Featured

The Inner Source Tax: Why Pull Requests to Another Team's Repository Wait Days

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.

Liam Davis
Liam Davis
• 13 min read
The Inner Source Tax: Why Pull Requests to Another Team's Repository Wait Days

Table of Contents

TL;DR: Enterprises encourage teams to contribute to each other's code instead of filing tickets and waiting: "inner source". But a pull request that crosses a team boundary pays a tax. In a typical enterprise, one pull request in seven targets a repository owned by another team. It waits 12.8 business hours for a first review instead of 3.4, takes 38.6 business hours to merge instead of 11.2, and 22% of closed cross-team pull requests are closed without merging, against 7% within teams. The tax isn't spread evenly: owning teams where two reviewers handle three quarters of outside reviews make contributors wait close to four working days. The Keypup MCP Server reads each pull request's author, target repository, review request, review and merge dates, lines changed, review state, mergeability, build status, and Keypup's recommended action and actors. Give your AI assistant which team owns each repository and which team each engineer belongs to, and it can show what crossing a boundary costs, which owning teams are bottlenecks, why outside contributions get sent back, and which cross-team pull requests to unblock today.

The checkout team needs one new field in the identity service's token. The identity team's roadmap is full until next quarter, so the platform group's advice is the inner source one: "Open a pull request, they'll review it." A checkout engineer writes the change in a day. Then it sits. The identity team has two senior engineers who know the token code, and both are busy with their own sprint. Three days later a review arrives: rename this, move that, add a test in a framework the checkout engineer has never used. A week later the change is still open, the checkout feature is late, and the next time someone needs something from identity, they file a ticket instead.

The Friction: Contributions Nobody Owns

Inner source promises that any engineer can fix what blocks them, wherever the code lives. In practice, several things turn a cross-team pull request into the slowest work in the company:

  • Reviews of outside work aren't in anyone's sprint. The owning team plans its own work. A pull request from another team is an interruption, and it waits until someone has a gap.
  • Reviewers are concentrated. Outside contributions go to the one or two people who know the code best, the same people the owning team depends on.
  • Contributors don't know the conventions. They arrive with a large batch, the wrong patterns and tests in the wrong place, and get sent back.
  • Nobody tracks the outcome. When a cross-team pull request is abandoned, the requesting team quietly works around it or files a ticket, and the cost never shows up anywhere.

The result: leadership believes inner source is working because cross-team pull requests exist, while the engineers who open them learn to avoid it.

Why This Matters: The Real Cost of the Inner Source Tax

The Delivery Problem

Cross-team pull requests are rarely side work. They unblock a feature in the requesting team. When they wait a week, the feature waits a week, and the delay shows up in the requesting team's metrics, not the owning team's.

The Waste Problem

A cross-team pull request closed without merging is finished work thrown away: the time to learn an unfamiliar codebase, write the change and go through review rounds. Multiplied by thousands of pull requests a year, it's a team's worth of capacity.

The Culture Problem

Each abandoned contribution teaches an engineer that crossing a boundary doesn't pay. Teams go back to tickets, duplicate code in their own repositories, or build workarounds, and the silos inner source was meant to remove come back.

The Enterprise Discussion: What Engineering Leaders Are Actually Saying

"Our inner source PRs just rot", "other teams never review our pull requests" and "nobody owns contributions from outside" are recurring complaints wherever staff engineers, engineering managers and platform leads compare notes. The quotes below are representative of recurring threads on r/ExperiencedDevs, r/EngineeringManagers, r/softwarearchitecture and r/devops.

Staff Engineer, Retail Banking (r/ExperiencedDevs)

"Leadership loves inner source. In reality I open a PR on the platform team's repo, it sits for a week, then I get twenty comments about their conventions. Next time I'll just copy the code into our service."

Engineering Manager, Travel Marketplace (r/EngineeringManagers)

"My team is the owner of a shared library everybody depends on. We get thirty outside PRs a month and nobody budgets time to review them. Two of my seniors do all of it, and they're burning out."

Principal Engineer, Telecom Operator (r/softwarearchitecture)

"We measure cycle time per team, so cross-team PRs are invisible. The requesting team looks slow, the owning team looks fine, and the PR in between has been open for nine days."

The pattern holds: organizations encourage engineers to contribute across team boundaries, but don't measure what happens to those contributions, or who pays for the wait.

