architecture-patterns

Architecture Patterns

How to structure an application so it survives change — coupling and cohesion, dependency direction, hexagonal and clean architecture, DDD, CQRS, event sourcing, and decomposing a monolith without building a distributed one.

12 units·36 lessons·~14 h

Start track →

Start here

What architecture actually is, and the frame — fitness for forces — you carry into every structural decision.

01 What architecture actually is 18 min 02 Fitness and tradeoffs 20 min

Coupling and cohesion

The two forces every structural decision trades between: how parts depend on each other, and how focused each part is.

01 Coupling forms 22 min 02 Cohesion 20 min 03 Connascence 22 min

Dependency direction

Who is allowed to know about whom — the dependency rule, and how to invert it when it points the wrong way.

01 The dependency rule 20 min 02 Dependency inversion 22 min 03 Acyclic and stable abstractions 24 min

Layered architecture

The n-tier default everyone starts with, why it is reasonable, and exactly where it leaks.

01 N-tier layered architecture 20 min 02 Anemic vs rich domain model 22 min 03 Where layering leaks 22 min

Hexagonal architecture

Ports and adapters: invert the boundary so the domain owns the contract and the outside world plugs in.

01 Ports and adapters 22 min 02 Driving and driven sides 22 min 03 Testing at the boundary 24 min

Clean and onion architecture

The concentric dependency rule, use-case interactors, and the entity core — and the boilerplate tax it charges.

01 The concentric dependency rule 22 min 02 Use cases and interactors 22 min 03 The entity core and the cost 24 min

Domain-driven design

Model the business so the model is the architecture: bounded contexts, ubiquitous language, aggregates, and the strategic map.

01 Bounded contexts 24 min 02 Ubiquitous language 20 min 03 Aggregates and invariants 24 min 04 Context mapping 26 min

CQRS

Split the write model from the read model — what it buys, what it costs, and when the split is overkill.

01 Command-query split 22 min 02 Read models and projections 24 min 03 When CQRS is overkill 20 min

Event sourcing

The event log as the source of truth — state as a fold over events — and the traps that come with it.

01 Events as the source of truth 26 min 02 Projections, replay, and snapshots 28 min 03 The traps 28 min

Event-driven architecture

Structuring a system around things that happened: choreography vs orchestration, sagas, and eventual consistency as a design choice.

01 Choreography vs orchestration 25 min 02 Sagas 25 min 03 Eventual consistency as a design choice 25 min

Decomposition

One app or many, and how to get from one to the other without accidentally building a distributed monolith.

01 The Modular Monolith 22 min 02 Monolith to Services 25 min 03 The Distributed Monolith 22 min

Evolution and decisions

Architecture is a verb — ADRs, fitness functions, and reasoned tradeoff analysis that change it on purpose.

01 Architecture Decision Records 20 min 02 Fitness Functions and Evolutionary Architecture 22 min 03 Tradeoff Analysis 25 min

Build with this track

Guided projects that exercise what you learn here.

◆ Projects

B2B Order & Billing Platform Architecture

Design the architecture of a B2B order and billing platform end-to-end: carve bounded contexts from the problem space, assign a structural style to each (layered, hexagonal, or clean/onion), decide where CQRS, event sourcing, and event-driven sagas are warranted, choose between a modular monolith and a set of services while explicitly avoiding the distributed monolith trap, and justify every significant decision with an Architecture Decision Record backed by a fitness function you can actually measure.

Next track

Code patterns & craft

Code is read far more than it is written. Learn the craft that keeps a codebase changeable — naming, SOLID, code smells, and safe refactoring — plus the judgment to know when an abstraction earns its keep.