The bridge from developer to architect: the measure of a design is how well it survives change, not how clever it is.

Sets up the trade-off habit and the vocabulary that every later step assumes.

Styles, risks, and costs later in the path are all measured against these, so you need the short list before you can trade anything.

Coupling is what nearly every later decision is really arguing about, and this gives you a way to measure it.

The argument underneath the rest of the path: where authority lives decides what a system can absorb. Every later decision is a version of that question.

The first concrete act of design: finding components from workflows and actors, and avoiding the entity trap.

Bounded contexts give component boundaries a business reason to exist, which is what keeps them from eroding.

Teams and system boundaries shape each other. Draw one without the other and Conway's Law redraws it for you.

Turns characteristics and boundaries into a decision: which style gives you the ones you need by default.

An argument for sequencing: stay monolithic while you learn the domain, and distribute only what you've learned needs it.

The style that argument points to, and the one whose module boundaries make every later split cheaper.

Before a module becomes a service, know what the network will cost you and how to tell whether the split is real.

Three successive designs for one problem, including a pipeline style that never fit it, and the organizational pattern that outlived all three.

The basic ways parts interact, compared by the coupling each one creates.

An argument to settle before designing any interface: a domain-driven system exposes operations, and REST's resource model fights that.

APIs are the longest-lived contracts you'll design. This is how to make them hold up and evolve.

The argument for separating read workloads from production, which the next step turns into patterns.

Who owns which data once one database becomes several, and how reads stay fast without shared tables.

Sound data patterns undone by an infrastructure constraint nobody weighed, which is what the next level's decision discipline exists to catch.

The argument for this level: spend design time in proportion to how expensive a decision is to reverse.

Which decisions are yours to make, when to make them, and how to keep them from being relitigated.

The record the previous step asks for, ready to copy for your first decision.

A decision nobody can picture doesn't travel. C4 gives each audience a diagram at the right zoom level.

Ranks where your chosen design is likely to fail its characteristics, so mitigation goes where it matters.

Prices a decision over its whole life, which is the argument that gets it funded.

One boundary decision followed from options to consequences, including taking on debt on purpose.

Applies the authority argument to security: legitimacy should come from verified identity, not network position.

The design-time practice for finding what that argument predicts: threats across trust boundaries, before they're built.

Five separate auth implementations unified behind one abstraction before any could be replaced, with every request validated and customer and service identity kept apart.

Once parts talk over a network, one slow dependency can take down the rest. These patterns are how a design keeps a failure local.

A system that can't tell handled from broken can't be operated, whatever platform sits behind it. That classification is a design decision.

Teams you don't manage carry out most of your decisions. This is how to lead them without becoming the bottleneck.

Debt everyone can see but nobody funds is the usual reason a system has to be modernized at all. This is the vocabulary that makes the case before it gets there.

When the fix is a replacement: how to change a system the business keeps running on, without a rewrite.

Scales everything above past one team: who decides what, and how the organization notices when a decision stops working.

The argument for this last stage: every plan assumes someone will notice when it's wrong and stop, and plan continuation bias keeps teams building what they already know is wrong.

The three phases, and the rule that makes them work: going back is part of the method, not a failure of it.

Discovery with the people who have the need, and the Go, Pivot, or No-Go call made before anyone commits to a plan.

Turning alignment into a plan people commit to. The boundaries, style, decisions, and risks from earlier in the path all come together here.

Delivering against the agreement, with circuit breakers that force the continue, adapt, or go back decision.