🇦🇪 HireDeveloper.ae

We Shipped 3 Broken Releases in 5 Weeks on a 2 Line Code Review Policy: the 7 Steps I Use in Dubai Now

Developer reviewing code on screen, illustrating a written code review policy for an engineering team in Dubai
Bryan

Bryan

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

TL;DR

  • •The problem: our entire policy was “two approvals before merge”. It passed audits and caught nothing, because it never said what a reviewer was supposed to be looking for.
  • •The method: 7 steps, one page of output. Name the jobs review does, scope what must and must not be reviewed, assign by ownership plus a rota, set times in working hours, separate blocking from preference, settle the rule for generated code, then measure 4 numbers.
  • •The part people skip: step 5. Most review pain in a distributed team is not technical disagreement, it is that nobody can tell which comments they are allowed to ignore.

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.

  1. 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.
  2. Reviewed by anyone: ordinary feature work, bug fixes, tests.
  3. 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.

Spend Reviewer Attention Where It Changes the OutcomeEqual review for everything means shallow review for the things that matterAlways, by an ownerauth, payments, deletion,migrations, permissionsdeep read, no size exceptionsBy anyone on the rotafeatures, bug fixes, testsnormal read, 400 line capNot reviewedcopy, lock files, doc typos,green dependency bumpspipeline is the reviewerReview quality against diff size, as every team eventually rediscoverstinya few hundred lineshugeuseful range

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 typeFirst responseWho, when the clock runs out
Production incident fixWithin the hour, in overlapRota reviewer, then the on-call engineer
Owner-required pathNext working day of the ownerNamed deputy owner, no exceptions
Ordinary change4 working hoursRota reviewer for that day
Above the diff capScheduled walkthrough, not a queueAuthor 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 started

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

  1. 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.
  2. 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.
  3. 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:

  1. Time to first review, median and the worst tenth. The worst tenth is where the frustration lives, and averages hide it completely.
  2. Review cycles per change. Rising cycles usually mean changes are too large or intent is unstated, not that reviewers are fussy.
  3. Share of changes approved by a single reviewer on owner-required paths. This is your rubber-stamp detector.
  4. 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 7 Steps, and What Each One ProducesTotal output: one page, six decisions, four numbers1. Rank the 3 jobssettles every trade-off2. Scope and size cap3 lists, 400 line limit3. Owners plus rotano area with 1 owner4. Times in work hoursnamed fallback owner5. Comment labelsblocking, question, preference6. Generated codeauthor owns it, no exemption7. Measure 4 numbers, change 1 rule a monthtime to first review, cycles, single-approver share, escaped defectsThe failure mode this replaces"Two approvals before merge": audit-friendly, catches nothing, and nobody knows what they approved

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?
One page that people follow beats ten pages nobody opens, but two lines is not a policy, it is a hope. The useful length covers six decisions: what must be reviewed, what must not, who reviews it, how fast, what counts as blocking, and who owns the change. Anything longer is usually style guidance, which belongs in a linter, or escalation detail, which belongs in your on-call runbook. The real test is whether a new joiner can read it once and know what to do with a 400 line change touching payment code at 17:00 on a Thursday.
Should reviews block a release or run in parallel with it?
Review should block the merge, not the release. If it blocks the release, every reviewer becomes a release gate and the pressure to approve without reading becomes irresistible late in the week. If it blocks the merge and your pipeline can deploy what is on the main branch, a slow review delays one change rather than everything queued behind it. The useful side effect is that small changes become genuinely cheaper to ship, which is the incentive you want, since small changes are where review catches the most.
How do I test code review ability in an interview rather than after hiring?
Give the candidate a real change to review instead of a problem to solve: roughly 150 to 300 lines with two or three genuine defects planted in it, such as a swallowed exception, a wrong boundary condition, and a dependency that does not belong. Ask them to review it as if it ships Monday. Score what they caught, whether they distinguished a defect from a preference, how they phrased the hard comment, and whether they asked who owns the consequence if it breaks. Strong reviewers ask that unprompted. It takes an afternoon to build and tells you more than a whiteboard round.
What changes about review when part of the team is in another time zone?
A review cycle stops costing minutes and starts costing a day, so the policy must minimise cycles rather than reviewer effort. Express every service level in working hours with a named overlap window, so a change raised at 18:00 has a defined owner the next morning. Cap diff size hard, because a large change across a time zone boundary can take a week of back and forth that the same change would take an hour in one room. And require two sentences of intent at the top of every change, since the reviewer cannot lean over and ask.

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