Skip to main content
FeatureFactory
← Blog
team velocity19 min read·FeatureFactory

Review bottleneck or oversized batch? Diagnose the difference

A field guide for engineering managers who suspect review is slowing delivery -- with a reusable diagnostic worksheet, a hypothetical two-team walkthrough, matched interventions, and an experiment framework with guardrails.

The symptom that looks the same from the outside

Pull requests are taking too long to merge. The team agrees something is wrong. The most common proposal: add more reviewers, or nag the current ones. Sometimes that helps. Often it does not, because the delay is not caused by a shortage of reviewers -- it is caused by the shape of the work being reviewed.

A PR that sits open for three days might be waiting because every eligible reviewer is occupied. Or it might be waiting because the reviewer opened it, saw 900 changed lines across four subsystems, closed the tab, and came back when they had a bigger block of time. Those two situations produce the same cycle-time number but require completely different fixes. Adding reviewers to the second case just gives you more people closing the tab.

There is a third possibility that looks like both and is harder to spot: the reviewer saw the notification, opened the diff, spent twenty minutes reading it, decided they needed more context, and left without commenting. From your timestamps, this looks identical to "reviewer never saw the request." The distinction matters because one is a visibility problem (fix with better notifications) and the other is a context problem (fix with better PR descriptions or smaller scope). We will address how to tell them apart below.

This guide is for the engineering manager who needs to tell these cases apart before spending organizational capital on the wrong intervention. It delivers a reusable diagnostic worksheet, a worked hypothetical showing two teams with identical delays but different root causes, a matched set of interventions, and an experiment framework with quality and interruption guardrails.

Quick-start path

If you need a diagnosis this week, not a deep read:

  1. Export the last 30 merged PRs with timestamps for opened, first reviewer response, last revision pushed, and approved/merged.
  2. For each PR, record the number of changed files, the number of distinct code directories (or service boundaries) touched, and the number of eligible reviewers at the time of request.
  3. Sort by the gap between opened and first reviewer response. This is your queue time.
  4. Split the list into two groups: PRs where queue time was more than half the total cycle time, and PRs where it was less.
  5. In the high-queue-time group, check whether those PRs also had high file counts or crossed multiple domains. If they did, you likely have a batch-size problem disguised as a queue problem. If they did not, you likely have a capacity or availability problem.
  6. Use the diagnostic worksheet below to record findings and match them to interventions.

This five-minute triage will not give you a complete answer, but it will stop you from reflexively adding reviewers to a batch-size problem or splitting PRs when the real issue is reviewer availability.

Break the review timeline into four events

Every pull request passes through four observable moments. Treating "time in review" as a single number hides where the time actually goes.

The four events

  • Requested: The author marks the PR ready for review and assigns or requests reviewers.
  • First response: A reviewer leaves a substantive comment or approves. Bot comments and automated checks do not count.
  • Last revision: The author pushes the final addressing commit in response to feedback.
  • Approved/Merged: The PR receives its final approval and merges.

The three gaps that matter

Gap What it measures Common causes
Requested --> First response Queue time Reviewer availability, unclear ownership, intimidating diff size
First response --> Last revision Revision time Unclear feedback, author context-switching, complex rework, multiple revision rounds
Last revision --> Approved/Merged Re-review time Reviewer re-queue, approval ceremony, merge conflicts

Most teams who say "review is slow" have not separated these three gaps. When you do, one gap usually dominates. That dominant gap determines your intervention.

Why this matters: If queue time dominates, the bottleneck is before the reviewer engages. If revision time dominates, the bottleneck is the feedback loop between author and reviewer. If re-review time dominates, the bottleneck is the second pass. Each points to a different fix.

A note on revision time and multiple rounds: The "revision time" gap -- from first response to last revision -- naturally includes multiple back-and-forth rounds. A PR that goes through three rounds of feedback will show a large revision-time number even if each individual round is fast. This is by design: the worksheet captures total time in the revision phase per PR. If you want to understand whether the problem is too many rounds (a batch-size or unclear-context signal) versus slow individual rounds (an author-availability signal), add a "Rounds" column to the worksheet.

Detecting "opened but deterred" versus "never saw it"

Timestamp data has a blind spot: it cannot distinguish a reviewer who never noticed the review request from one who opened the diff, felt overwhelmed, and silently walked away. Both show up as queue time. Here are two lightweight ways to tell them apart without instrumenting your Git host:

