Three broken releases in five weeks, and every single change had two approvals on it. That is the detail that still bothers me. Nobody skipped the process. The process was two lines long, it said “two approvals before merge”, and it had never once told a reviewer what they were approving.
What follows is the method I use now, written for a team that is part in Dubai and part somewhere several hours away, which describes most engineering teams I work with here. It produces one page. It is not a style guide, and deliberately so: style belongs to a linter, not to a human being reading a diff at 17:40.
Step 1: Name the 3 Jobs Review Is Doing, and Rank Them
Before any rule, answer one question in writing: what is review for on this team. There are only three honest answers, and almost every argument about review is really an unspoken disagreement about their order.
- Catching defects before a user finds them.
- Spreading context so more than one person understands each area.
- Creating an accountable second signature on a change, so the organisation can say who looked at it.
Rank them, because the ranking decides your trade-offs. A team that ranks defect-catching first should route reviews to whoever knows that code best, and will accept a bottleneck to get it. A team that ranks context-spreading first should deliberately route reviews to whoever knows it least, and will accept slower reviews and more missed defects in exchange for resilience when someone resigns. Those are opposite policies. Running both at once, which is what an unranked policy does, is how you end up with the senior engineer reviewing everything and nobody learning anything.
We ranked defect-catching first for anything touching money or authentication, and context-spreading first everywhere else. Writing that sentence down took ten minutes and settled six months of recurring argument.
Step 2: Scope What Must Be Reviewed, and What Must Not
A policy that reviews everything equally produces rubber stamps on the things that matter, because reviewer attention is finite and you have spent it on copy changes. So write three lists.
- Always reviewed, by someone who owns the area: authentication and authorisation, anything handling payments, data deletion and retention, schema migrations, infrastructure permissions, and anything that writes to a customer-facing audit trail.
- Reviewed by anyone: ordinary feature work, bug fixes, tests.
- Not reviewed: content and copy strings, dependency version bumps that pass the pipeline, generated lock files, documentation typos.
Then add the rule that does more work than the three lists combined: a maximum diff size for a single change. We use 400 lines, excluding generated files and tests, and the number matters far less than having one. Above a few hundred lines, review quality falls off a cliff and approvals start arriving suspiciously fast. If a change must be larger, it needs a scheduled walkthrough with a named reviewer rather than a pull request thrown over a wall.
Step 3: Assign Reviewers by Ownership Plus a Rota
Two mechanisms, and you need both. A code owners file routes high-risk paths to people who actually know them. A named weekly rota handles everything else, so review load stops landing on the same two seniors by default.
The rota is the part that gets resisted and the part that pays. Without it, review becomes an informal tax on whoever is most helpful, which is how you lose that person in eighteen months. With it, review is a scheduled duty with a name against it, and the question “who is reviewing today” has an answer that does not require anyone to volunteer.
One rule to add while you are here: no area may have exactly one owner. If the file says one name, you have found a resignation risk, not an ownership model. Fixing it is a hiring and pairing question rather than a policy one, and it belongs on your roadmap next to the review rules. We treat it the same way we treat a technical debt audit before hiring developers: a map of where the team is thin, produced before anyone writes a job advert.
Step 4: Set Review Times in the Hours You Actually Employ
Most review service levels are written in calendar time and quietly break the moment half the team is five hours behind. “Within 24 hours” sounds generous until you notice it means a change raised at 18:00 Dubai time on a Thursday gets reviewed on Sunday by someone who has lost all context.
Write it in working hours instead, and name the overlap window explicitly:
| Change type | First response | Who, when the clock runs out |
|---|---|---|
| Production incident fix | Within the hour, in overlap | Rota reviewer, then the on-call engineer |
| Owner-required path | Next working day of the owner | Named deputy owner, no exceptions |
| Ordinary change | 4 working hours | Rota reviewer for that day |
| Above the diff cap | Scheduled walkthrough, not a queue | Author books it, reviewer confirms |
The second column is the promise. The third column is what makes it real, and it is the one most policies omit: a service level with no named fallback is a wish. Define the overlap window once, in writing, with both locations named, and let people plan their day around it rather than around guesswork.
Our expert take
If you only implement one step from this article, implement step 4, and measure time to first review before and after. On every distributed team I have worked with, the gap between a slow review culture and a fast one is not reviewer diligence, it is whether a change raised late in one time zone has an owner in the other by the next morning. That is a scheduling decision, not a seniority decision, and it is free.
Hiring someone to own this
If your review queue is the constraint rather than your output, we can help you scope the senior role that fixes it and shortlist pre-vetted engineers against that scope.
Get startedStep 5: Separate Blocking Comments From Preferences
This is the step teams skip and the one that removes the most friction. Most review pain is not technical disagreement. It is that an author cannot tell which of nine comments they are obliged to act on, so they either act on all of them, which is slow and demoralising, or none, which is worse.
Adopt three prefixes and require one on every comment:
- blocking: this must change before merge. The reviewer is asserting a defect, a risk, or a policy breach, and is accountable for that assertion.
- question: I do not understand this yet and may be about to find a defect. Needs an answer, not necessarily a change.
- preference: I would have done it differently. The author may close this without discussion, and no reviewer may hold a merge over it.
Two supporting rules. A reviewer who writes only preferences has not reviewed, they have commented, and should not be the approving signature on an owner-required path. And any blocking comment on a disputed design decision goes to a five minute conversation rather than a comment thread, because a thread is the slowest possible medium for a disagreement and it is permanent in a way that makes people defensive.
The cultural effect of this step is larger than it looks, especially on a team spanning several first languages. Explicit labels let a reviewer be direct without sounding harsh, and let an author push back without sounding insubordinate. The label carries the tone so the words do not have to.
Step 6: Settle the Rule for Machine-Generated Code
Every team has this question open and most have not answered it in writing, which means it gets answered differently by each reviewer on each bad day. Three sentences are enough.
- The human who opens the change owns it. Whatever produced the code, the author is asserting it is correct, and “the tool wrote that part” is not available as an explanation after an incident. This single sentence prevents a whole category of argument.
- Say what was generated. One line in the description: which parts were machine-produced and what the author checked. Not for blame, for the reviewer, who reads generated code differently and should be allowed to.
- Generated volume does not buy a size exemption. If a tool produced 900 lines, it still gets split into reviewable changes. The cheapness of writing has no bearing on the cost of reading, and the reading is the part that protects you.
The hiring consequence is worth stating plainly, because it is changing what a strong engineer looks like. Reviewing confidently-wrong code is now a core skill rather than a senior luxury, and it is testable in an interview rather than discovered in month three. We set out how we test it in building a technical interview scorecard for UAE AI hiring.
Step 7: Measure 4 Numbers Monthly, Change 1 Rule
A policy nobody measures becomes folklore within two quarters. Four numbers, once a month, pulled from your repository rather than from opinion:
- Time to first review, median and the worst tenth. The worst tenth is where the frustration lives, and averages hide it completely.
- Review cycles per change. Rising cycles usually mean changes are too large or intent is unstated, not that reviewers are fussy.
- Share of changes approved by a single reviewer on owner-required paths. This is your rubber-stamp detector.
- Defects that passed review, counted from incidents and hotfixes. The only number that tells you whether any of this works.
Then change one rule, and only one. A policy that changes wholesale every quarter teaches the team that none of it is binding. One change a month, announced, with the number it is meant to move, is slower and sticks. We review ours alongside the delivery metrics in engineering performance review calibration, because review behaviour that is never acknowledged in performance conversations quietly stops happening.
The Mistake I Made Rolling This Out
I introduced all seven steps in one week, as a document, with a meeting. Adoption was immediate and entirely cosmetic. People used the prefixes and ignored the rest, because seven new rules at once is indistinguishable from no rules at all.
The second attempt worked: steps 2 and 4 first, which are mechanical and visibly reduce waiting, then step 5 three weeks later once people were already feeling the improvement, then the rest over two months. Same content, opposite result. If you are rolling this out across a team that spans time zones, the sequence matters more than the completeness, and the early wins have to be ones people feel in their own week rather than ones that show up in a dashboard you own.
Frequently Asked Questions
How long should a code review policy be?
Should reviews block a release or run in parallel with it?
How do I test code review ability in an interview rather than after hiring?
What changes about review when part of the team is in another time zone?
Start with one step, not seven
Tell us where your review queue hurts and we will tell you which step moves it first, and what the role looks like if you need to hire for it.
Get started