The third rewrite is the one that made me stop. Same subsystem, third architecture in eighteen months, and when I asked who had decided to go this way, the answer was a shrug and a reference to a conversation in a meeting room that two of the four people involved had already left the company. Nobody had done anything wrong. There was simply no mechanism by which a decision could be made once and stay made.
What an RFC Process Actually Fixes
Let me be precise about the failure, because “we should document our decisions” is the kind of resolution that produces a template nobody fills in.
The failure is not missing documentation. It is that a technical decision made verbally has no owner, no record of what was rejected, and no expiry. Six months later a new engineer proposes the approach you already considered and discarded, and because nobody can explain why it was discarded, you have the argument again. If that engineer is persuasive, you get a rewrite. The second time this happens you lose a quarter.
A request for comments document, which is all an RFC is, converts a conversation into an artefact with four properties a conversation cannot have: a named owner, a stated set of alternatives, a date, and a reason it might be wrong. That is the whole value. Everything in the seven steps below exists to get those four properties cheaply, and to stop the process collapsing into bureaucracy on the way.
Our expert take
In a distributed team the effect is larger than people expect, and it is not mainly about the writing. When part of your team is five hours away, a verbal decision is available to whoever happened to be awake. That is a structural advantage for one group and a structural disadvantage for another, and over a year it quietly determines whose technical judgement shapes the system. A written process does not fix a timezone, but it does mean the record of a decision is the same artefact for everybody rather than a story told by whoever was in the room.
Step 1: Set the Threshold for What Needs an RFC
Start here, and resist the temptation to start with the template. Most design document processes die because they are applied to everything, become a tax on ordinary work, and get abandoned inside a quarter.
Write one sentence. Ours: a change needs an RFC if it is hard to reverse, crosses a team boundary, or changes a contract another system depends on. Anything else does not. That sentence has done more for the process than the template did.
Test it against the last ten substantial changes you made. If more than about three of them would have needed a document, your threshold is too low and engineers will route around it. If none of them would have, you do not have a design problem and should stop reading here, which is a legitimate outcome.
Step 2: Write a One-Page Template and Enforce the Page Limit
Five headings, and the limit is the feature:
- The problem, in user or business terms. Not the technical symptom. If it cannot be stated without naming a technology, it is usually a solution looking for a problem.
- The constraint that makes it hard. Every genuine design decision has one. If there is no constraint, there is no decision to make and you should just build it.
- The proposal. What you intend to do, in enough detail that a reviewer could disagree with something specific.
- Alternatives considered. At least two, with the reason each was set aside.
- What would make this wrong. The condition under which a future reader should revisit the decision.
One page. A four-page RFC is not more rigorous, it is less likely to be read, and an unread document provides the appearance of a process without any of the benefit. We hold the limit by convention rather than tooling, and the convention holds because the fifth heading is hard to write at length.
The fifth heading is the one teams drop, and it is the one I would keep if I could only keep one. A decision with a written expiry condition is a decision that can be revisited without an argument about whether revisiting it is an insult to whoever made it.
Step 3: Name One Decider, Never a Committee
Every document carries a named decider in the header. Reviewers comment and advise. The decider decides, and signs the decision at the bottom with a date.
This is the step that gets resisted, usually on the grounds that it is not collaborative. The objection has it backwards. Consensus processes do not fail loudly, they fail by never concluding: the document accumulates comments, the author loses momentum, and eventually the code ships without the document because somebody had to make progress. Now you have a design process that produces documents which do not describe the system, which is worse than having none.
The decider is usually the most senior engineer who is not writing the document. Separating author from decider matters, because an author who is also the decider is writing a memo rather than a request for comments.
Step 4: Put a Clock on Review, With a Stated Default
Seventy-two working hours to comment. Then the decider rules, with or without input.
The important half of this step is the default, and it is the part most teams never write down: what does silence mean. Ours is that silence means assent, and that an objection raised after the clock expires does not block the work but does open a new RFC. That is harsh, and it is deliberate. A process where silence means nothing specific is a process where any reviewer can stall any decision by not replying, and the people who suffer most are the ones in a timezone where their working day ends first.
Want a second pair of eyes on your first RFC
Send us the design document you are least happy with. We will mark it against the five headings above and tell you which of the seven steps your team is missing.
Get startedStep 5: Record the Rejected Alternatives, Not Just the Choice
If you take one thing from this piece, take this. The rejected options are where the long-term value sits, and almost every team treats them as padding.
The scenario is predictable. Eighteen months after a decision, a capable engineer who was not there proposes the approach you considered and rejected. If the rejection is written down with its reason, the conversation takes four minutes and the engineer learns something about the system. If it is not, you are relitigating from scratch, with less context than you had the first time, against somebody who has just arrived and is keen.
The failure mode to watch for is a document that lists alternatives as strawmen. If every alternative in your RFCs is obviously worse than the proposal, nobody is thinking, they are justifying. A good alternatives section contains at least one option that is genuinely defensible and was set aside for a reason a reasonable person could disagree with.
Step 6: Wire the Document Into Code Review
A document that lives in a folder nobody opens is archaeology. The connection point is the first pull request that implements it.
Two rules do the work. The implementing pull request links to the RFC in its description. The reviewer checks the code against the document rather than against personal taste, and where the implementation has diverged from the design, that divergence gets either a note in the RFC or a conversation. Divergence is not a crime. Undocumented divergence is how you end up with a design document that actively misleads the next engineer, which is worse than no document at all.
This is also the step that makes the process self-sustaining, because it gives the document a job after it is signed. If you already have a written review standard, this is the cheapest place to attach it: we describe ours in the engineering code review policy, and step 6 is the hinge between the two processes.
Step 7: Audit Quarterly Against What Actually Happened
Once a quarter, reread the RFCs from two quarters earlier. Mark each one: held, reversed, or irrelevant.
The reversal rate is the only honest measure of whether the process improves decisions rather than just recording them. A rate near zero usually means your threshold from step 1 is set too high and you are only documenting decisions that were never in doubt. A rate above roughly a third means the documents are being written too late, after the real choice has already been made elsewhere.
The irrelevant pile is the interesting one. Decisions that stopped mattering because the product moved are not failures of the process, but a large irrelevant pile is a signal that engineering is designing for a roadmap that is not holding, and that is a conversation to have with whoever owns the roadmap rather than with the engineers.
| Step | Time cost | The failure it prevents |
|---|---|---|
| 1. Threshold sentence | One afternoon, once | Process applied to everything, then abandoned |
| 2. One-page template | 30 to 90 min per document | Documents nobody finishes reading |
| 3. Named decider | Zero | Documents that never conclude |
| 4. Review clock and default | Zero | Decisions stalled by indifference |
| 5. Rejected alternatives | 10 min per document | Relitigating settled questions |
| 6. Linked from the pull request | Zero | Documents that drift from the system |
| 7. Quarterly audit | Two hours per quarter | A process that records without improving |
The 4 Things This Will Not Fix
I would rather you adopt this knowing the limits than abandon it in a quarter when it fails to solve something it was never going to solve.
- An unclear product direction. If nobody can say what the product is for, your engineers will write beautifully reasoned documents about the wrong problem. The documents will make this visible faster, which feels like the process causing conflict. It is not.
- A missing technical authority. Step 3 requires somebody whose judgement the team accepts. If no such person exists, naming one in a template does not create the authority, and the documents will be ignored politely.
- Deadline pressure that makes design irrational. A team shipping under a date it did not set will route around any process. The RFC becomes retrospective paperwork. That is a planning problem.
- Poor hiring. A design process surfaces weak technical reasoning, which is genuinely useful, but it does not remedy it. If the documents are consistently thin, the honest reading is usually about the seniority of the team rather than the template. We cover how to see that gap deliberately in our method for an engineering skills matrix and gap analysis.
If you are standing this up alongside a wider build, the sequencing question is covered in our guide to custom software development in the UAE.
Frequently Asked Questions
Is an RFC process worth it for a team of five engineers?
How is this different from a code review policy?
What stops an RFC process from becoming bureaucracy?
Who should write RFCs in a mixed in-house and offshore team?
Start with one document, not a policy
We help UAE employers put a design process in place that their engineers actually use, and shortlist senior developers who can carry the decider role once it exists.
Get started