InterviewKata
Software architecture · Level 6: Governance and evolution · Module 27 of 46

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

A ship's logbook. It doesn't just say where the ship is; it records each change of course, who decided it, and why: "changed heading to 270° to avoid storm cell reported at 14:00". The next captain can see that the detour was deliberate, and decide whether the reason still holds, instead of steering back into the storm.
SectionWhat goes in it
TitleNumbered and short, phrased as the decision: "ADR-014: Use asynchronous messaging between Orders and Payments"
StatusProposed, Accepted, Superseded by ADR-031, (or RFC with a deadline for comments)
ContextThe forces at play: the problem, the constraints, the characteristics that matter, the options considered
DecisionWhat we will do, stated firmly ("we will"), with the justification. Why matters more than how.
ConsequencesWhat becomes easier and what becomes harder: the trade-offs, including the negative ones
ComplianceHow we'll know the decision is followed: the fitness function (Module 26) or review that checks it
NotesAuthor, 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

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.

Context: what's included?

Decision

Consequences: what's included?

Compliance

    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:

    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.

    TierWhich decisionsProcess
    TeamReversible, inside one team's boundaryDecide, record an ADR if it's significant
    AdviceAffects other teams, or a shared resourceSeek advice from affected teams and an expert; record the advice in the ADR
    ForumExpensive to reverse, crosses many teams, or breaks a principlePresent 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:

    Say it in the interview

    Two-sentence answers
    • "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.
    Red flags interviewers notice
    • Decisions that live in chat threads.
    • A consequences section with only benefits.
    • ADRs edited in place, losing the history.

    6. Remember it

    Memory hook: "Write down the why, and the price"Every significant decision gets its reasons and its costs recorded where the next person will look.
    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 logbookADR
    "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 oneSuperseding, not editing

    The trap it saves you from

    Groundhog Day: the same debate every month, forever.

    7. Common mistakes

    Only the outcome"We use Kafka" with no context or reasons is a fact, not a decision record. It can't be evaluated or revisited.
    One-sided consequencesListing only benefits hides the trade-off and erodes trust in the record.
    No complianceA decision nobody checks drifts (Module 26).
    Waiting to be certainCovering your assets delays everyone. Decide at the last responsible moment, and record what would make you revisit.

    8. Design exercise (30 minutes)

    1. Find a Groundhog Day (5 min). Which decision does your team keep re-discussing?
    2. Write its ADR (20 min). Use the seven sections. Include at least two options considered and at least one negative consequence.
    3. 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 history of why things changed stays readable.

    The team discusses whether to adopt GraphQL every few months. Which antipattern?

    The decision's reasons weren't recorded, so it keeps coming back.

    What must the consequences section include?

    Everything is a trade-off; record what was given up.

    What does the compliance section describe?

    Often a fitness function or a review step.

    How do you introduce ADRs to a ten-year-old system?

    Value comes quickly from the decisions people actually ask about.

    Under the advice process, what must someone do before making an architecture decision?

    Anyone can decide; the obligation is to seek advice, not permission.

    10. Go deeper

    ResourceTimeWhy
    Documenting Architecture Decisions (Michael Nygard)10 minThe blog post that started ADRs.
    Scaling the Practice of Architecture, Conversationally (Andrew Harmel-Law)40 minThe advice process and its four supporting elements.
    adr.github.iobrowseTemplates, tools and examples from the ADR community.
    Fundamentals of Software Architecture, 2nd editionbookThe chapter on architecture decisions, antipatterns and ADR sections.