How Keypup MCP Measures the Inner Source 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 target repository, its creation, review request, first review, changes requested and merge dates, its state (open, merged or closed without merge), its lines changed, each submitted review and its reviewer, and, while it's open, its review state, mergeability, build status, and Keypup's recommended action and recommended actors.

Keypup doesn't know which team owns which repository, or which team each engineer belongs to. That mapping comes from you: paste it in the prompt or keep it in a file your assistant can read, such as a CODEOWNERS export or your team directory. A pull request is cross-team when its author's team differs from the team owning its target repository.

All figures cover pull requests opened in the last 12 full months, November 2025 to October 2026, excluding bots, for an organization of around 1,200 engineers in 38 teams and 210 repositories. Times are in business hours, 09:00 to 17:00 UTC, Monday to Friday.

1. Measuring What Crossing a Boundary Costs

The first question: how much inner source is there, and how does it compare with work inside a team?

MCP Prompt:

Using the repository-to-team and engineer-to-team mapping below, split
pull requests opened in the last 12 full months into cross-team and
same-team. Show KPI cards with the share of cross-team pull requests,
and for each group the median business hours to first review, the
median business hours from opening to merge, and the share of closed
pull requests closed without merge.

Output: The Inner Source Tax at a Glance

Four KPI cards for November 2025 to October 2026. Cross-team pull requests: 14.5%, 13,900 of 96,000 pull requests target a repository owned by another team. Median wait for first review: 12.8 business hours cross-team against 3.4 within the team, 3.8 times longer. Median open to merge: 38.6 business hours cross-team against 11.2 within the team, 3.4 times slower. Closed without merge: 22% of closed cross-team pull requests against 7% within the team, 2,780 contributions abandoned

Key Insight: Crossing a team boundary costs almost four times the wait. One pull request in seven goes to another team's repository. It waits 12.8 business hours for a first look instead of 3.4, takes almost five working days to merge instead of a day and a half, and is three times more likely to be closed without merging.

2. Following What Happens to Cross-Team Pull Requests

Medians describe merged pull requests. Outcomes show the ones that never made it.

MCP Prompt:

For the same pull requests, show their outcome today as 100% stacked
bars, cross-team against same-team: merged within 5 business days of
opening, merged later, closed without merge, or still open. Show the
share and the count in each segment.

Output: What Happens to a Cross-Team Pull Request?

100% stacked horizontal bars by outcome today. Same team, 82,100 pull requests: merged within 5 business days 80%, 65,680; merged after 5 business days 11%, 9,031; closed without merge 7%, 5,747; still open 2%, 1,642. Cross-team, 13,900 pull requests: merged within 5 business days 49%, 6,811; merged later 24%, 3,336; closed without merge 20%, 2,780; still open 7%, 973

Key Insight: Only half of cross-team pull requests are merged within a working week, against 80% within teams. One in five is closed without merging, and 973 are still open today. Every one of those is a feature in another team that waited, or was built some other way.

3. Seeing How Long Contributors Wait for a First Look

A cross-team contributor's first question is "has anyone seen my pull request?". A survival curve answers it hour by hour.

MCP Prompt:

For pull requests with a review request, plot the share still waiting
for their first submitted review after 2, 4, 8, 16, 24 and 40 business
hours, as two lines: cross-team and same-team.

Output: How Long Until Someone Looks?

Line chart of the share of pull requests still waiting for a first submitted review by business hours since review was requested. Same-team: 62% after 2 hours, 46% after 4, 27% after 8, 12% after 16, 7% after 24, 3% after 40. Cross-team: 90% after 2 hours, 83% after 4, 66% after 8, 41% after 16, 29% after 24, 17% after 40. A dashed line marks 24 business hours, three working days

Key Insight: After three working days, 29% of cross-team pull requests still have no review, against 7% within teams. The gap opens in the first hours: a same-team pull request has a 38% chance of being reviewed within two business hours, a cross-team one 10%. Outside contributions aren't reviewed slowly; they aren't picked up.

4. Finding Which Owning Teams Are Bottlenecks

The tax depends on who owns the code. Comparing owning teams separates high volume from slow response.

MCP Prompt:

For cross-team pull requests opened in the last 12 full months, group
them by the team owning the target repository. For the 10 teams
receiving the most, plot a bubble chart: number received on the X
axis, median business hours to first review on the Y axis, and the
number of distinct outside authors as the bubble size.

