Why a 30-Minute Code Review Waits 9 Hours
The queueing math behind the senior engineer bottleneck, a script to measure your own queue, and five fixes that don't involve working harder

A small pull request lands at 9:40 on a Tuesday. Reviewing it takes thirty minutes. It gets approved at 4:15 on Wednesday.
Nobody slacked off. The reviewer is the team's strongest engineer, and she was busy. That's the whole problem, and it has a formula.
TL;DR: A senior engineer behaves like a queue with one server. Average wait time grows as busy ÷ (1 − busy), so past roughly 80% utilization, small increases in load produce large increases in how long everyone waits. Getting faster doesn't fix it, because the queue refills. Changing what enters the queue does.
The model: a connection pool of size one
If you've debugged connection pool exhaustion, you already know this shape. When every slot is busy, requests don't fail. They wait, and the wait looks like slowness.
A senior engineer is a pool with one slot. Reviews, questions, design calls and approvals arrive all day, and each has two clocks:
- Service time: how long you spend on it. You feel this one.
- Wait time: how long it sits before you start. Your team feels this one.
The formula
For the simplest single-server queue (random arrivals, uneven task sizes), the average wait before work starts is:
wait = busy / (1 - busy) * task_time
Run it for a 30-minute review:
task_minutes = 30
for busy in (0.5, 0.7, 0.8, 0.9, 0.95):
wait = busy / (1 - busy) * task_minutes
print(f"{busy:.0%} busy: waits {wait / 60:.1f} h, free {1 - busy:.0%} of the time")
50% busy: waits 0.5 h, free 50% of the time
70% busy: waits 1.2 h, free 30% of the time
80% busy: waits 2.0 h, free 20% of the time
90% busy: waits 4.5 h, free 10% of the time
95% busy: waits 9.5 h, free 5% of the time
Two things stand out:
- From 90% to 95% busy, the wait doubles. It feels like taking on one more small thing.
- The chance a request finds you free is
1 − busy. Phillip Armour made this point in Communications of the ACM: at 95% utilization, urgent work has one chance in twenty of starting right away.
Caveat, stated honestly: this is a model, not a measurement of your team. Kingman's formula, the more general version, keeps the same busy / (1 - busy) term and multiplies it by how variable arrivals and task sizes are. Senior work is highly variable (two-minute answers, two-day incidents), which makes the curve steeper.
Your output is measured by what you finish. Your team's speed is measured by how long work waits for you.
Why "just get faster" fails
Getting faster lowers busy for a while. Then the queue refills, because speed is an advertisement: every fast, good answer teaches the team you're the shortest path to an answer. Capacity rises, arrivals rise with it, and you're back near 95%.
Saying no fails too. The work still exists. Refusing it moves the wait somewhere less visible.
What the wait costs, beyond hours:
- Context decay. The author has moved on; a 15-minute fix becomes an hour of reloading.
- Stacking. People branch off unreviewed branches; one comment ripples through three PRs.
- Guessing. When an answer takes a day, people guess. Wrong guesses come back weeks later as rework.
- Routing around you. The person with the most context ends up with the least say over risky changes.
As AI makes code cheaper to produce, more of the remaining work waits on human judgment. I covered the junior-developer side of that in Juniors Aren't Losing to AI. They're Losing the Review Queue.
Measure it: the Blocked-On-Me Count
For one week, list every open item where someone can't move until you act: reviews, unanswered questions, decisions, tickets others depend on. Write down how long each has waited, not how long it'll take you.
For PRs on GitHub, the CLI does the counting:
gh search prs --review-requested=@me --state=open \
--sort created --order asc \
--json number,title,repository,createdAt \
--jq '.[] | "\(((now - (.createdAt|fromdateiso8601))/3600)|floor)h \(.repository.nameWithOwner)#\(.number) \(.title)"'
This prints the age of each PR waiting on your review, oldest first. PR age overstates time-in-your-queue if the request came later, so treat it as an upper bound. Add your unanswered questions and pending decisions by hand.
Read it like this: if the count rarely drops below five, or the oldest item is regularly older than a day, you're on the steep part of the curve.
Five fixes that shrink the queue without working less
1. Drain before you build
Google's public code review guide optimizes for team speed over individual speed: respond within one business day at most, at natural break points, without interrupting focused work. Clear what's blocked on you before opening your own branch. Avoid one weekly "review hour"; two or three short windows a day protect focus without parking everyone's work.
2. Keep a fifth of the week unbooked
The cheapest wait reduction is the drop from 95% to 80% busy, roughly one day a week. Don Reinertsen, who brought queueing theory into product development, calls running near full utilization "an economic disaster." Slack absorbs incidents and urgent questions instead of pushing them to the back of a day-long line.
3. Get off the critical path
Don't take the ticket the release depends on. Your own work and everyone's requests will fight over the same hours. Take important work nobody is waiting on (next quarter's migration, test infrastructure), and pair with whoever owns the critical-path ticket.
4. Turn gates into guardrails
"Check with me first" is a permanent stream of arrivals. Write down the rule you'd apply anyway (which migrations need review, what retry behavior the payment client needs, when a dependency is fine) and let people check themselves. Keep personal sign-off for one-way door decisions.
5. Answer the second ask in writing
First time: answer. Second time: write it down and send the link. Prefer public channels over DMs so answers are searchable. This is the only fix that lowers future arrivals.
Bonus lever from Kingman: smaller, specific requests ("does this index cover the new query?") get answered between meetings. Vague ones ("thoughts on the data layer?") wait for an afternoon that never comes.
Common mistakes
- "Ping me anytime." Unlimited arrivals with no shape. Pair availability with a channel and a request format.
- Delegating without reasoning. Every question routes back to you, which is just a new queue.
- Invisible slack. Unbooked time gets booked. Show the effect (blocked count falling, same-day reviews), because work that prevents waiting erases its own evidence.
Key Takeaways
- A senior engineer is a single-server queue; wait time grows as
busy ÷ (1 − busy). - At 95% busy you're free for 1 request in 20, and a 30-minute task waits about 9.5 hours on average in the simple model.
- Getting faster doesn't help for long: speed attracts more requests.
- Measure time-waiting-on-you, not time-to-complete.
- Shrink the queue by draining first, keeping ~20% slack, leaving the critical path, writing guardrails and answering repeats in writing.
FAQ
Why do senior engineers become bottlenecks?
Because the most knowledgeable person receives the most requests (reviews, questions, decisions), and a single person handling variable work behaves like a single-server queue. Once their utilization passes roughly 80%, average wait time for everyone else climbs sharply even though their own output stays high.
What is the formula for wait time in a queue?
For the simplest single-server queue (M/M/1), average wait before service is utilization / (1 − utilization) × service time. Kingman's formula generalizes it by multiplying in a variability factor for arrivals and task sizes.
What utilization should a software engineer aim for?
There's no universal number, but the curve gets steep past about 80% busy. Leaving roughly a fifth of the week unbooked keeps waits short and leaves capacity for incidents and urgent requests. Higher-variability roles need more slack.
How fast should code reviews be?
Google's published guidance sets one business day as the maximum time to respond to a review request, ideally at natural break points so reviewers don't interrupt focused work. Many teams that deploy daily aim faster.
How do I stop being the bottleneck on my team?
Measure what's waiting on you, review before building, keep slack, hand off critical-path tickets while pairing on them, replace "ask me first" approvals with written rules, and turn repeated questions into documentation.
Does working faster fix a bottleneck?
Only briefly. Faster, better answers attract more requests, so utilization climbs back. Lasting fixes change what enters the queue (fewer gates, written answers, smaller requests) and protect spare capacity.
Related reading
- Your Database Is Fine. Your App Is Dying Anyway. The same queue, inside your backend.
- Juniors Aren't Losing to AI. They're Losing the Review Queue.
- Your Career Isn't Measured in Code. It's Measured in Blast Radius.
- Metastable Failures: Why Your System Stays Down After the Cause Is Fixed
The bottom line
Once enough of a team's work passes through you, your output and the team's speed stop being the same number. The engineers people call force multipliers are usually the ones the team moves fastest around.
Not how much you shipped. How long people waited for you.
Adam Jaber is a software engineer who writes Simply Explained: complex topics, made simple. No jargon, no hype.
New here? Start with the Plain-English Map. Get one of these in your inbox each week: subscribe to the newsletter.
About the author
- I'm a senior software engineer. I write Simply Explained, a plain-English breakdown of how AI and software actually work, and the quiet ways they break: AI fixes that hide bugs, agents that pick the wrong tool, health checks that take down healthy servers. One symptom, one analogy, one fix per piece. New here? Start with the pinned Start Here guide, or get one breakdown a week by email.
Comments
Join the discussionNo comments yet. Be the first to comment.




