System Architect

Design system architectures across monolith, modular monolith, microservices, or serverless patterns with technology selection and NFR mapping.

Updated Dec 4, 2025
One-click install
npx skills add https://github.com/co-cddo/innovation-sandbox-on-aws-deployer --skill system-architect-co-cddo
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: System Architect
Source: https://github.com/co-cddo/innovation-sandbox-on-aws-deployer/tree/main/.claude/skills/bmad/bmm/architect
Command: npx skills add https://github.com/co-cddo/innovation-sandbox-on-aws-deployer --skill system-architect-co-cddo

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Designing a system architecture that effectively meets all functional and non-functional requirements, while considering scalability, security, and maintainability, is a critical and complex task. This Skill automates the structured creation of architectural designs.

Core Features & Use Cases

  • Architecture Design: Designs comprehensive system architectures, selecting appropriate technology stacks and defining components, boundaries, and interfaces.
  • NFR Mapping: Systematically addresses non-functional requirements like performance, scalability, and security with specific architectural decisions.
  • Decision Documentation: Documents architectural decisions, trade-offs, and their rationale, providing a clear blueprint for development.
  • Use Case: After your PRD is finalized, use this Skill to design the system architecture. It will consider your project's NFRs (e.g., 99.9% availability, 10,000 concurrent users) and propose patterns like Modular Monolith or Microservices, along with technology choices.

Quick Start

Design the system architecture for the 'MyApp' project based on the existing PRD. /architecture

Frequently Asked Questions about System Architect

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I design a system architecture that meets functional and non-functional requirements?

System architecture design involves defining components, boundaries, and interfaces while systematically addressing non-functional requirements like performance, scalability, and security. The process maps requirements to specific architectural patterns—monolith, modular monolith, microservices, or serverless—and justifies technology choices with documented trade-offs.

What architectural patterns should I choose for scalability and security?

Pattern selection depends on your non-functional requirements. Microservices excel at independent scaling and fault isolation; serverless optimizes for variable load; modular monoliths balance complexity and maintainability; traditional monoliths suit simpler, lower-scale projects. Each pattern carries distinct trade-offs in operational complexity, data consistency, and deployment overhead.

How do I document architectural decisions and their rationale?

Architectural decision documentation captures the chosen pattern, technology stack, component boundaries, and the specific NFRs each decision addresses. Clear rationale linking decisions to requirements—such as 99.9% availability or 10,000 concurrent users—provides the development team a blueprint and stakeholders visibility into trade-offs.

When should I use microservices versus a monolithic architecture?

Choose microservices when you need independent scaling, technology diversity per service, or rapid deployment cycles—typically at higher user concurrency and complexity. Use monolithic or modular monolith approaches for smaller scope, tighter consistency requirements, or teams preferring simpler operational models.

Can I design architecture for serverless and traditional infrastructure together?

Yes. Hybrid architectures combine serverless functions for variable-load workloads with traditional services for stateful or compute-intensive components. This requires clear API contracts and messaging patterns between layers, trading simplicity for flexibility in cost and scaling behavior across different compute models.

What inputs do I need before designing system architecture?

Start with a finalized PRD, functional requirements, and explicit non-functional requirements—target availability, concurrent users, latency, throughput, and security constraints. Architectural design translates these into component topology, technology stack, data models, and API specifications.