Output: Which Teams Are the Inner Source Bottlenecks?

Bubble chart of the 10 owning teams receiving the most cross-team pull requests, 10,540 of 13,900. X axis: cross-team pull requests received; Y axis: median business hours to first review; bubble size: distinct outside authors. Identity 2,150 received, 21.4 hours, 310 authors; Shared UI Kit 1,880, 6.2 hours, 420; Payments Core 1,420, 27.9 hours, 160; Data Platform 1,310, 18.3 hours, 240; API Gateway 1,060, 9.1 hours, 190; Observability 760, 4.8 hours, 210; Search 640, 14.7 hours, 95; Notifications 520, 8.0 hours, 88; Billing 470, 31.2 hours, 64; Mobile Core 330, 12.5 hours, 70. A dashed line marks the organization median of 12.8 hours

Key Insight: Volume doesn't explain the wait. Shared UI Kit receives 1,880 cross-team pull requests from 420 authors and reviews them in 6.2 business hours. Billing receives 470 and takes 31.2. Four teams, Identity, Shared UI Kit, Payments Core and Data Platform, receive 49% of all cross-team pull requests: that's where review capacity for outsiders matters most.

5. Checking Whether Outside Contributions Get Sent Back More

Contributors often blame slow reviews. Owning teams often blame the contributions. The review outcome by size settles it.

MCP Prompt:

For reviewed pull requests opened in the last 12 full months, show as
grouped columns the share that received at least one changes-requested
review, by lines changed: under 50, 50 to 200, 200 to 500, over 500.
Compare cross-team and same-team, and give the median lines changed of
each group.

Output: Do Cross-Team Pull Requests Get Sent Back More?

Grouped columns of the share of reviewed pull requests with at least one changes-requested review by lines changed. Under 50 lines: same-team 9%, cross-team 17%. 50 to 200: 14% and 27%. 200 to 500: 21% and 41%. Over 500: 28% and 55%. Median size 168 lines cross-team, 92 same-team; 19% of cross-team pull requests change more than 500 lines against 8% within teams

Key Insight: Both sides are right. At every size, a cross-team pull request is sent back about twice as often, and cross-team pull requests are bigger: the median is 168 lines against 92. Over 500 lines, more than half get changes requested. Contribution guides and an early design conversation for large changes cut both the size and the rework.

6. Seeing Who Reviews the Outsiders

When outside reviews fall on the same two people, the owning team's experts become the queue.

MCP Prompt:

From pull request reviews submitted in the last 12 full months on
cross-team pull requests, for the 8 owning teams receiving the most,
show the share of reviews done by the team's two most active reviewers
as horizontal bars, with the number of distinct reviewers and the
median business hours to first review.

Output: Who Reviews the Outsiders?

Horizontal bars of the share of reviews on cross-team pull requests done by the owning team's two most active reviewers, with distinct reviewers and median business hours to first review. Payments Core 78%, 6 reviewers, 27.9 hours; Billing 74%, 4, 31.2; Identity 71%, 9, 21.4; Data Platform 58%, 11, 18.3; Search 52%, 7, 14.7; API Gateway 44%, 14, 9.1; Observability 31%, 18, 4.8; Shared UI Kit 26%, 23, 6.2

Key Insight: Where two people review every outsider, outsiders wait. At Payments Core and Billing, two reviewers handle three quarters of cross-team reviews, and the median wait is close to four working days. Shared UI Kit spreads them across 23 reviewers and answers in under a day. A review rotation for outside contributions is the cheapest fix on this page.

7. Listing the Cross-Team Pull Requests to Unblock Today

The last step turns the analysis into a routine: which cross-team pull requests are stuck right now, what do they need, and who should act?

MCP Prompt:

List open cross-team pull requests open for more than 16 business
hours. Show the repository and number, author team, owning team,
business hours open, lines changed, review state, mergeability, build
status, Keypup's recommended action and the first recommended actor,
longest first. Add KPI cards for the totals.

Output: Cross-Team Pull Requests to Unblock Today