Reviewer-side spot check. During your diagnostic period, ask each reviewer to keep a one-line log when they open a PR and decide not to engage immediately. The format is simple: PR #, reason (too large / need context / busy / other). Even a week of this data reveals whether your queue time is a notification problem or a deterrence problem. If most entries say "too large" or "need context," your queue time is actually a batch-size or context problem in disguise.

View-event correlation. Some Git hosting platforms expose "PR viewed" or "diff viewed" events. If yours does, compare the time of first view to the time of first comment. A large gap between view and comment -- hypothetically, a median of 6+ hours -- suggests reviewers are looking and walking away. A missing view event before the comment suggests the reviewer simply did not see the request promptly.

This distinction matters because it changes your intervention. A notification problem calls for better review-request routing. A deterrence problem calls for smaller PRs, better descriptions, or an explicit "what to look at first" summary in the PR body.

Collecting this data

If your tooling tracks review events with timestamps, you can extract these directly. If not, a manual sample of 20-30 PRs is enough to identify patterns -- perfection is not needed, directionality is. FeatureFactory helps teams examine engineering delivery and code quality, including AI-assisted work, which can reduce the manual collection effort, but a spreadsheet works for the initial diagnosis.

Diagnostic worksheet (copyable)

Copy this worksheet and fill one row per PR. Instructions follow the table.

PR REVIEW DIAGNOSTIC WORKSHEET
===============================

Team: _______________     Period: _______________
Sample size target: 30 merged PRs (minimum 20)
Time convention: [ ] Wall-clock hours  [ ] Business hours

For each PR, record:

| PR ID | Opened | 1st Response | Last Revision | Merged | Files Changed | Directories Touched | Eligible Reviewers | Rounds | Queue hrs | Revision hrs | Re-review hrs | Total hrs |
|-------|--------|--------------|---------------|--------|---------------|---------------------|--------------------|--------|-----------|--------------|---------------|-----------|
| #412  | Mon 9a | Mon 4p       | Tue 10a       | Tue 11a| 6             | 1                   | 3                  | 1      | 7         | 2            | 1             | 10        |
| #415  | Mon 2p | Wed 10a      | Wed 3p        | Thu 9a | 22            | 4                   | 2                  | 3      | 20        | 5            | 7             | 32        |
| #418  | Tue 8a | Tue 9a       | Tue 2p        | Tue 3p | 3             | 1                   | 4                  | 1      | 1         | 5            | 1             | 7         |
| ...   |        |              |               |        |               |                     |                    |        |           |              |               |           |

Note: Example rows above use WALL-CLOCK hours. If your team
uses business hours, adjust overnight and weekend gaps accordingly.
For example, Mon 4p to Tue 10a = 18 wall-clock hrs but ~2 business hrs.

SUMMARY (fill after completing all rows):

Median queue time:          ___ hrs
Median revision time:       ___ hrs
Median re-review time:      ___ hrs
Dominant gap (largest):     [ ] Queue  [ ] Revision  [ ] Re-review

Of PRs where queue > 50% of total:
  - Median files changed:   ___
  - Median directories:     ___
  - Median eligible reviewers: ___

Reviewer deterrence check (if data available):
  - PRs where reviewer viewed but did not comment for 6+ hrs: ___
  - Most common reason from reviewer spot-check log: ___________

Pattern match:
  [ ] High queue + high file count + multiple directories --> Batch/scope problem
  [ ] High queue + low file count + few eligible reviewers --> Capacity/ownership problem
  [ ] High queue + low file count + many eligible reviewers --> Priority/visibility problem
  [ ] High queue + reviewer deterrence evidence --> Context/description problem
  [ ] High revision + many rounds --> Batch-size or unclear-context problem
  [ ] High revision + few rounds + long per-round time --> Author availability problem
  [ ] High re-review + any size --> Second-pass queue or approval ceremony problem

Primary diagnosis: _______________________
Matched intervention (see table below): _______________________

