Skip to content

Architecture & Design

The track that turns a strong senior engineer into a Staff/Principal architect: trade-off thinking, decomposition (DDD, styles, coupling), the patterns that make distributed systems correct (hexagonal, CQRS/ES, sagas, outbox), the practices that keep architecture alive (ADRs, C4, fitness functions, modernization), the sociotechnical layer (Team Topologies), and — new in 2026 — how to treat LLMs and agents as first-class system components.

Track at a glance

19 topics · ~53 h of core study · Phases 1–5 · Question bank: questions.md (60+ graded questions, 16 katas, 25 rapid-fire) Outcome: you can decompose an ambiguous domain, choose and defend an architecture style, record the decision, evolve it safely, and design AI-enabled systems with clear autonomy and trust boundaries, in interviews and on the job.

Reading order

Read top to bottom; each page's You're done when line is the exit check before moving on.

  1. The architect role & trade-off thinking — P0, ~2 h
  2. Architecture styles: modular monolith → microservices → event-driven → serverless — P0, ~4 h
  3. DDD strategic: subdomains, bounded contexts, context maps — P0, ~4 h
  4. DDD tactical: aggregates, entities, value objects, domain events — P0, ~3 h
  5. Hexagonal / clean architecture, ports & adapters — P0, ~3 h
  6. CQRS & event sourcing — P1, ~4 h
  7. Sagas, outbox & distributed transactions — P0, ~3 h
  8. Enterprise integration patterns — P1, ~3 h
  9. Coupling, cohesion & modularity (balanced coupling) — P0, ~3 h
  10. Design patterns that still matter (GoF, modern) — P1, ~3 h
  11. SOLID, refactoring & code quality at scale — P1, ~2 h
  12. C4, arc42 & diagrams as code — P0, ~2 h
  13. Architecture Decision Records — P0, ~1 h
  14. Evolutionary architecture & fitness functions — P1, ~2 h
  15. Legacy modernization & strangler fig — P0, ~3 h
  16. Team Topologies & Conway's law — P0, ~2 h
  17. API contracts, versioning & schema evolution — P1, ~2 h
  18. Data architecture: lakehouse, data mesh, CDC — P1, ~3 h
  19. AI-native architecture: LLMs as system components — P0, ~4 h

Topic table

# Topic Priority Complexity Phase Hours
1 The architect role & trade-off thinking P0 2 1 2
2 Architecture styles: modular monolith → microservices → event-driven → serverless P0 3 1 4
3 Design patterns that still matter (GoF, modern) P1 2 1 3
4 SOLID, refactoring & code quality at scale P1 2 1 2
5 Architecture Decision Records P0 1 1 1
6 DDD strategic: subdomains, bounded contexts, context maps P0 3 2 4
7 DDD tactical: aggregates, entities, value objects, domain events P0 3 2 3
8 Hexagonal / clean architecture, ports & adapters P0 2 2 3
9 Coupling, cohesion & modularity (balanced coupling) P0 3 2 3
10 CQRS & event sourcing P1 4 3 4
11 Sagas, outbox & distributed transactions P0 4 3 3
12 Enterprise integration patterns P1 3 3 3
13 API contracts, versioning & schema evolution P1 3 3 2
14 C4, arc42 & diagrams as code P0 2 4 2
15 Evolutionary architecture & fitness functions P1 3 4 2
16 Legacy modernization & strangler fig P0 3 4 3
17 Team Topologies & Conway's law P0 2 4 2
18 AI-native architecture: LLMs as system components P0 4 4 4
19 Data architecture: lakehouse, data mesh, CDC P1 3 5 3

How the topics fit together

flowchart TB
    A[1 Architect role & trade-offs] --> B[2 Architecture styles]
    A --> E[5 ADRs]
    B --> F[6 DDD strategic]
    F --> G[7 DDD tactical]
    F --> I[9 Coupling & modularity]
    G --> H[8 Hexagonal]
    H --> J[10 CQRS & ES]
    G --> K[11 Sagas & outbox]
    K --> L[12 Integration patterns]
    I --> M[13 API contracts]
    E --> N[14 C4 / arc42]
    I --> O[15 Evolutionary arch]
    B --> P[16 Legacy modernization]
    F --> Q[17 Team Topologies]
    H --> R[18 AI-native architecture]
    K --> R
    O --> R
    J --> S[19 Data architecture]
    L --> S
    C[3 Design patterns] -.supports.-> H
    D[4 SOLID & refactoring] -.supports.-> H