KPI cards: 973 open cross-team pull requests; 512 open more than 16 business hours with no review yet; 188 approved and mergeable; 61% with Review as Keypup's next action. Table: identity-service #4471, Checkout to Identity, 46.2 business hours open, 84 lines, review none, mergeable, build success, next action Review, actor a.kowalski; payments-ledger #2913, Mobile Core to Payments Core, 39.5, 312, pending, mergeable, success, Review, r.mehta; data-contracts #788, Search to Data Platform, 33.0, 56, approved, mergeable, success, Merge, j.lindqvist; billing-engine #1650, Payments Core to Billing, 28.7, 640, changes requested, conflicting, failure, Fix code, p.santos; api-gateway #5102, Notifications to API Gateway, 22.4, 18, none, mergeable, no build, Assign reviewer, e.dubois; ui-kit #9310, Growth to Shared UI Kit, 17.1, 130, pending, mergeable, in progress, Review, m.okafor
Pull requestAuthor teamOwning teamBusiness hours openLinesReview stateNext actionActor
identity-service #4471CheckoutIdentity46.284NoneReviewa.kowalski
payments-ledger #2913Mobile CorePayments Core39.5312PendingReviewr.mehta
data-contracts #788SearchData Platform33.056ApprovedMergej.lindqvist
billing-engine #1650Payments CoreBilling28.7640Changes requestedFix codep.santos
api-gateway #5102NotificationsAPI Gateway22.418NoneAssign reviewere.dubois
ui-kit #9310GrowthShared UI Kit17.1130PendingReviewm.okafor

Key Insight: 188 cross-team pull requests only need someone to press merge: data-contracts #788 is approved, mergeable and green. identity-service #4471 has waited 46 business hours without a single review, and Keypup names who should pick it up. billing-engine #1650 is the other face of the tax: 640 lines, changes requested, now conflicting. It needs a conversation, not another review round.

The Technical Implementation: What Keypup MCP Actually Reads

Every number above comes from fields Keypup imports from your Git platforms, combined with a team mapping you provide. It helps to be precise about what each one depends on.

Cross-Team Comes From Your Team Mapping

Keypup records each pull request's author and its target repository. It doesn't hold an organization chart: which team owns a repository, and which team an engineer belongs to, come from the mapping you give your assistant. If your pull requests carry a label naming the owning team, the assistant can use that instead; it only works as far as those labels are applied consistently. The quality of every cross-team figure depends on that mapping being current: an engineer who moved teams last quarter counts in their new team for the whole period, unless your mapping has dates.

Waits Come From Pull Request Dates

Each pull request carries its creation date, its review request date, its first submitted review date, its first changes-requested date and its merge or close date. Waits are the business hours between two of them, computed by Keypup with the working hours and time zone you give. Pull requests without an explicit review request have no wait to first review, and are left out of that chart.

Outcomes Come From Pull Request State

A pull request is open, draft, merged or closed without merge. "Abandoned" in this article means closed without merge: Keypup doesn't know why. Some were replaced by another pull request, some were duplicates; the share is a signal to look, not a verdict.

Review Concentration Comes From Submitted Reviews

Keypup imports each submitted review, its reviewer and its state: approved, changes requested, commented or dismissed. Counting reviews per reviewer on cross-team pull requests shows how the load is shared. Reviews given as plain comments outside a review are not counted as reviews.

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 your organization chart, CODEOWNERS files or repository permissions: ownership comes from your mapping. It doesn't import chat or design discussions, so a conversation that happened before the pull request isn't visible. And it doesn't read why a pull request was closed: closing comments are free text, and this analysis doesn't classify them.

Real-World Impact: Enterprise Case Studies

Case Study 1: European Insurance Group

Before Keypup MCP:

  • 1,400 engineers, with an inner source program launched to replace cross-team tickets
  • A dashboard counting cross-team pull requests opened, growing every quarter
  • Recurring complaints that platform teams "never review"

After Keypup MCP:

  • The outcome chart changed the success metric: the program now tracks the share of cross-team pull requests merged within five business days, not the number opened
  • A review rotation for outside contributions in the four owning teams receiving half of them, with one engineer per sprint assigned to cross-team reviews
  • A daily list of stuck cross-team pull requests shared with each owning team's lead, ordered by Keypup's recommended action

"We were celebrating the number of inner source pull requests. Then we saw that one in five was thrown away. Now we celebrate the ones that ship."

— Head of Engineering Productivity, European Insurance Group

Case Study 2: North American Logistics Platform

