Architecture decisions and ADRs
Architecture is a series of decisions, and most of their value is lost if only the outcome survives. Six months later someone asks "why didn't we use Kafka here?", nobody remembers, and the debate starts again, or worse, the decision is reversed by someone who doesn't know what it protected. An architecture decision record is a short document that keeps the why. This module covers how to make decisions, how to record them, and the antipatterns they prevent.
1. The idea
| Section | What goes in it |
|---|---|
| Title | Numbered and short, phrased as the decision: "ADR-014: Use asynchronous messaging between Orders and Payments" |
| Status | Proposed, Accepted, Superseded by ADR-031, (or RFC with a deadline for comments) |
| Context | The forces at play: the problem, the constraints, the characteristics that matter, the options considered |
| Decision | What we will do, stated firmly ("we will"), with the justification. Why matters more than how. |
| Consequences | What becomes easier and what becomes harder: the trade-offs, including the negative ones |
| Compliance | How we'll know the decision is followed: the fitness function (Module 26) or review that checks it |
| Notes | Author, date, who approved it, links |
Which decisions deserve one?
Ones that are expensive to reverse or affect several teams (the architecture end of the spectrum from Start here): a style, a data-ownership rule, a communication pattern, a shared technology. Not every library choice. A useful test: would a new team member six months from now plausibly ask "why is it like this?"
Three decision antipatterns
- Covering your assets: avoiding or postponing decisions for fear of being wrong. Teams wait, or decide without you.
- Groundhog Day: the same decision is discussed again and again because nobody recorded why it was made.
- Email-driven architecture: decisions announced in emails and chat threads that half the people never see, and nobody can find later.
2. How it works
Groundhog Day, and the cure
An ADR's life
Decisions aren't permanent. ADRs aren't edited when things change; they're superseded, so the history stays readable.
3. Try it yourself
Write an ADR and check it
The team must decide how the Orders service stores product prices. Fill in the record by choosing what goes in each section, and see the record and its quality check update.
4. Trade-offs
Speed vs consultation
Deciding alone is fast and breeds resentment; consulting everyone is slow. Use the RFC status: propose, set a deadline for comments, then decide and record the dissent.
Short vs complete
A one-page ADR gets read; a ten-page one doesn't. Link to detailed analysis instead of including it.
Every decision vs important ones
Recording everything buries the important decisions; recording too little loses them. Record what's expensive to reverse or crosses teams.
Wiki vs repository
ADRs in the code repository are versioned with the code and reviewed in pull requests; in a wiki they're easier for non-developers to find. Either works if everyone knows where they are.
5. In real projects
Adding ADRs to an existing system. Don't try to document ten years of history. Record new decisions from today, and write ADRs for old decisions only when they come up for debate: the next time someone asks "why do we use X?", the answer becomes ADR-001.
Architecture stories and narratives. Alongside user stories, some teams write architecture stories ("as an architect, I need the order data split from payments so that payments can be scaled and audited separately") to get architecture work onto the backlog with its business reason.
Avoid analysis paralysis. If a decision is reversible (Module 06), time-box it and record it as "revisit after the load test". An ADR doesn't have to be the final word to be valuable.
Review boards that don't become the bottleneck
Many organisations put a formal architecture review board (ARB) between a design and its delivery. The classic version fails in predictable ways:
- It reviews too late. Designs arrive when the team has already built half of it, so the only possible verdicts are "approve" or "start again".
- It meets too rarely. A monthly board with a two-month queue is slower than most delivery cycles, so teams route around it or present designs that are already shipped.
- Reviewers lack context. Five senior people read a document for twenty minutes and decide something the team spent three months understanding.
- It owns decisions it doesn't live with. The board approves; the team carries the pager. Accountability and authority split.
The lightweight alternative keeps the decision with the team and makes advice the obligation. Andrew Harmel-Law calls it the advice process: anyone can make an architecture decision, but first they must consult everyone meaningfully affected by it and people with expertise in the area. Four supporting elements make it work at scale: decision records (this module), a weekly, open architecture advisory forum where proposals are discussed, team-sourced architecture principles, and a technology radar of what's adopted, trialled or on hold.
| Tier | Which decisions | Process |
|---|---|---|
| Team | Reversible, inside one team's boundary | Decide, record an ADR if it's significant |
| Advice | Affects other teams, or a shared resource | Seek advice from affected teams and an expert; record the advice in the ADR |
| Forum | Expensive to reverse, crosses many teams, or breaks a principle | Present at the advisory forum within a week; a named decider decides; dissent recorded |
Governance then lives in three cheap places instead of one expensive meeting: principles that teams apply on their own, fitness functions that check the rules automatically (Module 26), and a forum for the few decisions that genuinely need many eyes. A review checklist for the forum is on the Templates page.
Dissent and consensus
Disagreement about a significant decision is healthy; unresolved or hidden disagreement is not. Habits that turn it into better decisions:
- Name one decider. Consensus is a goal, not a requirement. Everyone knows who decides and by when, so a single holdout can't stall the decision indefinitely.
- Argue against the strongest version. Restate the other option at its best before criticising it; if its supporters agree with your summary, the debate is about the real trade-off.
- Agree what evidence would decide it. "If the load test shows p99 under 200 ms on Postgres, we don't need DynamoDB." A spike or a prototype ends many arguments that meetings can't.
- Record the dissent. The ADR names the objection, who raised it and why it was overruled. People commit more easily when their view is on record, and the next reviewer sees the risk that was accepted.
- Disagree and commit, with a review date. Once decided, everyone supports the decision; the ADR says when or on what signal it will be revisited.
Say it in the interview
- "How do you document architecture decisions?" Architecture decision records: one short document per significant decision with context, decision, consequences and how compliance is checked, kept with the code. Old ones are superseded, never edited.
- "How do you stop the same debate recurring?" Record the decision with the reasons and the options rejected; when it comes up again, point to the ADR and ask what's changed.
- "How do you govern architecture without slowing teams down?" Teams decide, after seeking advice from the people affected and an expert, and record the decision. Only expensive, cross-team decisions go to an open weekly forum, and fitness functions check the rules automatically.
- "What makes a good ADR?" Clear context with the constraints, a firm decision with its justification, honest negative consequences, and a way to check it's followed.
- Decisions that live in chat threads.
- A consequences section with only benefits.
- ADRs edited in place, losing the history.
6. Remember it
How this hook works: what "write down the why, and the price" means
What the slogan means, phrase by phrase
- "Write down the why"
- Context and justification: the part that's lost first and needed most.
- "and the price"
- The negative consequences, so nobody is surprised and the trade-off can be revisited honestly.
Why this picture fits: the code already shows what was done; the record adds what code can't: the reasons and what was given up.
The story → the concept
| Ship's logbook | ADR |
|---|---|
| "Changed course to 270°" | The decision |
| "to avoid the storm reported at 14:00" | The context and justification |
| "arrival delayed six hours" | The consequences |
| A new entry, not a crossed-out one | Superseding, not editing |
The trap it saves you from
Groundhog Day: the same debate every month, forever.
7. Common mistakes
8. Design exercise (30 minutes)
- Find a Groundhog Day (5 min). Which decision does your team keep re-discussing?
- Write its ADR (20 min). Use the seven sections. Include at least two options considered and at least one negative consequence.
- Add compliance (5 min). Write how you'd know if the decision stopped being followed.
9. Self-check quiz
A decision recorded in ADR-014 is changed. What do you do?
The team discusses whether to adopt GraphQL every few months. Which antipattern?
What must the consequences section include?
What does the compliance section describe?
How do you introduce ADRs to a ten-year-old system?
Under the advice process, what must someone do before making an architecture decision?
10. Go deeper
| Resource | Time | Why |
|---|---|---|
| Documenting Architecture Decisions (Michael Nygard) | 10 min | The blog post that started ADRs. |
| Scaling the Practice of Architecture, Conversationally (Andrew Harmel-Law) | 40 min | The advice process and its four supporting elements. |
| adr.github.io | browse | Templates, tools and examples from the ADR community. |
| Fundamentals of Software Architecture, 2nd edition | book | The chapter on architecture decisions, antipatterns and ADR sections. |