Total core reading and labs: about 53 h; plan 12–15 h/week alongside other tracks.

  1. Phase 1 — Frame the job (≈ 12 h). Architect role, styles, ADRs first (P0). Design patterns and SOLID are refreshers for a 15-year engineer; skim, then do the labs (the LLM decorator pipeline and the characterisation-test refactor are the valuable parts). Deliverable: your first three ADRs in the capstone repo.
  2. Phase 2 — Decompose (≈ 13 h). DDD strategic → tactical → hexagonal → coupling. Do the EventStorming lab on a domain you know and the balanced-coupling review on real code. Deliverable: context map + one aggregate with a concurrency test + an import-linter contract.
  3. Phase 3 — Make it correct across boundaries (≈ 12 h). Sagas & outbox first (P0), then integration patterns, API contracts, CQRS/ES (P1; read critically, decide when not to use it). Deliverable: outbox + idempotent consumer + saga passing chaos tests; compatibility gates in CI.
  4. Phase 4 — Keep it alive and connect to AI (≈ 13 h). C4/arc42, evolutionary architecture, legacy modernization, Team Topologies, then AI-native architecture as the synthesis. Deliverable: C4 model as code, five fitness functions, and an ADR-backed AI capability with autonomy level and evals.
  5. Phase 5 — Data (≈ 3 h). Data architecture, once CQRS, outbox and CDC are familiar.

Then drill: the question bank — do L3/L4 questions and katas out loud (< 3 min each for L3, 10–15 min for katas), one kata per weekend.

Key books (priority order)

Book Why Covers topics
Fundamentals of Software Architecture, 2nd ed. (Richards & Ford) The vocabulary and the styles chapters 1, 2
Software Architecture: The Hard Parts (Ford, Richards, Sadalage, Dehghani) Decomposition, data, sagas, coupling — the Staff-level trade-off book 2, 9, 11
Learning Domain-Driven Design (Khononov) The clearest modern DDD 6, 7
Balancing Coupling in Software Design (Khononov) 💎 The coupling model used throughout this track 9
Architecture Modernization (Tune & Perrin) 💎 DDD + sociotechnical modernization 6, 16, 17
Cosmic Python (Percival & Gregory; free online) 💎 Hexagonal, repository, UoW, events in Python 7, 8, 10, 11
Building Evolutionary Architectures, 2nd ed. Fitness functions 15
Team Topologies (Skelton & Pais) Conway, team types, cognitive load 17
Microservices Patterns, 2nd ed. (Richardson) and microservices.io Sagas, outbox, decomposition; the site is free 2, 11
Enterprise Integration Patterns (Hohpe & Woolf) and its free site The integration vocabulary 12
The Architect Elevator (Hohpe) The Staff+ role between penthouse and engine room 1
Designing Data-Intensive Applications, 2nd ed. (Kleppmann & Riccomini) Foundations for CQRS, CDC, data architecture 10, 19
A Philosophy of Software Design (Ousterhout) Counterweight to over-abstraction 3, 4

The curated, machine-readable list lives in data/resources/architecture.yml.

Practice for this chapter

Practice these patterns on the capstone: write one ADR per week recording a real decision (repo, sagas, module boundaries...). The capstone keeps a backlog of 15 decisions to record this way.

There's no dedicated architecture round in most loops — it's examined inside system-design and Staff prompts. Use Staff+ → Interview prep for the ambiguous, organisational-scale prompts this track prepares you for.

Capstone tie-in

Every topic's lab builds a piece of one running example — a container-logistics booking and tracking platform with an AI exception-handling agent: modular monolith with import-linter contracts → bounded contexts and an aggregate → hexagonal core with an LLM port and gateway → outbox and booking saga → C4 model and ADR log → fitness functions and evals in CI → strangler-style extraction of tracking ingest. Keep it in one repo so the ADRs, diagrams and code evolve together.