System Architecture Document Template
Create comprehensive system architecture documents with structured sections covering all technical aspects for scalable, secure software implementation.
# System Architecture Documentation Generator
## Role and Objective
You are an expert systems architect with extensive experience in designing scalable, secure, and maintainable software systems. Your task is to create a comprehensive System Architecture Document (SAD) for {project_name} that will serve as the definitive technical blueprint for implementation teams, stakeholders, and future maintainers.
## Document Structure
Please create a detailed system architecture document with the following sections:
1. **Executive Summary**
- Brief overview of the system purpose
- Key architectural decisions and their rationale
- High-level benefits of the chosen architecture
2. **Introduction**
- Project background
- System purpose and goals
- Scope and boundaries
- Intended audience for the document
- Referenced documents and standards
3. **Architectural Goals and Constraints**
- Business requirements driving architecture
- Technical constraints
- {specific_constraints}
- Budget and schedule constraints
- Assumptions and dependencies
4. **System Stakeholders and Concerns**
- Primary stakeholders
- Key concerns for each stakeholder group
- How the architecture addresses these concerns
5. **Architectural Viewpoints and Views**
- Context view (system in its environment)
- Functional view (features, capabilities)
- Information view (data models, flow, storage)
- Concurrency view (parallel processes, threading)
- Development view (code organization)
- Deployment view (physical infrastructure)
- Operational view (monitoring, management)
6. **System Components and Services**
- Component breakdown with detailed descriptions
- Purpose of each component
- Interfaces and APIs
- Dependencies between components
- Third-party components and integration points
- Technologies used for each component with version information
7. **Communication and Integration Mechanisms**
- Inter-component communication patterns
- API specifications
- Integration protocols
- Message formats and examples
- Synchronous vs. asynchronous interactions
8. **Data Architecture**
- Data models and schemas
- Database architecture (SQL/NoSQL decisions)
- Data flow diagrams
- Data retention policies
- Backup and recovery strategies
- Data migration considerations
9. **Security Architecture**
- Authentication mechanisms
- Authorization framework
- Data encryption (at rest and in transit)
- API security
- Network security measures
- Compliance with {relevant_security_standards}
- Audit logging and monitoring
- Threat modeling results
10. **Performance and Scalability**
- Performance requirements
- Scalability approach (vertical/horizontal)
- Caching strategies
- Load balancing approach
- Expected throughput and capacity
- Resource estimation
- Performance benchmarks and targets
11. **Reliability and Availability**
- Availability targets (e.g., 99.9%)
- Fault tolerance mechanisms
- Disaster recovery approach
- Backup strategies
- Failover mechanisms
- High availability design
12. **DevOps and Deployment Architecture**
- CI/CD pipeline
- Environment strategy (dev, test, staging, prod)
- Deployment process
- Configuration management
- Infrastructure as Code approach
- Monitoring and alerting
- Logging strategy
13. **Cross-Cutting Concerns**
- Internationalization and localization
- Accessibility compliance
- Audit and compliance features
- Monitoring and observability
- System health checks
14. **Architectural Decisions Record**
- Key decisions made
- Alternatives considered
- Decision rationale
- Implications and trade-offs
15. **Risk Assessment and Mitigation**
- Identified architectural risks
- Probability and impact analysis
- Mitigation strategies
- Contingency plans
16. **Future Considerations and Roadmap**
- Planned architectural evolution
- Technical debt management
- Anticipated scaling needs
- Future integration points
17. **Appendices**
- Glossary of terms
- Referenced standards and documentation
- Detailed diagrams
- API specifications
## Formatting Requirements
- Create clear, professional diagrams for all architecture views using standard notation (UML, C4, etc.)
- Include both high-level and detailed component diagrams
- Use tables where appropriate (e.g., for component responsibilities, API endpoints)
- Include sequence diagrams for key interactions
- Use consistent and precise technical terminology
- Provide a glossary for domain-specific or specialized terms
- Format all code examples, configuration snippets, and API specifications in appropriate code blocks
## Technical Considerations
Consider and address the following aspects in your architecture:
- {industry_specific_requirements}
- {compliance_requirements}
- {technology_constraints}
- {scalability_requirements}
- {performance_requirements}
- {security_requirements}
- {budget_constraints}
## Diagrams to Include
1. High-level system context diagram
2. Component breakdown diagram
3. Data flow diagrams
4. Deployment architecture diagram
5. Network topology diagram
6. Security architecture diagram
7. Integration points diagram
8. Database schema (conceptual)
9. Sequence diagrams for critical processes
10. State diagrams where applicable
## Quality Guidelines
The document should be:
- Comprehensive yet clear
- Technically precise
- Accessible to both technical and semi-technical stakeholders
- Consistent in terminology and notation
- Forward-looking but practical
- Justified in all architectural decisions
- Realistic about constraints and limitations
## Before You Begin
Please confirm that you understand the requirements and ask any clarifying questions about the system to be documented. To create the most relevant architecture, please provide:
1. What is the primary purpose of {project_name}?
2. What is the expected user/transaction volume?
3. What are the most critical non-functional requirements (security, performance, availability, etc.)?
4. Are there any existing systems this needs to integrate with?
5. What technology stack preferences or constraints exist?