Skip to main content
Catalog
T006
Technology

Monorepo Gravity Well

MEDIUM(75%)
·
February 2026
·
4 sources
T006Technology
75% confidence

What people believe

“Monorepos simplify dependency management and improve code sharing.”

What actually happens
+500%CI build time
+1000%Git clone time
SimplifiedCross-project code sharing
ProhibitiveProject extraction cost
4 sources · 3 falsifiability criteria
Context

Teams adopt monorepos to simplify dependency management, enable atomic cross-project changes, and share code easily. Google and Meta run massive monorepos, so it must work. But those companies built custom tooling costing millions — Bazel, Buck, custom VCS. Most teams adopt monorepos with off-the-shelf tools (npm workspaces, Turborepo, Nx) and hit scaling walls within 12-18 months. CI pipelines slow to a crawl as every change triggers builds across the entire repo. Git operations degrade as the repo grows. Ownership boundaries blur — everyone can change everything, so nobody owns anything. The monorepo becomes a gravity well: easy to add projects, nearly impossible to extract them.

Hypothesis

What people believe

“Monorepos simplify dependency management and improve code sharing.”

Actual Chain
→
CI/CD pipeline complexity explodes(Build times 5-10x longer within 18 months)
└
Every PR triggers cross-project builds
└
Flaky tests in unrelated projects block merges
└
CI costs scale superlinearly with repo size
→
Ownership boundaries dissolve(Shared code becomes nobody's responsibility)
└
Breaking changes propagate silently across teams
└
Code review bottlenecks on shared packages
→
Git performance degrades at scale(Clone, checkout, status operations slow 3-5x)
└
Developers need sparse checkout workarounds
└
IDE indexing becomes painfully slow
└
New developer onboarding time increases
→
Extraction becomes prohibitively expensive(Tightly coupled code resists separation)
└
Projects that should be independent can't be extracted
└
Monorepo becomes permanent architectural constraint
Impact
MetricBeforeAfterDelta
CI build time5-10 min per project30-60 min monorepo+500%
Git clone timeSecondsMinutes to hours+1000%
Cross-project code sharingPackage publishingDirect importsSimplified
Project extraction costN/AWeeks to months of workProhibitive
Navigation

Don't If

  • •Your team is under 20 engineers and projects have clear boundaries
  • •You don't have dedicated build infrastructure engineering capacity

If You Must

  • 1.Invest in build caching and affected-project detection from day one
  • 2.Enforce strict ownership boundaries with CODEOWNERS files
  • 3.Use sparse checkout and partial clone to manage repo size
  • 4.Define extraction criteria before projects enter the monorepo

Alternatives

  • Polyrepo with shared packages — Publish shared code as packages, keep projects independent
  • Focused monorepos — Group tightly coupled projects only, not everything
  • Git submodules — Shared code as submodules — ugly but maintains boundaries
Falsifiability

This analysis is wrong if:

  • Teams adopting monorepos with off-the-shelf tooling report sustained CI performance at scale beyond 50 projects
  • Monorepo adoption correlates with improved code ownership clarity rather than ownership diffusion
  • Project extraction from monorepos is routinely accomplished in under one week
Sources
  1. 1.
    Google Monorepo Paper: Why Google Stores Billions of Lines in a Single Repository

    Google's monorepo works because of massive custom tooling investment most companies can't replicate

  2. 2.
    Uber's Monorepo Migration Challenges

    Uber documented significant CI/CD scaling challenges after monorepo adoption

  3. 3.
    Nx and Turborepo Performance Benchmarks

    Build tools help but can't fully solve the fundamental scaling challenges of large monorepos

  4. 4.
    Microsoft 1ES: Lessons from the Largest Git Repo

    Microsoft's Windows repo required custom VFS for Git to function at scale

Related

This is a mirror — it shows what's already true.

Want to surface the hidden consequences of your engineering decisions?

Try Lagbase