ADR vs RFC vs design doc vs PRD: which document when
ADR vs RFC vs design doc vs PRD compared: what each answers, who writes it, how long it is, and how they fit together from idea to shipped code.
An engineer asks in Slack whether the new caching layer needs "an RFC or an ADR or a design doc." Three people answer with three different conventions from three previous jobs. The work waits while the team debates the paperwork.
The documents answer different questions, so the choice is simpler than it looks. This guide compares them, drawing on Michael Nygard's ADR format, the Rust RFC process, Malte Ubl's Design Docs at Google, and Atlassian's PRD guide, checked on 16 November 2026.
The short answer
| PRD | Design doc | RFC | ADR | |
|---|---|---|---|---|
| Answers | What and why, for users | How we'll build it, and the trade-offs | Should we do this? Comments please | What did we decide, and why? |
| Typical author | Product manager | Engineer or tech lead | Anyone proposing a change | Whoever made the decision |
| Scope | A feature or product | A system or feature | A significant change | One decision |
| Length | One to a few pages | 1 to 3 pages small, 10 to 20 large | Varies | About a page |
| Timing | Before design | Before building | Before deciding | When deciding |
| Lifespan | Until shipped, then archive | Reference for years, drifts | Closes with a decision | Permanent, superseded not edited |
PRD: what and why
A product requirements document defines what the team is building, for whom, and why, without saying how. Atlassian describes it as a single source of truth that keeps product, design, and engineering aligned.
Design doc: how, and the trade-offs
Ubl describes a design doc as the high-level implementation strategy and key design decisions, with emphasis on trade-offs. Its sections: context and scope, goals and non-goals, the design, alternatives considered, and cross-cutting concerns. He puts larger docs at around 10 to 20 pages and notes 1 to 3 page mini design docs for smaller work. See the technical design document template.
RFC: a proposal and a decision process
An RFC is a proposal put up for comments before a decision. Rust's template covers motivation, a guide-level and a reference-level explanation, drawbacks, alternatives, and unresolved questions, and its process ends with a disposition (merge, close, or postpone) and a ten-day final comment period. The defining feature is the process, not the sections. See the engineering RFC template.
ADR: one decision, recorded
Nygard's ADR is short: title, status, context, decision, consequences. It records one decision that's been made, and when the decision changes, a new ADR supersedes it rather than editing it. See architecture decision record examples.
How they fit together
A large feature, start to finish:
- PRD: "Workspace admins need to see stale access before security reviews."
- Design doc: how the activity data is collected, stored, and queried, with alternatives.
- RFC review of the design doc, with a comment deadline and a named decider.
- ADRs for the decisions that will matter later: "activity is recorded per session, not per request," "retained for 13 months."
- Code, with ADRs linked from the modules they affect.
Design doc vs RFC: one document or two?
Mostly one. A design doc is a document; an RFC is a document plus a review process. Many teams write the design doc and run it as an RFC: share it, set a deadline, name a decider, record the outcome. Keep them separate only if your RFCs cover more than designs, such as process changes or policies.
Which do you need?
| Situation | Write |
|---|---|
| Small, reversible change | Nothing, or a line in the PR |
| One hard-to-reverse technical choice | ADR |
| A significant change others should weigh in on | RFC |
| A system or feature with many trade-offs | Design doc, reviewed as an RFC |
| A new product feature | PRD, then a design doc if the build is non-trivial |
The rule of thumb from Ubl applies to all of them: if the answer isn't ambiguous, the document is overhead.
Where decisions get lost
Each document holds decisions at the moment it was written. Design docs drift as the system changes. RFCs close and stop being read. Decisions made after either, in a PR thread or a meeting, often never reach any document. ADRs are the best defense, but only if someone writes them.
Where Lockstep fits
Lockstep pulls decisions out of all four kinds of document, plus Slack and pull requests, routes each to its owner for approval, and keeps them current: a new decision supersedes the old one with both visible. Claude Code sessions are briefed on the approved decisions that apply to the code they're changing.
See how it works.
Sources checked 16 November 2026
- https://cognitect.com/blog/2011/11/15/documenting-architecture-decisions
- https://github.com/rust-lang/rfcs
- https://www.industrialempathy.com/posts/design-docs-at-google/
- https://www.atlassian.com/agile/product-management/requirements
Related reading
For product-side documents, see PRD vs BRD vs FRD vs SRS. For ADRs versus decision logs, see decision log vs ADR. For diagramming the result, see architecture diagram examples. For reviewing designs, see the architecture review template.
Frequently asked questions
- What is the difference between an ADR and an RFC?
- An RFC proposes a change and asks for feedback before a decision, often with a comment period. An ADR records a decision that has been made: the context, the decision, and its consequences. An accepted RFC often produces one or more ADRs.
- What is the difference between a design doc and an RFC?
- They overlap a lot. A design doc focuses on recording the design and its trade-offs. An RFC focuses on the request for comments and an explicit decision process. Many teams write one document and run it through an RFC-style review.
- What is the difference between a design doc and an ADR?
- A design doc covers a whole system or feature, often several to twenty pages, with many decisions inside. An ADR covers a single decision in about a page. Teams often extract the key decisions from a design doc into ADRs so they can be found later.
- What is the difference between a PRD and an RFC?
- A PRD is a product document: what to build for users and why. An RFC is usually an engineering proposal for how to change a system or process. The PRD comes first; the RFC or design doc responds to it.
- Do we need all four documents?
- No. Use the lightest one that answers the question. A small, reversible change may need nothing. A single hard-to-reverse technical choice needs an ADR. A large project with many trade-offs needs a PRD and a design doc, reviewed through an RFC process.
Keep reading