🇦🇪 HireDeveloper.ae

We Shipped 3 Rewrites Nobody Agreed To: the 7-Step RFC Process That Ended Design by Loudest Voice in Our Dubai Team

A developer reading code on a large screen, illustrating the engineering RFC and design document process a Dubai team uses before writing implementation code
Bryan

Bryan

Delivery & Offshore Teams Expert · November 12, 2026 · 10 min read

TL;DR

  • •The problem: we rebuilt the same subsystem 3 times in 18 months, and each rewrite was decided in a conversation nobody could later reconstruct. The cost was not the code, it was relitigating the same argument every two quarters.
  • •The method: 7 steps, built around three limits rather than three additions: a one-page cap, one named decider, and a review clock with a stated default for silence.
  • •The honest part: the first two documents were slower than just building the thing, and step 7 exists because some of our own RFCs aged badly. The 4 problems this will not fix are listed near the end.

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:

  1. 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.
  2. 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.
  3. The proposal. What you intend to do, in enough detail that a reviewer could disagree with something specific.
  4. Alternatives considered. At least two, with the reason each was set aside.
  5. 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.

The same decision, two ways of holding itFour properties a conversation cannot carryDecided in a meetingOwner: whoever remembersAlternatives: lostDate: approximateExpiry condition: noneDecided in an RFCOwner: named deciderAlternatives: written, with reasonsDate: exactExpiry: stated conditionThe fourth row is the one most teams omit, and the one that lets a decision be revisited without relitigating it.Both columns describe our own practice before and after November 2025, not an industry benchmark.

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 started

Step 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.

Reading the quarterly auditThree piles, and what the size of each one is telling youHeldThe decision still standsNear 100 percent means yourthreshold is too high: you onlydocument the obviousReversedWe changed our mindAbove about a third means thedocuments are written too late,after the real choice was madeIrrelevantIt stopped matteringA large pile is a roadmapsignal, not an engineeringone. Raise it elsewhereThe reversal rate is the only one of the three that measures whether the process improves decisions rather than just recording them.Thresholds quoted here are our own rules of thumb after four quarters of running this, not a published standard.Audit the quarter that closed two quarters ago, so there has been time for a decision to be tested by real work.Keep it to two hours. A longer audit turns into a review of the engineers rather than of the process.
StepTime costThe failure it prevents
1. Threshold sentenceOne afternoon, onceProcess applied to everything, then abandoned
2. One-page template30 to 90 min per documentDocuments nobody finishes reading
3. Named deciderZeroDocuments that never conclude
4. Review clock and defaultZeroDecisions stalled by indifference
5. Rejected alternatives10 min per documentRelitigating settled questions
6. Linked from the pull requestZeroDocuments that drift from the system
7. Quarterly auditTwo hours per quarterA 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.

  1. 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.
  2. 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.
  3. 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.
  4. 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?
Partly, and the honest answer depends on turnover rather than size. In a team of five that has been together two years and sits in one room, verbal decisions work and this will feel like paperwork. In a team of five where two people joined this quarter, or where part of the team is in another timezone, the documents do something a conversation cannot: they make a decision available to somebody who was not in the room. The threshold test in step one matters more than headcount. If you are reversing decisions, relitigating the same argument every few months, or finding that two engineers built against different assumptions, you have the problem regardless of team size.
How is this different from a code review policy?
They operate at different moments and catch different failures. Code review catches defects in work already written, so by the time it runs the approach is already chosen and changing direction costs the whole implementation. An RFC runs before the code exists, when changing direction costs an afternoon of argument. The two connect at step six: the pull request links to the document, and the reviewer checks the code against the agreed design rather than against personal preference. A team with strong code review and no design process reviews the wrong things very thoroughly.
What stops an RFC process from becoming bureaucracy?
Three things, all of them limits rather than additions. The page limit, which keeps documents readable and stops authors using length as a substitute for clarity. The named decider, which stops documents drifting while everyone waits for consensus. The review clock with a stated default, which means a document cannot be blocked by indifference. Bureaucracy in design processes almost always comes from unbounded review rather than from writing things down. If your RFCs routinely sit open for three weeks, the problem is step four, not the existence of the process.
Who should write RFCs in a mixed in-house and offshore team?
Whoever is going to build the thing, and this is worth defending. The common failure is to have the in-house senior engineer write documents that an offshore team then implements, which turns the RFC into a specification handed down and destroys the main benefit: the author thinking the problem through before committing. If an offshore engineer is building it, that engineer writes the document and the in-house senior reviews it. This is slower for the first two documents and faster forever afterwards, because it surfaces misunderstandings while they are still cheap. It also gives you a written record of how a remote engineer reasons, which is the most useful artefact you will have at promotion time.

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