The Time Zone Tax: Why Distributed Teams Lose a Day on Every Code Review
In a typical distributed enterprise, a pull request reviewed from another hub waits 4.1 times longer for a first review, and each round of requested changes costs a day instead of a few hours. Learn what engineering leaders on Reddit say about code review across time zones, and how Keypup MCP measures the time zone tax, from the hour a review request is sent to the teams that review locally and the cross-hub pull requests to hand off before logging off.
TL;DR: Enterprises spread engineering across hubs to hire talent and, in theory, to "follow the sun". In code review, the sun mostly sets. In a typical three-hub organization, 38% of reviewed pull requests get their first review from another hub. They wait 11.8 weekday hours for a first review instead of 2.9, take 49.3 hours to merge instead of 17.8, and each round of requested changes costs about 62 hours across hubs, against 20 within one. The hour a review is requested matters more than the reviewer: Berlin's requests to Bengaluru wait 2.6 hours in the morning and 19.2 hours after 10:00 UTC. The Keypup MCP Server reads each pull request's author, review request, each submitted review with its reviewer, state and time, approval and merge dates, and, for open ones, review state, build status and Keypup's recommended action and actors. Give your AI assistant which hub each engineer works from, their working hours and, for team views, their team, and it can show what crossing a time zone costs, when to ask for reviews, where cross-hub time goes, which teams review locally and which pull requests to hand off before logging off.
It's 16:30 in Berlin. A backend engineer finishes a change to the ledger service and requests a review from the two people who know that code best. Both work in Bengaluru, where it's 21:00. The review arrives the next morning, Berlin time 06:00: three comments and a request for a test. The Berlin engineer fixes it by 10:00 and asks again. Bengaluru is in its last hour of the day; the reviewer is in a meeting. The approval arrives the following morning. A two-hundred-line change has taken three days, for maybe two hours of actual work on either side.
The Friction: Review Cycles That Wait for Sunrise
Distributed teams don't fail because people in other hubs are slow. They fail because every exchange in a code review is a handoff, and every handoff across time zones waits for the other side to wake up:
The first review waits for the next working day. A request sent after the reviewer's day ends sits overnight, whatever its size.
Every round of changes repeats the wait. The reviewer comments at the start of their day, the author answers at the start of theirs, and each loop costs a calendar day.
The overlap window is small and overbooked. Two to four shared hours, usually full of meetings, are the only time a question gets answered the same day.
Organization-wide medians hide it. As more work crosses hubs, average cycle time creeps up and nobody can say why: no single team got slower.
The result: leadership sees cycle time rising across the organization, while engineers know their pull requests wait for someone else's morning.
Why This Matters: The Real Cost of the Time Zone Tax
The Delivery Problem
A feature that needs three review rounds ships in a day and a half within one hub, and in a working week across hubs. For a roadmap built on two-week sprints, that's the difference between finishing in the sprint and carrying over.
The Focus Problem
Authors waiting overnight start something else, then switch back the next morning to answer review comments. Reviewers do the same. Every round trip adds two context switches, on top of the wait.
The Hiring Problem
Organizations open hubs to scale. If cross-hub pull requests are three times slower, each new hub adds capacity on paper and coordination cost in practice, and the next headcount request is argued on the wrong numbers.
The Enterprise Discussion: What Engineering Leaders Are Actually Saying
"Every PR takes a day per round trip", "the overlap hours are all meetings" and "follow-the-sun never worked for us" are recurring complaints wherever staff engineers, engineering managers and directors compare notes. The quotes below are representative of recurring threads on r/ExperiencedDevs, r/EngineeringManagers, r/cscareerquestions and r/devops.
"I'm in Europe, half my reviewers are in India and the other half in the US. Any PR that needs more than one round takes three days minimum. I spend my evenings refreshing GitHub to catch someone before they log off."
"Leadership sold us follow-the-sun. What we got is a team where nobody can get a same-day review because the people who know the code are asleep. Our cycle time doubled after the reorg and the dashboard just says 'slower'."
Director of Engineering, Logistics Platform (r/devops)
"We have a two-hour overlap between Austin and Berlin. It's eaten by standups and syncs. Every code question that isn't asked in those two hours costs a day."
The pattern holds: organizations distribute engineering across time zones, but measure code review as if everyone shared one working day.
How Keypup MCP Measures the Time Zone Tax
The Keypup Model Context Protocol (MCP) Server gives your AI assistant structured access to the data Keypup imports from GitHub, GitLab, Bitbucket and Azure DevOps, and from Jira. For this analysis, what matters is each pull request: its author, its creation, review request, first review, approval and merge dates, and its state; each submitted review, with its reviewer, its state (approved, changes requested, commented) and its request and submission times; and, while the pull request is open, its review state, build status, and Keypup's recommended action and recommended actors.
Keypup doesn't know where your engineers work. Which hub each engineer works from, their working hours and, for the team view, which team they belong to come from you: paste the mapping in the prompt or keep it in a file your assistant can read, such as an export of your HR directory. A pull request is cross-hub when its first submitted review comes from an engineer in a different hub from its author.
Durations in this article are in weekday hours: Monday to Friday, all 24 hours, in UTC. Business hours from 09:00 to 17:00 can't compare hubs whose working days don't overlap, so nights are counted, and weekends aren't. All figures cover pull requests merged in the last 12 full months, November 2025 to October 2026, excluding bots, for an organization of around 900 engineers in three hubs: Berlin, Bengaluru and Austin.
1. Measuring What Crossing a Time Zone Costs
The first question: how much review crosses hubs, and what does it cost?
MCP Prompt:
Using the engineer-to-hub mapping below, split pull requests merged in
the last 12 full months into same-hub and cross-hub, by the hub of the
first reviewer. Show KPI cards with the share of cross-hub pull
requests and, for each group, the median weekday hours from review
request to first review, from opening to merge, and from opening to
merge with one round of requested changes.
Output: The Time Zone Tax at a Glance
Key Insight: More than a third of reviewed pull requests cross a time zone, and they pay for it at every step: four times the wait for a first look, almost three times the time to merge. The gap is widest when changes are requested: 104.6 hours against 34.8, three extra working days for a single round.
2. Finding When a Review Request Waits Overnight
Within a hub, the hour of a request barely matters. Across hubs, it decides everything.
MCP Prompt:
From reviews submitted on pull requests merged in the last 12 full
months, show a heatmap of the median weekday hours from review request
to review, by the UTC hour the review was requested, in two-hour slots,
for each author hub and reviewer hub pair.
Output: When You Ask Decides How Long You Wait
Key Insight: Berlin's requests to Bengaluru wait 2.6 hours when sent before 10:00 UTC, and 19.2 hours when sent just after, because Bengaluru's working day is ending. The same pair, the same reviewers, seven times the wait. Bengaluru to Berlin works all day: Bengaluru's afternoon is Berlin's morning. Austin's requests to the other two hubs always land at night.
3. Pricing Each Round of Requested Changes
A first review is one handoff. A review with requested changes is three: the comments, the fix and the new review.
MCP Prompt:
For the same pull requests, count the changes-requested reviews each
one received, and plot the median weekday hours from opening to merge
for 0, 1, 2 and 3 or more, as two lines: same-hub and cross-hub. Give
the share of pull requests in each group.
Output: Every Round Trip Costs a Day
Key Insight: Within a hub, each round of changes adds about 20 hours. Across hubs, about 62. Cross-hub pull requests also get changes requested a little more often: 37% need at least one round, against 29%. Every review round that can be avoided, with clearer pull request descriptions or a quick question during the overlap, saves almost three days across hubs.
4. Seeing Where Cross-Hub Time Goes
Is it the wait for the first review, the back-and-forth, or the merge? Splitting the time into phases answers it.
MCP Prompt:
Break the time of merged pull requests into three phases: review
request to first review, first review to last approval, and last
approval to merge. Show the median weekday hours of each phase as
stacked horizontal bars for same-hub pull requests and for each author
hub to first reviewer hub pair.
Output: Where Cross-Hub Pull Requests Lose Their Time
Key Insight: The first wait isn't the biggest cost. Between the first review and the final approval, cross-hub pull requests spend 14 to 34 hours, against 6.8 within a hub: that's the round trips. And when the approval lands after the author has logged off, the merge waits another night: up to 15 hours for pull requests reviewed from Austin.
5. Finding Which Teams Review Locally
Some teams have reviewers for each part of the code in every hub. Others send everything to the one hub where the experts are.
MCP Prompt:
Using the engineer-to-team mapping below, for the 10 teams merging the
most pull requests in the last 12 full months, plot a bubble chart:
share of first reviews done by a reviewer in the author's own hub on
the X axis, median weekday hours to first review on the Y axis, and
merged pull requests as the bubble size.
Output: Teams That Review Locally Wait Less
Key Insight: Teams whose authors find a reviewer in their own hub wait 3 to 7 hours. Platform Infra, Billing and Analytics send most first reviews to another hub and wait 15 to 17 hours. That isn't about effort: it's where the people who can approve the code sit. Training one reviewer per hub for each critical area of the code is the fix.
6. Explaining Why the Organization Looks Slower Every Month
When cycle time rises across the board, the cause is often a shift in the mix, not a slowdown.
MCP Prompt:
Month by month over the last 12 full months, show the share of merged
pull requests that were cross-hub as columns, and the median weekday
hours from opening to merge as lines: all pull requests, same-hub and
cross-hub.
Output: Why the Organization Looks Slower Every Month
Key Insight: The organization's median rose from 24.6 to 33.1 hours, a 35% slowdown on the dashboard. Same-hub pull requests didn't move. Two things did: the cross-hub share grew from 31% to 45%, and cross-hub pull requests themselves got slower. Without the split, the board hears "engineering is slowing down".
7. Listing the Pull Requests to Hand Off Before Logging Off
The last step turns the analysis into a routine at the end of each hub's day: which cross-hub pull requests are waiting, what do they need, and when will the person who should act next be online?
MCP Prompt:
List open pull requests whose requested reviewers or reviewers are
in another hub than the author, waiting more than 8 weekday hours
since their last review request or review. Show the repository and
number, author and reviewer hubs, hours waiting, lines changed, review
state, build status, Keypup's recommended action and first recommended
actor, and when that actor's next working window starts in UTC. Add
KPI cards.
Output: Cross-Hub Pull Requests to Hand Off Before Logging Off
Pull request
Author → reviewer hub
Hours waiting
Review state
Next action
Actor
Next window (UTC)
checkout-web #8812
Austin → Berlin
18.4
Pending
Review
k.schneider
Berlin, 08:00
ledger-service #3307
Berlin → Bengaluru
15.2
Pending
Review
p.iyer
Bengaluru, 04:00
identity-api #2741
Bengaluru → Austin
13.9
Changes requested
Fix code
a.raman
Bengaluru, 04:00
search-indexer #1189
Berlin → Austin
11.7
Approved
Merge
m.weber
Berlin, 08:00
mobile-app #6630
Austin → Bengaluru
10.3
None
Review
s.nair
Bengaluru, 04:00
data-pipeline #904
Bengaluru → Berlin
9.1
Pending
Review
l.hoffmann
Berlin, 08:00
Key Insight: 58 cross-hub pull requests only need their author to press merge: search-indexer #1189 is approved and green, and m.weber is back at 08:00 UTC. identity-api #2741 has a failing build and requested changes, and its author's next window starts at 04:00 UTC: fixing it before Austin's reviewers log on saves a full day. mobile-app #6630 has been waiting for its Bengaluru reviewer since Austin's afternoon; adding a second reviewer in Austin before the day ends avoids another night of waiting.
The Technical Implementation: What Keypup MCP Actually Reads
Every number above comes from fields Keypup imports from your Git platforms, combined with a hub, working hours and team mapping you provide. It helps to be precise about what each one depends on.
Hubs, Working Hours and Teams Come From Your Mapping
Keypup records who authored each pull request and who submitted each review. It doesn't know where they work, when their day starts or which team they belong to. That mapping comes from you. An engineer who moved hub or team during the period counts in their current one for the whole period, unless your mapping has dates. A "next working window" is computed by your assistant from the working hours in your mapping, not imported from a calendar.
Waits Come From Review and Pull Request Dates
Keypup imports, for each review, when it was requested and when it was submitted, and for each pull request, when it was opened, when the first review and the last approval were submitted, and when it was merged. Waits are the hours between two of them, computed by Keypup's BUSINESS_HOURS function. Here it counts all 24 hours, Monday to Friday, in UTC; you can give it other working hours and a time zone instead. Spontaneous reviews, given without a request, have no request time and are left out of the heatmap.
Review Rounds Come From Review States
Each submitted review is approved, changes requested, commented or dismissed. A round of changes is a changes-requested review. Comments left outside a review, or a request for changes written as a plain comment, aren't counted.
Next Actions Come From Keypup's Recommendations
For open pull requests, Keypup reads the review state, the mergeability, the build status reported by your Git platform and the remaining required approvals, and derives a recommended action, such as review, merge, fix the build, address requested changes or assign a reviewer, along with the people expected to perform it. The build status depends on your CI reporting its checks to the Git platform.
What Keypup Doesn't See
Keypup doesn't import calendars, vacations, public holidays or time zones from your HR system: a local holiday in one hub counts as a working day. It doesn't import chat, so a question answered in Slack during the overlap isn't visible. And it doesn't track when an engineer is actually online, only when they requested, submitted or merged something.
Real-World Impact: Enterprise Case Studies
Case Study 1: European Payments Group
Before Keypup MCP:
1,100 engineers in Berlin, Lisbon and Bengaluru after two years of hiring in India
Organization-wide cycle time up 40% in a year, with no team admitting to being slower
A proposal to move review ownership back to Berlin "for quality"
After Keypup MCP:
The monthly split showed the cause: same-hub pull requests hadn't slowed; the cross-hub share had doubled
One certified reviewer per hub for each of the eight most critical services, trained over two quarters
A review request cut-off: requests to Bengaluru sent before 10:00 UTC, with anything later going to a local reviewer first
"We were about to centralize reviews in Berlin, which would have made it worse. The heatmap showed us the problem was the hour of the request, not the hub of the reviewer."
— VP Engineering, European Payments Group
Case Study 2: North American Retail Platform
Before Keypup MCP:
750 engineers in Austin, Toronto and Kraków
Pull requests from Austin to Kraków taking a working week whenever changes were requested
Overlap hours fully booked with status meetings
After Keypup MCP:
The review-rounds chart priced each round: about 60 hours across the Atlantic, against 18 within a hub
The first overlap hour reserved for code review, with status meetings moved to written updates
An end-of-day hand-off list posted in each hub's channel, ordered by Keypup's recommended action
"Knowing that a round of changes cost us two and a half days changed how we write pull requests. People now ask their question in the overlap hour instead of in a review comment at 6 pm."
— Director of Engineering, North American Retail Platform
Implementation: Getting Started with Keypup MCP
1. Connect Your Git Platforms
Connect GitHub, GitLab, Bitbucket or Azure DevOps to Keypup. Pull requests, review requests, reviews, approvals and merges are imported automatically, along with mergeability and build status where your platform provides them.
2. Write Down Who Works Where, and When
Build a simple mapping of engineers to hubs, each hub's working hours in UTC, and engineers to teams. Keep it in a file your assistant can read, and update it when people move.
3. Make Review Requests Explicit
The wait to first review and the heatmap need a review request. Ask authors to request a reviewer rather than pinging in chat, so the clock starts when the request is made.
4. Agree on How You Count Time
Pick one convention, such as weekday hours in UTC, so hubs can be compared, and state it in every prompt along with your thresholds, such as 8 hours without a review.
5. Connect the MCP Server to Your AI Assistant
Connect the MCP server to your AI assistant using the MCP documentation, run the same-hub and cross-hub comparison for your last 12 months to set a baseline, then post the hand-off list at the end of each hub's day.
Frequently Asked Questions
What is the time zone tax in code review?
It's the extra time a pull request spends waiting because its author and reviewer don't share working hours. Each handoff, the request, the comments, the fix and the approval, waits for the other side's next working day, so a review that takes hours within a hub takes days across hubs.
How do you measure code review delays across time zones?
Map each engineer to a hub, then compare pull requests reviewed within a hub with those reviewed from another hub: the wait for a first review, the time to merge, the cost of each round of requested changes, and the wait by the hour the review was requested. Count time in a convention that works across hubs, such as weekday hours in UTC.
Does follow-the-sun development work for code review?
Only in one direction at a time. A hub whose afternoon is another hub's morning gets fast reviews; the reverse direction waits overnight. Measuring the wait by request hour and hub pair shows which handoffs work and which don't.
How do you speed up code review in distributed teams?
Train reviewers for each critical area of the code in every hub, send review requests while the reviewer's day still has hours left, reserve part of the overlap for code review questions, and review the list of waiting cross-hub pull requests at the end of each hub's day.
The Bottom Line
Distributed engineering works when a pull request doesn't have to wait for sunrise on another continent. In many enterprise organizations it does, once per handoff, while the dashboard reports a slower organization without saying why. Keypup MCP makes the time zone tax visible:
✅ Measuring what crossing a time zone costs, against review within a hub ✅ Finding when a review request waits overnight, by hour and hub pair ✅ Pricing each round of requested changes, within and across hubs ✅ Seeing where cross-hub time goes, phase by phase ✅ Finding which teams review locally, and which depend on one hub ✅ Explaining why the organization looks slower, by separating the mix from the speed ✅ Listing the pull requests to hand off before logging off, with who should act and when they're back
Ready to find out what your time zones cost your code reviews? Connect the Keypup MCP Server and ask your AI assistant.
Ready to Transform Your Analytics?
Join teams already using AI to make data-driven decisions faster than
ever.
In a typical enterprise, a pull request sent to another team's repository waits 3.8 times longer for a first review, takes almost five working days to merge and is three times more likely to be abandoned. Learn what engineering leaders on Reddit say about cross-team contributions, and how Keypup MCP measures the inner source tax, from which owning teams are bottlenecks to which cross-team pull requests to unblock today.
In a typical enterprise, the longest phase of a pull request's life starts after it is approved: a median of 9.6 business hours from last approval to merge, and 31% of approved pull requests waiting two business days or more. Learn what engineering leaders on Reddit say about approved code that doesn't ship, and how Keypup MCP measures merge limbo, from who holds the merge button to which approved pull requests can be merged today.
In a typical enterprise, a pull request sent to five reviewers waits 3.4 times longer for its first review than one sent to a single reviewer, and 69% of the people asked never respond. Learn what engineering leaders on Reddit say about review requests nobody owns, and how Keypup MCP measures the reviewer bystander effect, from panel size to the people who actually review.