How to use this worksheet:

  1. Pull timestamps from your Git hosting platform or project tracker. Choose your time convention first and mark it at the top. Use business hours if your team works roughly the same hours in the same time zone. Use wall-clock hours if the team is distributed. Apply your chosen convention consistently across all rows.
  2. "Eligible reviewers" means people with enough context to review that PR meaningfully, not everyone with repository access.
  3. "Rounds" means the number of feedback-and-revision cycles. A PR that was approved on the first review pass is 1 round. A PR that went through feedback, revision, more feedback, and another revision is 3 rounds.
  4. Fill the summary section after all rows are complete. Use medians, not averages, to avoid letting a single outlier dominate.
  5. The pattern-match section covers seven patterns. Real situations may combine two. If so, record both and address the larger contributor first.

Hypothetical worked scenario: two teams, same delay, different causes

The following scenario is entirely hypothetical and uses illustrative numbers. All times are wall-clock hours.

Setup

Two teams -- Team Acacia and Team Birch -- both report a median PR cycle time of roughly 48 hours. Leadership asks both to "speed up review." Each team fills in the diagnostic worksheet for their last 25 merged PRs.

Team Acacia's findings

Metric Value
Median queue time 8 hrs
Median revision time 34 hrs
Median re-review time 6 hrs
Median rounds per PR 3
Median files changed (all PRs) 28
Median directories touched 3
Median eligible reviewers 4
PRs where queue > 50% of total 4 of 25

Observation: Queue time is not dominant -- reviewers respond within a business day. Total time is high because revision cycles repeat. Most PRs go through three rounds of feedback. When the team digs into those rounds, they find reviewers asking authors to split concerns, restructure error handling, or explain why three unrelated changes are bundled together. The long revision time is not feedback ambiguity; it is rework caused by oversized, multi-concern batches. The worksheet's "Rounds" column made this visible: high revision time combined with many rounds pointed directly to a batch-size problem, not an author-availability problem.

Diagnosis: Batch-size problem. The PRs are too large and cross too many boundaries, causing repeated revision cycles. Adding reviewers would not help -- reviewers are already responding within a day. The fix is upstream: smaller, single-concern PRs.

Matched intervention: The team adopts a pre-review split check. Before requesting review, the author asks: "Does this PR contain changes that could be deployed independently?" If yes, split. They also set a soft guideline of one directory boundary per PR unless the change is inherently cross-cutting. For more structured guidance on where to draw PR boundaries, the related split-or-keep guide covers the decision in detail.

Team Acacia also adds a brief "reviewer deterrence" check. After one week, three reviewers report that they regularly opened large PRs, skimmed them, and left without commenting because they needed a 45-minute block they did not have. This confirmed the batch-size diagnosis: even the 8-hour queue time was partially a deterrence effect, not a pure availability gap.

Team Birch's findings

Metric Value
Median queue time 32 hrs
Median revision time 10 hrs
Median re-review time 6 hrs
Median rounds per PR 1.5
Median files changed (all PRs) 8
Median directories touched 1
Median eligible reviewers 1.5
PRs where queue > 50% of total 19 of 25

Observation: Queue time is dominant. PRs are reasonably sized and require few revision rounds. The problem is that most PRs have only one or two people who can review them, and those people are frequently in meetings, on-call, or working on their own PRs. When a reviewer is unavailable for a day, the PR sits. The reviewer spot-check log confirmed the diagnosis: reviewers were not deterred by PR size -- they simply had not seen the requests because they batch-checked notifications once a day.

Diagnosis: Capacity and ownership concentration problem. Knowledge is concentrated in too few people, creating a single-point-of-failure review bottleneck.

Matched intervention: Team Birch starts pairing a secondary reviewer with the primary on each PR -- not to double the review burden, but to build context in a second person. Over six weeks (hypothetically), the median eligible-reviewer count rises from 1.5 to 3, and queue time drops because there is almost always someone available who can review.

Why this distinction matters

If both teams had followed the generic advice to "add more reviewers," Team Acacia would have added reviewers who still send back the same split-this-up feedback, and Team Birch might have added people without the domain knowledge to review meaningfully. The worksheet forces you to look at the data before picking a fix.

Matching interventions to causes

The table below maps each diagnostic pattern to concrete interventions. This is not exhaustive, but it covers the patterns most teams encounter.

