System Architecture

Design scalable, maintainable system architectures.

When to Use

•Major architectural decisions
•System design discussions
•Evaluating trade-offs
•Planning large refactors
•Reviewing system structure

Design Process

•Understand - Clarify requirements and constraints
•Identify - Define components and boundaries
•Design - Create architecture with trade-offs
•Validate - Check against requirements
•Document - Record decisions and rationale

Architecture Patterns

Layered Architecture

code

┌─────────────────────────────┐
│      Presentation Layer     │  UI, API endpoints
├─────────────────────────────┤
│       Business Layer        │  Domain logic, services
├─────────────────────────────┤
│      Persistence Layer      │  Repositories, DAOs
├─────────────────────────────┤
│        Data Layer           │  Database, cache
└─────────────────────────────┘

Microservices

code

┌─────────┐  ┌─────────┐  ┌─────────┐
│ User    │  │ Order   │  │ Payment │
│ Service │  │ Service │  │ Service │
└────┬────┘  └────┬────┘  └────┬────┘
     │            │            │
     └────────────┼────────────┘
                  │
           ┌──────┴──────┐
           │ Message Bus │
           └─────────────┘

Event-Driven

code

Producer → Event Bus → Consumer(s)
              │
              ├→ Service A
              ├→ Service B
              └→ Analytics

Decision Framework

Trade-off Analysis

Aspect	Option A	Option B
Complexity	Low	High
Scalability	Limited	Horizontal
Cost	$	$$$
Time to market	Fast	Slow
Maintenance	Easy	Complex

ADR Template

markdown

# ADR-001: [Decision Title]

## Status

Accepted | Proposed | Deprecated

## Context

[Why we need to make this decision]

## Decision

[What we decided]

## Consequences

### Positive

- [Benefit 1]

### Negative

- [Trade-off 1]

### Risks

- [Risk 1]

Key Principles

•Separation of Concerns - Each component has one responsibility
•Loose Coupling - Minimize dependencies between components
•High Cohesion - Related functionality grouped together
•YAGNI - Don't build for hypothetical requirements
•Fail Fast - Detect and report errors immediately

Scalability Checklist

• Stateless services (session in Redis/DB)
• Horizontal scaling capability
• Database read replicas
• Caching layer (Redis, CDN)
• Async processing for heavy tasks
• Rate limiting and circuit breakers

Examples

Input: "Design a notification system" Action: Define channels, queue architecture, delivery guarantees, scaling strategy

Input: "Should we use microservices?" Action: Analyze team size, complexity, scaling needs, recommend with trade-offs