Lesson 05 · Architecture & System Design

ADRs & Design Reviews

Your output is decisions — here's how to write one down in a page, and how to review one without wrecking the room.

Principal skill · decisions written down are decisions that stick
🎧 Listen to this lesson · ~8 min · narrated audiobook edition

⏱ ~9 min read · 🎧 8 min listen · ✎ 3 quizzes · 🧪 ~45 min lab

Back in Lesson 01 we landed on the sentence that defines this level: your output becomes decisions, documents, and direction. Here's the problem — a decision that lives in a meeting, a Slack thread, or one engineer's head evaporates. Six months later nobody remembers why, the debate reopens, and the org pays for the same decision twice. This lesson gives you the two tools that stop the leak: the Architecture Decision Record, which makes a decision durable, and the design review, which makes it good before it's durable.

Names in the wild Companies use different words for overlapping things: Google says "design doc" (per Malte Ubl's essay), many startups say "RFC" (LeadDev's guide to RFCs covers that culture), and "ADR" names the smallest of the family. Rough rule: RFCs and design docs propose and explore; an ADR records one decision after it's made. Ask what a document is for, not what it's called.

The ADR: a decision in one page

In 2011, Michael Nygard proposed something almost embarrassingly simple: for each architecturally significant decision, write a short text file — one or two pages, numbered, stored in the repo next to the code it governs.1 That post became the canonical format, and an entire ecosystem of templates and tooling grew around it.2 Nygard's format has just four working parts:

SectionWhat it answersThe trap to avoid
ContextWhat forces are at play — technical, political, project-local. Why is a decision needed now?Assuming tribal knowledge a new hire won't have
Decision"We will…" — the response to those forces, in active voice, full sentencesHedging. An ADR records a decision, not a discussion
StatusProposed → accepted → later, possibly deprecated or superseded by a newer ADREditing old ADRs. Supersede them; never rewrite history
ConsequencesThe resulting context — all of it: positive, negative, and neutralListing only the upsides (more on this below)
Superseded, never edited The status rule is the quiet genius of Nygard's format: an outdated ADR gets a successor, not a rewrite. That turns your decision log into something like git history for the architecture — you can replay not just what the system believes now, but every position it held on the way there, and why each one made sense at the time.

Why bother writing it down? Three payoffs, and each one maps to your mission. Onboarding: a new engineer reads the decision log and absorbs in an afternoon what took the team years of arguments — Nygard's original motivation.1 Un-relitigating: when someone asks "why don't we just use X?", the answer is a link, not a week-long debate that ends where it started. Promotion evidence: an ADR has your name on it, a date, and a decision that shaped the system — it's the most legible artifact in your evidence trail, and interviewers at Principal loops increasingly ask "walk me through a decision you documented."

What makes an ADR good

A bad ADR is a press release: three benefits, zero costs, alternatives dismissed in a sentence. A good ADR is an honest trade-off record — Lesson 02 in miniature. Two tests separate them. First, the consequences section names at least one genuine downside of the chosen option — because after Lesson 02 you know there is always one; a consequences list with no negatives means the author stopped thinking or started selling. Second, the alternatives section would satisfy an advocate of the rejected option: each alternative is written with its real strengths, so the person who argued for it reads the ADR and says "yes, that's a fair account of why we didn't." Software Architecture: The Hard Parts models this discipline at book length — every significant decision in it lands as an ADR with trade-offs attached.3