Pattern Root cause Intervention Who owns it Expected timeline
High queue + large PRs + multiple directories Batch size Pre-review split check; single-concern PR norm Authors, with tech lead reinforcing 2-4 weeks to see queue-time improvement
High queue + small PRs + few eligible reviewers Ownership concentration Pair-review rotation; explicit knowledge-sharing sessions Engineering manager + tech lead 4-8 weeks for reviewer pool to widen
High queue + small PRs + many eligible reviewers Priority/visibility Dedicated review windows; review-request channel with SLA Team collectively 1-2 weeks if adopted consistently
High queue + reviewer deterrence evidence Missing context in PR PR description template with "what to review first" section; inline navigation comments from author Authors 1-2 weeks
High revision + many rounds Batch size or unclear context Smaller PRs; design alignment before coding; author-provided test plan in description Authors + tech lead 2-4 weeks
High revision + few rounds + slow per-round time Author availability Explicit revision SLA; block calendar time for addressing feedback Authors + engineering manager 1-2 weeks
High re-review time Second-pass queue or ceremony Allow author-merge after addressing non-blocking comments; reduce required approvals for low-risk changes Engineering manager (policy change) 1 week

Adapting to team context

  • Small teams (2-4 engineers): Ownership concentration is almost always present. The primary lever is expanding reviewable surface area through pairing and documentation, not adding headcount.
  • Large teams (10+): Priority and visibility problems are more common. PRs get lost in a long queue. Dedicated review slots or a rotation system helps more than training more reviewers.
  • Distributed teams: Time-zone gaps inflate queue time mechanically. Separate time-zone-induced queue time from availability-induced queue time before diagnosing. A PR opened at 5 PM in one time zone that gets reviewed at 9 AM in another is not a bottleneck -- it is physics.
  • Teams using AI-assisted coding: FeatureFactory supports agent-assisted implementation workflows, and teams adopting these workflows sometimes see PR volume increase faster than review capacity scales. If your PR open rate has jumped recently, check whether the queue-time increase correlates with volume increase, not with individual PR characteristics.

Define a short experiment with guardrails

Once you have a diagnosis and a matched intervention, run a time-boxed experiment rather than a permanent policy change. Here is the framework:

Experiment structure

REVIEW INTERVENTION EXPERIMENT
==============================

