What is a software architecture document?
A system analysis, design and architecture document describes a system at a high level: its context and logical architecture as diagrams, its components, integrations, data, security, deployment and the key decisions. For software, digital and integration concepts.
Also called: System analysis, design and architecture, System design document, SAD.
Why it matters
Architecture is decided early, whether anyone writes it down or not. Written down, each choice shows its alternatives, and the quality targets the system must meet are set before they are costly to change.
From context to decisions
The document is drawn from the PRD and from the same system model as the FRS.
- Context. The system as one box: who uses it and what it exchanges data with, as a diagram. In Ainna's document: the system in context.
- Structure. The logical architecture: its layers and components, and each component's responsibilities. In Ainna's document: the logical architecture; components and their responsibilities.
- Qualities. Quality attributes with targets, security, and the deployment and recovery objectives. In Ainna's document: quality attributes, security, deployment.
- Decisions. Each significant choice, with the alternatives considered and why this one won. In Ainna's document: architecture decisions.
What's inside, part by part
- The architecture in brief
- The system, on one page.From the system model.
- What drives it
- The requirements and constraints that shape it.From the PRD.
- The system in context, as a diagram
- Who and what it exchanges data with.From the system model.
- The logical architecture, as a diagram
- Its layers and components.From the system model.
- Components and their responsibilities
- What each part does.From the system model.
- Integration patterns
- How it connects to other systems.From the system model.
- Data and its stores
- What data it keeps, and where.From the system model.
- Quality attributes, with targets
- The qualities it must have, with targets.From the PRD.
- Security
- How it protects its users and their data.From the system model.
- Deployment and recovery objectives
- How it runs, and how fast it recovers.From the system model.
- Architecture decisions
- Each significant choice, with the alternatives considered.From the system model.
- Risks and transition
- What could go wrong, and how it moves into production.From the PRD and the system model.
Where it fits
It is distilled from the PRD, and the same system model as the FRS.
It comes after the Product Requirements Document (PRD) and the Functional Requirements Specification (FRS).
How the architecture document compares with related documents
| Document | Answers | Read by | Length |
|---|---|---|---|
| Product Requirements Document (PRD) | What to build, and why | Product, engineering, design and leadership | About 20 pages |
| Functional Requirements Specification (FRS) | Exactly how the system must behave, testably | Engineers and testers | 13 pages |
| System Analysis, Design and Architecture | How the system is put together | Architects and engineers | 9 pages, with diagrams |
Questions
Can AI design a software architecture?
It can propose one. Ainna writes the architecture from the PRD and a system model, and states each decision with its alternatives, for your engineers to challenge.
What goes into a software architecture document?
Ainna's covers the system in context and its logical architecture, both as diagrams; the components and their responsibilities; how it integrates with other systems; its data and where it is stored; quality attributes with targets; security; deployment and recovery objectives; and the key architecture decisions with their alternatives.
What is a system context diagram?
One picture of the system as a single box, the people who use it and the systems it exchanges data with. It is the first diagram an architecture document needs.
What is an architecture decision record?
A short note for each significant choice: the decision, the alternatives considered, and why this one won.
Architecture document or FRS?
The FRS says what the system must do. The architecture document says how it is structured to do it, and how well it must perform.
Yours comes from the work, not from a prompt
- It is written from the PRD and the same system model as the FRS, so the two never contradict each other.
- Each architecture decision is stated with the alternatives considered.
- Where a piece of the work is missing, the document leaves it out instead of filling it with plausible text.
- It agrees with every other document Ainna makes from the same idea, because they all come from one body of work.
- It is yours to edit as a Word file, and it can carry your logo.
Create yours in Ainna.
Ainna is where you frame a problem, explore ideas and test them against the evidence. When the work is done, Ainna packages it as a software architecture document like this one: from your own analysis, about your own idea.
Which documents you can create depends on your plan.
Read next
- The problem behind this sample: no. 0032 on the Problem Radar
- See all twelve document examples