Before Keypup MCP:

  • 900 engineers in 30 teams sharing a handful of core libraries
  • Two senior engineers in the core library team reviewing nearly every outside contribution
  • Large, unannounced contributions sent back again and again

After Keypup MCP:

  • The concentration chart made the load visible: the core library team added six reviewers for outside contributions, with the two seniors kept for design questions
  • A contribution guide and a 200-line guideline: changes above it start with a short design note to the owning team
  • The share of cross-team pull requests sent back fell as contributions got smaller and contributors learned the conventions

"Everyone thought the core team was slow. The data said two people were doing all the outside reviews while also building the roadmap. We fixed the staffing, not the people."

— VP Engineering, North American Logistics 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 and merges are imported automatically, along with mergeability and build status where your platform provides them.

2. Write Down Who Owns What

Build a simple mapping of repositories to owning teams and engineers to teams, from your CODEOWNERS files or your team directory. Keep it in a file your assistant can read, and update it when teams change.

3. Make Review Requests Explicit

The wait to first review needs a review request. Ask contributors to request a reviewer from the owning team when they open a cross-team pull request, so the clock starts when the request is made.

4. Agree on Your Working Hours and Thresholds

Business hours depend on your teams' working days and time zone. State them in your prompts, along with what counts as "stuck", such as 16 business hours without a review, so every team reads the same numbers.

5. Connect the MCP Server to Your AI Assistant

Connect the MCP server to your AI assistant using the MCP documentation, run the cross-team comparison for your last 12 months to set a baseline, then share the list of stuck cross-team pull requests with owning teams every morning.

Frequently Asked Questions

What is inner source?

Inner source is the practice of applying open source habits inside a company: any engineer can propose a change to any team's code through a pull request, and the owning team reviews and merges it. It's meant to replace "file a ticket and wait" with "fix it yourself".

Why do cross-team pull requests take longer to merge?

Because reviewing outside work rarely appears in the owning team's plan, outside reviews tend to fall on one or two experts, and contributors don't know the codebase's conventions, so their changes are larger and get sent back more often. Measuring the wait, the outcome and the reviewer load by owning team shows which applies.

How do you measure inner source success?

Count outcomes, not volume: the share of cross-team pull requests merged within a set time, the share closed without merge, and the wait to first review, compared with pull requests inside the team. Follow them by owning team to see where the program works and where it doesn't.

How do you speed up reviews of cross-team pull requests?

Give owning teams explicit capacity for outside reviews, such as a rotation, spread those reviews beyond one or two experts, publish a contribution guide, and ask for a short design conversation before large changes. Then review the list of stuck cross-team pull requests every day.

The Bottom Line

Inner source works when contributions across team boundaries ship as fast as work inside a team. In many enterprise organizations they don't: they wait longer, get sent back more, and are quietly abandoned, while the program's dashboard counts pull requests opened. Keypup MCP makes the inner source tax visible:

✅ Measuring what crossing a boundary costs, against work inside the team ✅ Following what happens to cross-team pull requests, including the ones that never ship ✅ Seeing how long contributors wait for a first look, hour by hour ✅ Finding which owning teams are bottlenecks, beyond volume ✅ Checking whether outside contributions get sent back more, by size ✅ Seeing who reviews the outsiders, and how concentrated the load is ✅ Listing the cross-team pull requests to unblock today, with who should act

Ready to find out what crossing a team boundary costs your engineers? 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.

Most Recent Articles

Merge Limbo: Why Approved Pull Requests Wait Days to Ship

Merge Limbo: Why Approved Pull Requests Wait Days to Ship

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.

Stephane Ibos
The Reviewer Bystander Effect: Why More Reviewers Make Pull Requests Wait Longer

The Reviewer Bystander Effect: Why More Reviewers Make Pull Requests Wait Longer

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.

Arnaud Lachaume
The Backport Tax: Why Supporting Multiple Release Versions Quietly Drains Delivery Capacity

The Backport Tax: Why Supporting Multiple Release Versions Quietly Drains Delivery Capacity

In a typical enterprise that supports several versions of its product, one merged pull request in five targets an older release line, and customers on the oldest line wait ten business days for fixes already merged on main. Learn what engineering leaders on Reddit say about backports and LTS maintenance, and how Keypup MCP measures the backport tax, line by line.

Thomas Williams