Hypothesis: ___________________________
  (Example: "Splitting PRs at directory boundaries will reduce
   median revision time by at least 30% without increasing
   defect escape rate.")

Intervention: ___________________________
Duration: 3 weeks (minimum 2, maximum 4)
Sample: All PRs opened during the experiment period

Metrics to track:
  - Primary: The gap you diagnosed as dominant (e.g., revision time)
  - Guardrail 1: Defect escape rate (must not increase by more than [threshold])
  - Guardrail 2: Reviewer interruption frequency (review requests per reviewer per day)
  - Guardrail 3: Author satisfaction (brief weekly pulse: "Did the new process help, hurt, or make no difference?")

Stop conditions:
  - Guardrail 1 breached for two consecutive weeks --> stop and investigate
  - Team signals the intervention is creating more friction than it removes --> stop and adjust

Success criteria: Primary metric improves by [target] and no guardrail is breached.
Decision at end: [ ] Adopt  [ ] Modify and re-run  [ ] Abandon

Why guardrails matter here: The most common failure in review-process experiments is optimizing queue time at the cost of review quality. If you reduce queue time but reviewers are now rubber-stamping because they feel pressured, your defect escape rate will rise weeks later. The guardrails force you to watch for that.

Why interruption frequency matters: Dedicated review windows can accidentally turn reviewers into interrupt-driven workers who never get deep-work blocks. Track how many review requests each reviewer handles per day. If it spikes, the intervention may be redistributing the problem rather than solving it.

Failure symptoms, corrective actions, and escalation points

Symptom Likely cause Corrective action Escalate when
Queue time drops but total cycle time stays the same Revision or re-review time expanded to fill the gap Re-run the diagnostic worksheet; the bottleneck shifted Two experiment cycles show the same pattern
PR size drops but queue time increases Reviewers now have more PRs to review; volume overwhelmed capacity Track PR volume alongside size; consider review batching or dedicated review slots Reviewer interruption frequency exceeds 5 requests/day for two weeks
Pair-review rotation introduced but new reviewers take 3x longer Expected during knowledge transfer; becomes a problem if it persists Set an explicit ramp period (hypothetically, 4-6 weeks); track new-reviewer response quality separately After ramp period, new reviewers still require primary reviewer to re-review their approvals
Team adopts smaller PRs but ships fewer features Splitting overhead is real if taken too far; PRs may be split below useful granularity Review split boundaries -- each PR should still represent a deployable, testable unit Feature throughput drops for three consecutive sprints with no other explanation
Review feedback quality declines after adding review windows Time pressure causes shallow reviews Shorten the window but make it more frequent; or reduce the number of PRs per window Defect escape rate increases for two consecutive measurement periods
Reviewer deterrence persists after reducing PR size Problem may be PR descriptions, not size; reviewers still lack context to start Add "what to review first" to PR template; author posts an inline walkthrough comment on the critical path Deterrence log still shows "need context" after two sprint cycles of improved descriptions

When to escalate beyond the team: If your diagnostic worksheet consistently shows fewer than two eligible reviewers per PR and you have exhausted pairing and knowledge-sharing, the constraint may be organizational -- the team owns too much surface area for its size. That is a staffing or scope conversation, not a process tweak.

Explicit limitations

  • This diagnostic is directional, not precise. The worksheet uses timestamps and file counts as proxies. It cannot tell you whether a reviewer opened a PR, read it for 30 minutes, and left no comment -- that looks like queue time but is actually review time. The reviewer spot-check log and view-event correlation methods described above help close this gap, but they add manual effort and depend on reviewer honesty or platform support.
  • Small sample sizes produce unreliable patterns. If your team merges fewer than 15 PRs in the diagnostic period, the summary statistics will be noisy. Extend the period or combine with qualitative interviews.
  • The worksheet does not measure review quality. A fast review that misses a defect is worse than a slow review that catches it. Pair this diagnostic with defect-escape tracking if you want a complete picture.
  • Organizational politics are out of scope. If the real reason PRs sit is that a senior engineer gatekeeps approvals for status reasons, the worksheet will correctly identify the pattern but will not give you a script for that conversation.
  • Distributed-team time zones can inflate queue time mechanically. Always subtract expected time-zone lag before diagnosing a queue problem. An 8-hour gap between two time zones is not a bottleneck.
  • The intervention table is not exhaustive. Your team may have constraints -- regulatory review requirements, external dependency approvals, compliance gates -- that limit which interventions are available.

Ongoing review routine

Run this diagnostic quarterly, or whenever the team's delivery cadence changes noticeably. Here is a lightweight routine:

Monthly (5 minutes): Check the median queue time, revision time, and re-review time for the past 30 days. Compare to the previous month. If any gap has grown by more than 50%, fill in the full worksheet.

Quarterly (30 minutes): Fill in the full worksheet for the past quarter. Compare the dominant-gap pattern to the previous quarter. If the pattern has shifted (e.g., from queue-dominant to revision-dominant), your previous intervention may have moved the bottleneck rather than removed it. Re-diagnose and adjust.

After team composition changes: Whenever someone joins, leaves, or changes focus area, re-count eligible reviewers per PR for the past two weeks. Ownership concentration can shift quickly after a departure.

After workflow changes: If the team adopts new tooling, AI-assisted coding, or changes its branching strategy, re-run the diagnostic after four weeks. New workflows can change PR volume and shape in ways that shift the bottleneck. Organizing product signals with tools like FeatureFactory can help surface whether delivery changes correlate with product-level outcomes, but the review diagnostic itself stays mechanical.

Next-action checklist

  • Export timestamps for the last 30 merged PRs (opened, first response, last revision, merged)
  • Record file count, directories touched, eligible reviewers, and revision rounds for each PR
  • Choose and mark your time convention (wall-clock or business hours) before calculating gaps
  • Calculate queue time, revision time, and re-review time per PR
  • Fill in the diagnostic worksheet summary section
  • Optionally run the reviewer spot-check log for one week to detect deterrence vs. visibility gaps
  • Identify the dominant gap and match it to a pattern
  • Select one intervention from the matching table (resist the urge to try three at once)
  • Write an experiment hypothesis, duration, and guardrails
  • Communicate the experiment to the team with a clear start date and stop conditions
  • Run the experiment for the agreed duration
  • At experiment end, compare primary metric and guardrails to success criteria
  • Decide: adopt, modify, or abandon
  • Schedule the next quarterly diagnostic review

Measure what you ship - for real.

Put your team’s AI web-development on the outcome loop.

Get early access