Your template — keep this one open I've built you a printable ADR template: the blank format ready to copy into your repo, a short worked example ("Use event-driven messaging between Orders and Inventory"), and a six-item good-ADR checklist. It's the tool for this lesson's lab — and for every real decision after it.
A small template zoo The adr.github.io hub (this lesson's primary source) collects more than one format — Nygard's original alongside MADR, a more structured markdown variant from the same community. The course template follows Nygard. In practice the choice matters far less than consistency: pick one format for the repo and let the numbering, not the schema, do the work.

Design reviews that actually work

An ADR records the decision; a design review is where the decision gets stress-tested — and it's where Principals are most visible, for better or worse. Google runs on this loop: design docs circulated and reviewed before code, with the explicit goal of surfacing trade-offs early, when changing course is still cheap.4 Most design reviews fail the same four ways — and each failure has a precise fix:

The failureThe fix
Everyone reads the doc live, in the meetingCirculate it days before. The meeting is for discussion, not first contact — written proposals gather better feedback asynchronously5
Debate jumps straight to the solutionReview the problem first. Ask "is this the right problem, correctly framed?" before touching the design — a beautiful solution to the wrong problem is worthless
Reviewers issue verdicts ("you should have used Kafka")Ask questions instead. "What happens when the queue backs up?" teaches, keeps authors owning their design, and might reveal you're missing context
Review becomes a rubber stampAdopt the reviewer stance: "what would have to be true for this to fail?" — hunt for the load-bearing assumptions, then ask about those
The mental model in one line Write decisions so a stranger could understand them cold; review designs so the author leaves smarter and still owning the design. Records that are honest, reviews that are questions.

🧪 Lab: write a real ADR

Not a toy — a real ADR, for a decision your team made in the last few months (or is making right now): a library choice, a service boundary, a datastore, a build-vs-buy call. Open the template and:

  1. Pick the decision — one with real stakes and at least one credible alternative that someone actually argued for.
  2. Write the context cold — as if the reader joined the company yesterday: the forces, the constraints, why a decision was needed at all.
  3. State the decision in active voice ("We will…"), then write the alternatives — each with its genuine strengths, not a strawman.
  4. Write honest consequences — positive, negative, and neutral. If you can't find a negative, you haven't finished thinking.
  5. Run the checklist in the template, then — if the decision is current — circulate it to one teammate who preferred a different option and ask: "is your side fairly represented?"

Feedback loop: bring the ADR back to me in chat. I'll review it against a Principal-level rubric — does the consequences section name at least one genuine downside of the chosen option, would a rejected-option advocate feel fairly represented by the alternatives, and could a new hire understand the context cold. This artifact goes straight into your evidence trail; Lesson 12 will slot it into the promotion packet, and it's a ready-made answer to the interview question "tell me about a significant technical decision."

🤖 Get your work reviewed

No chat here — this box replaces it. Copy the prompt into any AI assistant (Claude, ChatGPT, Gemini…), then paste your ADR after it.

You are a seasoned Principal Engineer reviewing my work: an Architecture Decision Record (ADR) in Nygard's format. Grade it against this rubric:

- Honest consequences: the consequences section names at least one genuine downside of the chosen option, alongside positives and neutrals.
- Fair alternatives: each rejected option is written at its strongest — an advocate of it would say "yes, that's a fair account of why we didn't."
- Cold-readable context: a new hire could understand the forces and constraints with no tribal knowledge.
- A real decision: stated in active voice ("We will…"), not hedged into a discussion.

Grade each criterion Strong / Adequate / Missing with one sentence of evidence from my ADR. Be skeptical — challenge the weakest claim first. Then ask me 2–3 follow-up questions a design-review panel would ask. Finish with the single highest-leverage improvement.

My ADR follows below.

Check yourself — review the reviewers

Three scenarios. Diagnose from the mental model — honest records, questioning reviews. Wrong picks stay live.

Scenario A

A teammate drafts an ADR adopting a new message queue. The consequences section lists three benefits and zero costs; the alternatives section dismisses "Postgres as a queue" in one line: "doesn't scale." You're reviewing the ADR. What's the highest-value feedback?

Scenario B

You're the senior reviewer in a design review for splitting a service in two. Ten minutes in, you're fairly sure the proposed split is wrong — it cuts across the hottest data path. The room defers to you. What's the Principal move?

Scenario C

A new hire asks why the team self-hosts Kafka instead of using the cloud provider's managed service. Nobody quite remembers. A week-long debate reopens — and lands on the same conclusion as two years ago. What does this actually reveal?

Primary source — read this
The canonical home of the practice: Nygard's format, the MADR template, tooling, and examples — maintained by the researchers and practitioners who standardized ADRs. Pair it with Software Architecture: The Hard Parts, which practices what this lesson preaches: every major decision in the book is written up as an ADR.
Your one tangible win You have a real ADR, for a real decision, written to a standard most working engineers never see: honest consequences, fairly-argued alternatives, context a stranger could follow. And you know the four moves that make a design review produce better designs instead of bruised authors.
Questions? Take them to any AI assistant. Not sure which team decision is "architecturally significant" enough for the lab? Paste the relevant section of this lesson plus your question into Claude, ChatGPT, or whichever assistant you use — or ask it to play the rejected-option advocate against your alternatives section. For a full review of your draft ADR, the review box above has you covered.

Recommended learning

Hand-picked follow-ups. None are required — the primary source above comes first.

References

  1. Michael Nygard, "Documenting Architecture Decisions" (Cognitect blog, 2011) — the original ADR format: title, context, decision, status, consequences; one to two pages.
  2. adr.github.io — the ADR GitHub organization: canonical hub for templates (incl. MADR), tooling, and examples.
  3. Neal Ford, Mark Richards, Pramod Sadalage & Zhamak Dehghani, Software Architecture: The Hard Parts (O'Reilly, 2021) — documents every significant decision as an ADR with explicit trade-offs.
  4. Malte Ubl, "Design Docs at Google" — design docs written and reviewed before code, with emphasis on trade-offs.
  5. Juan Pablo Buriticá, "A thorough team guide to RFCs" (LeadDev) — circulating written proposals for asynchronous comment before decisions.