Monorepo vs Multi-Repo: A Fair Comparison
Contents
Contents
TL;DR
- Multi-repo gives every service its own copy of each shared library, pinned at its own version. Over time those versions drift, and a library fix becomes one PR on the library plus one re-pin PR per service that uses it.
- Count the PRs: shipping one library fix to 20 services is 21 PRs in multi-repo and 1 in a monorepo. The CI minutes are about the same, because a monorepo still has to test all 20 services. What you save is reviews, merges and calendar time, and you find breakage before the library is released.
- Big companies split both ways. Google, Meta, Microsoft (Windows), Uber, Stripe and Dropbox keep huge monorepos; Spotify and Netflix run thousands of repos. Both sides ended up building the same thing: tooling that keeps one version of each dependency and makes fleet-wide changes cheap.
- A monorepo isn’t free: Git slows down, CI has to know what a change affects, access control gets coarse, and coupling becomes easy. Multi-repo keeps team autonomy and clean boundaries, and wins when code has different owners, secrecy rules or release cycles.
- For one team or one product sharing Python libraries, I’d start with a monorepo. Across a whole organisation, the repo layout matters less than having one version of each dependency and automation to change many places at once.
This post compares a monorepo with multi-repo (also called polyrepo) as fairly as I can, mostly from what large engineering organisations have published about the problem. I don’t have a first-hand case with measured numbers to add, so treat the conclusions as informed by published accounts, not by a before-and-after of my own. It’s a companion to Git Flow vs trunk-based development: that post ended by saying a monorepo is a separate decision, and this is that decision. It’s for backend developers with a handful of services and shared libraries, wondering whether to put them in one repository.
The numbers below are worked examples, not measurements from a specific team: plug in your own.
The two models in one minute
A monorepo keeps many projects (services, libraries, tools) in one version-controlled repository. Each service in it can still be built, tested and deployed on its own, so a monorepo can hold many microservices. What’s shared is the history, the tooling and, usually, the dependency versions.
Multi-repo gives each project its own repository. Shared code is published as a package (to PyPI, a private index or a container registry), and each consumer pins the version it wants.
| Aspect | Multi-repo | Monorepo |
|---|---|---|
| Repositories | One per service or library | One |
| How a service gets a shared library | Pins a published version (common==1.3.2) | Imports it from the same tree, at the current commit |
| Versions of a library in use | As many as there are pins | One |
| A change across a library and its callers | One PR per repo, in the right order | One PR |
| CI | Each repo tests itself | Has to work out what a change affects, and test that |
| Access control | Per repo | Per directory, through review rules (CODEOWNERS) |
| Tooling and config | Copied into every repo | Shared |
Here’s the difference drawn out with one shared library and three services:
Where multi-repo hurts
One library, many versions
Every service pins its own version of each shared library. Updating the pin is a chore nobody schedules, so the versions spread out: billing is on 1.4, orders on 1.3, search on 1.2. “Is this bug fixed in search?” starts with checking which version search actually runs.
Segment described exactly this in 2018. They had over 140 services, each destination in its own repo, sharing libraries for common logic. Under time pressure, engineers bumped a shared library in the one service they were working on and left the rest behind, and “over time, the versions of these shared libraries began to diverge across the different destination codebases”. Changes that should have taken an hour or two sometimes took a couple of days to a week.
A change across repos is several PRs, in order
Renaming a function in a shared library goes like this: a PR on the library, a release, then a PR in every repo that calls it, each one reviewed and merged on its own. If the change breaks something, you find out in the caller’s PR, after the library is already released. Then you release again.
Uber’s iOS team hit this in 2016 with over forty modules in separate repos: a change in one module only showed up after updating the app’s dependency file, and a breaking change meant updating every dependent module by hand. Proton listed the same pain for its web apps: one feature meant repeating branches, merge requests, reviews and rebases in each repo, and no single operation could roll back several repos at once.
Re-pins multiply
Say a fix in common is needed by 20 services:
Counting a CI run on the PR and another on the merge, multi-repo is 21 × 2 = 42 runs, and the monorepo is 2. (That assumes a dedicated re-pin PR per service. A dependency bot that groups updates, or services that were about to bump the pin anyway, lowers the multi-repo count.) That looks like a huge win, but each of those 2 monorepo runs has to test the library and the 20 services that depend on it. If a service’s suite takes 15 minutes, the CI minutes come out about the same. What you save is people’s time: 20 fewer PRs to review and merge, no release step in the middle, and breakage that shows up in the library PR, before release, where in multi-repo it would surface in service 14’s re-pin a week later.
The calendar time is the bigger cost, and it’s the one you can see in published numbers. Before Spotify automated it, getting a new version of their internal service framework onto 70% of backend services took about 200 days.
Everything else is copied N times
CI workflows, linter config, Dockerfiles, pre-commit hooks, the Python version: each repo has its own copy, and they drift like the library pins do. Fixing the lint rule everywhere is another round of PRs.
Finding who uses what
“Who calls this function?” is a grep in a monorepo. In multi-repo, you need a code search tool that indexes every repo, or you ask around. In a 2018 survey of Google engineers who had worked with both models, visibility of the codebase (finding APIs to reuse, usage examples, and having callers updated when an API changes) was the main reason they preferred the monorepo.
What a monorepo would change
With one repository, every service imports common from the same commit, so there’s nothing to re-pin, and the library author changes the function, fixes every caller and lets CI test all of them in one PR. Tooling and config are shared, and a CODEOWNERS file says who reviews which path, so teams keep control of their services.
It would not change how you deploy. Each service is still its own image with its own pipeline. And one commit still means several deploys: if a PR changes an API and its callers together, the services still roll out at different moments, so the old and new versions have to work side by side for a while. You still need backwards-compatible changes; the monorepo only removes the wait between them.
A uv workspace
In Python, uv workspaces give you a monorepo without extra build tools: several packages, one lockfile. A layout for one library and two services:
repo/
├── pyproject.toml # workspace root
├── uv.lock # one lockfile for every member
├── .github/
│ ├── CODEOWNERS
│ └── workflows/
├── libs/
│ └── common/
│ ├── pyproject.toml
│ └── src/common/
└── services/
├── billing/
│ ├── pyproject.toml
│ ├── Dockerfile
│ └── src/billing/
└── orders/
└── ...
The root pyproject.toml only lists the members:
[tool.uv.workspace]
members = ["libs/*", "services/*"]
Each service depends on common by name, and workspace = true tells uv to take it from the tree instead of an index:
# services/billing/pyproject.toml
[project]
name = "billing"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = ["common", "fastapi>=0.115"]
[tool.uv.sources]
common = { workspace = true }
Install and test one service, with only the packages it needs:
uv lock
uv sync --locked --package billing
uv run --package billing pytest services/billing
The single uv.lock is the one-version rule for third-party packages too: billing and orders can’t end up on different httpx versions. That’s also the limit. uv’s docs say workspaces “are not suited for cases in which members have conflicting requirements”, and the whole workspace gets a single requires-python. So if your services pin different versions of the same library today, they have to agree on one before they move in, and that can be the bulk of the migration. A member that really can’t agree should stay a separate project with a path dependency.
Building images from the workspace
Docker only sees the build context, and billing needs libs/common, so the build has to run from the repo root:
docker build -f services/billing/Dockerfile -t billing .
# services/billing/Dockerfile
FROM python:3.12-slim
# Pin a uv version instead of latest in real use
COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
WORKDIR /app
COPY . .
RUN uv sync --locked --no-dev --package billing
# CMD for your service
Two side effects. .dockerignore now decides what every image can see, so it carries more weight than in a single-service repo:
.git
**/.venv
**/__pycache__
And COPY . . means a change anywhere in the repo invalidates the layer, so every image rebuilds its dependencies. uv’s Docker guide shows how to install third-party packages in their own cached layer first, with uv sync --frozen --no-install-workspace, and copy the source afterwards.
Versioning packages separately
In multi-repo, a repo’s tags are its versions. In a monorepo, tags need the package name in them: common-v1.4.0, billing-v2.1.0. release-please’s manifest mode does this: one config file, a manifest with each package’s version keyed by its path, and tags in the form <component>-v<version>. Python is a supported release type. If you build version numbers from Git tags with setuptools-scm, give each package its own tag prefix in its pyproject.toml ([tool.setuptools_scm.tag] with prefix = "common-v", per the setuptools-scm docs) so it only reads its own tags.
I haven’t found a tool that gives you one lockfile and independent versions per package out of the box; expect some glue. For services you deploy but never publish, you may not need package versions at all: the commit SHA on the image is enough.
CI that only tests what changed
Each service gets its own workflow, triggered by its own path and by everything it depends on:
# .github/workflows/billing.yml
on:
pull_request:
paths:
- "services/billing/**"
- "libs/common/**"
- "uv.lock"
push:
branches: [main]
paths:
- "services/billing/**"
- "libs/common/**"
- "uv.lock"
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: astral-sh/setup-uv@v10.3.2
- run: uv sync --locked --package billing
- run: uv run --package billing pytest services/billing
A change to services/orders/ doesn’t run billing’s tests; a change to libs/common/ runs both. Two catches:
- The dependency list is by hand. If billing starts importing a new library and nobody adds its path, a change to that library skips billing’s tests. Build tools such as Bazel, Pants, Buck2, Nx or Turborepo work this out from the dependency graph instead. For a handful of services, the hand-written list is usually enough.
- Skipped workflows block required checks. If you make
testa required status check, a PR that doesn’t touch billing never runs it, and the PR waits forever. GitHub documents this: a job skipped by anif:condition reports success, so for required checks, keep the workflow always running and skip the job with a change-detection step andif:instead of workflow-levelpaths.
CODEOWNERS keeps reviews with the right team:
/libs/common/ @your-org/platform
/services/billing/ @your-org/billing
/services/orders/ @your-org/orders
/uv.lock @your-org/platform
Note: action versions, uv flags and GitHub’s path-filter behaviour change over time (this was written in October 2026). The ideas that last are one version per dependency, test what a change affects, and own code by directory.
How big companies do it
I looked at what large engineering organisations have published about how they lay out their code. Same caveats as last time: these are their own blog posts, papers and talks, and their scale is not most teams’. What’s useful is the problems they ran into.
| Company | Layout | Scale (when published) | What they built to make it work |
|---|---|---|---|
| One monorepo for almost everything, except open source projects like Chromium and Android (SWE book) | 86 TB, about 2 billion lines, 16,000 human and 24,000 automated changes a day (CACM, 2016); about 50,000 engineers (2020) | Its own VCS (Piper), Bazel’s predecessor, OWNERS files per directory, automated large-scale changes | |
| Meta | Monorepo | Too big for stock Git or Mercurial | Decided not to split it; built Sapling, EdenFS and Mononoke (2022) and the Buck2 build system (2023) |
| Microsoft (Windows) | Moved from 40+ Source Depot depots to one Git repo | 3.5 million files, about 300 GB, about 4,000 engineers (2017) | GVFS (later VFS for Git), then Scalar; much of it went upstream into Git |
| Uber | Monorepos per language and platform; iOS moved from 40+ repos in 2016 | Go monorepo: under 10 to nearly 900 monthly engineers, 70,000+ files (2020) | Buck and Bazel, SubmitQueue to keep main green |
| Stripe | Ruby monorepo | About 50 million lines, 1.2 million test units (2026) | Selective test execution: about 5% of the suite runs on an average change |
| Dropbox | Backend monorepo | Grew to 87 GB (2026) | A server-side repack with GitHub (see below) |
| Canva | Monorepo | 500,000 files, about 60 million lines (2022) | Git tuning (see below) |
| Segment | 140+ repos and services, then back to one repo (2018) | 120 dependencies standardised on one version each | A monorepo and a single service |
| Spotify | Polyrepo, thousands of GitHub repos | Over 300,000 automated changes merged, 75% auto-merged (2023) | Fleet management: automation that changes thousands of repos at once |
| Netflix | Polyrepo, tens of thousands of Java repos (2026) | Nebula Gradle plugins to share build logic, keep dependencies current and lock versions | |
| Kubernetes | One repo for development, published as many | client-go and others are mirrors of staging/ (README) | A publishing bot that syncs commits and tags out to separate repos |
A few gaps: Amazon is the obvious missing name. Second-hand accounts describe a multi-repo setup with an internal build system that pins sets of package versions, but I couldn’t find a primary source, so it’s not in the table. Shopify has talked about a “World” monorepo, but I only found a conference listing, not a write-up.
Both layouts work at the largest scale, and nobody in that list runs either one with stock tools. Monorepo companies built version control, build systems and CI that scale. Polyrepo companies built automation that changes thousands of repos at once and keeps their dependencies in line. Google’s own book is blunt about what matters more:
“What is important is not whether we focus on monorepo; it’s that we adhere to the One-Version principle to the greatest extent possible.” (Software Engineering at Google, ch. 16)
The same chapter even admits that a well-built virtual monorepo (many repos stitched together with a shared idea of trunk and dependencies) “could have been a better investment” than their custom system.
What they ran into, and how they fixed it
| Problem | Who | What they did |
|---|---|---|
| Git gets slow with millions of files | Microsoft, Canva | Virtual file system, then Scalar; file-system monitor, untracked cache, git maintenance, sparse checkout (Canva’s git status went from about 10 s to 3 s) |
| The repo gets too big to clone | Dropbox: 87 GB, clones over an hour | Found the cause in Git’s delta compression heuristic, repacked on GitHub’s side: 20 GB, clones under 15 minutes |
| CI runs everything on every change | Stripe, Uber, Google | Test only what a change affects: Stripe records which files each test opens; Uber hashes Bazel targets |
| Main breaks when many people merge | Uber iOS: on the worst days about 10% of commits were reverted | SubmitQueue (a merge queue): main green 99% of the time |
| Huge changes can’t be atomic anyway | Large-scale changes are split by owner into thousands of small, independently tested changes | |
| Shared libraries drift across repos | Segment, Spotify | Segment moved to a monorepo with one version per dependency; Spotify automated the upgrades across repos (framework rollouts from about 200 days to under 7) |
| Build tools stop scaling | Uber Go, Meta | Bazel with generated build files (Uber dropped Make and go build), Buck2 |
| Moving everyone at once is risky | Block: about 450 JVM services and libraries (2026) | A seven-month pilot with a few willing teams, build and CI quality gates before each project could join, and pausing the migration when scaling issues appeared |
| Required checks don’t fit a monorepo | Ledger Live (2024) | Three CI iterations in two years: grouped workflows, then a GitHub App, then one master workflow |
Segment, Uber iOS and Proton moved into a monorepo to fix drift and slow cross-repo changes. Spotify fixed the same drift with automation and kept its thousands of repos. The Git, repo-size and CI rows are problems that only monorepo companies had to solve.
The case against monorepos
- Tooling is the real cost. Matt Klein’s “Monorepos: Please don’t!” (2019) makes this point: the tooling a monorepo needs at scale is expensive, and most organisations can’t afford to build it. The table above is consistent with that at the top end: Google, Meta and Microsoft each built or rebuilt their version control.
- CI has to understand the graph. Without affected-only testing, every PR runs every test, and CI becomes the bottleneck. Hand-written path filters drift; graph-aware tools are another thing to learn and maintain.
- Access control gets coarse.
CODEOWNERScontrols who reviews a path, not who can read it. Google’s book says a true monorepo fits only if every project has the same secrecy, legal, privacy and security requirements. The 2018 Google survey found that engineers valued multi-repo for access control and stability. - CI time grows with the repo. DigitalOcean wrote in 2017 that as its Go monorepo grew, “our CI build times have grown exponentially”, and that ownership of the repo’s tooling and pipelines was hard to pin down. The repo itself needs an owner, besides the owners of the code in it.
- Coupling becomes easy. When everything is one import away, unrelated code starts depending on each other. Uber’s iOS shared library became a catch-all in 2014 for exactly that reason. You need rules about what may import what.
- One main branch for everyone. A broken
mainblocks every team, not just one. You need a merge queue sooner than you’d think. - You lose some freedom. One lockfile means one version of
pydanticfor everyone. A team that needs a different version, or a different toolchain, has to argue for it. - Sharing a piece with the outside is harder. Open-sourcing one library out of a monorepo needs something like Kubernetes’ publishing bot.
- Migrating costs time. Merging Git histories, rewriting CI, and a few rough weeks: Proton had pipeline failures in the first week.
“Isn’t a monorepo riskier?”
The objection I’d expect first: if everything is in one place, one bad commit breaks everything. In my view a monorepo moves the risk around without adding to it. A bad change to a shared library reaches every service in both models. What changes is when and how it reaches them:
| Aspect | Multi-repo | Monorepo |
|---|---|---|
| Typical cause | Drift: a service stuck on an old library version, missing a fix, or two services on incompatible versions | A library change that passes its own tests but breaks a caller, or a broken main that blocks everyone |
| When you notice | Late: when a service finally re-pins, weeks after the library was released | Early: in the library PR, if CI tests the callers |
| Blast radius | One service at a time, as each re-pins | Every dependent service on its next deploy |
| Fix | A new library release and another round of re-pins | A fix PR or a revert, once |
| Prevention | Dependency bot, auto-merge, regular upgrades | Affected-only CI that really covers the callers, a merge queue, staged rollouts |
The monorepo risk is real, and you handle it at deploy time. In practice: when common changes, deploy one or two low-risk services before the rest. Uber’s staged rollout is covered in the Git Flow post.
Why big cross-cutting changes hurt more in a monorepo
A monorepo makes it possible to change a library and all its callers in one PR. That doesn’t mean you should:
- Review gets spread thin. A PR that touches 20 services needs a reviewer from each owning team. It waits for the slowest one, and nobody reviews the whole thing.
- Conflicts pile up. While a 20-service PR waits, every one of those services keeps moving. The bigger the PR, the more often you rebase.
- Reverting hurts everyone. If one service breaks, reverting the PR reverts the change for the other 19 too.
Google’s answer is in its large-scale changes chapter: the larger the codebase, the smaller the largest practical atomic change. Their tooling splits a big change by owner into many small ones that are tested and reviewed independently. For a library change, the usual pattern is expand, migrate, contract (the same idea as the schema changes in the Git Flow post): add the new function next to the old one, move callers over in small PRs (one per team), then delete the old one. The monorepo makes each step easy to see and test, and each step stays small enough to review and revert.
What a monorepo needs to work
Putting code in one place doesn’t solve the problems many repos were solving. Something else has to:
- CI and a workspace that fit. A uv workspace with one lockfile turns “one repo” into “one version of each dependency”. CI tests what a change affects: path filters for a handful of services, a graph-aware build tool once the hand-written lists stop being trustworthy. Cache dependencies and builds, or every run starts from zero. Each service keeps its own deploy pipeline.
- A merge queue. Many teams merge into one
main; a merge queue tests each PR against the futuremain, so two green PRs can’t combine into a red one. CODEOWNERSand import rules. Ownership per directory, and rules about which packages may import which, so the repo doesn’t turn into one big ball of coupling.- Git tuned for size, once it grows. Most teams never need this. When clones and
git statusget slow, start with the cheap options:
# Download file contents on demand instead of the whole history's blobs
git clone --filter=blob:none git@github.com:your-org/repo.git
cd repo
# Only check out the parts you work on
git sparse-checkout set services/billing libs/common
# Background maintenance, and settings for repos with many files
git maintenance start
git config feature.manyFiles true
GitHub’s write-up on partial and shallow clones explains the trade-offs: blobless clones suit developers, while shallow clones (--depth=1) suit throwaway CI checkouts and cause surprises for day-to-day work.
Bringing the history with you
Copying the code into a new repo loses git blame, which is most of the reason to keep history. Three ways to keep it:
| Option | What happens to history | Good for |
|---|---|---|
git filter-repo --to-subdirectory-filter <dir> on each repo, then merge | Every commit is rewritten under the new folder, so SHAs change and old links to commits break (filter-repo can keep an old-to-new map in refs/replace) | A one-off move where nobody links to old commits |
| tomono | Original commits keep their hashes; it adds a move commit and a merge commit per repo | A one-off move where tickets and docs link to old commits |
| Josh | A proxy that serves subdirectories of the monorepo as their own repos, with fetch and push | A long transition where some people keep working in the old repos |
None of them move pull requests, review comments or links from issue trackers. Those stay in the old repos, so archive them read-only instead of deleting them.
And what multi-repo needs
Multi-repo has a list too, and it’s the list Spotify and Netflix built. Done properly, it’s a complete strategy in its own right:
- A dependency bot with auto-merge. Renovate or Dependabot opens the re-pins, and they merge when CI is green, so drift is measured in days, not months.
- Shared CI and config, imported from one place. Reusable workflows, or build logic shipped as plugins the way Netflix does with Nebula, so a lint rule changes once.
- Templates with drift checks. Create repos from a template (Copier, cookiecutter) and keep checking them against it:
cruft checkfails CI when a repo has fallen behind its template, andcruft updatebrings it back. - A golden path. Spotify’s name for the supported, documented way to build a service. Fewer choices means fewer things to keep in sync.
- A way to change many repos at once. Even a script that opens the same PR in every repo beats doing it by hand. At scale, that’s Spotify’s fleet management.
- Code search across all repos. So “who calls this?” has an answer.
When multi-repo still makes sense
A monorepo wins on library changes, drift, finding usages and shared tooling (the sections above). Multi-repo wins where the differences are organisational:
| Concern | Why multi-repo fits |
|---|---|
| Setup cost | Each repo works with plain Git and simple CI; a monorepo needs affected-only CI and, later, Git tuning |
| Access control | Per-repo read permissions; CODEOWNERS only controls review |
| Different secrecy, legal or licensing rules | Code that can’t be seen by everyone needs its own repo |
| Team autonomy over toolchains and versions | Each repo can choose its own Python version, framework and pins |
| Open source or code shared with outsiders | External contributors need a normal repo (or a monorepo with a publishing step) |
| Projects with unrelated release cycles | A mobile app and a backend share little but the company name |
Limits of this comparison
- It’s built mostly from published accounts by companies far bigger than most teams, not from a controlled study. The Google survey is the closest thing to data, and it’s one company with its own custom tooling.
- The repo layout isn’t the only variable. Companies that moved to a monorepo often changed their build tool, CI and branching model at the same time. Segment moved to a monorepo and merged 140 services into one, so their gains can’t all be credited to the repo.
- The PR arithmetic assumes every service uses the library. Real fan-out is usually smaller, and a dependency bot with auto-merge closes much of the gap.
- The company accounts are self-reported, some are several years old (Uber iOS 2017, Segment 2018), and the Amazon and Shopify gaps are real.
- Every company here is large. I couldn’t find published evidence for a small team. The recommendation below for small teams is extrapolated from those accounts.
- Shared libraries are a cost in both layouts. A 2020 University of Oslo study of four companies found that shared libraries in microservices hurt agility, and recommends limiting them. A monorepo makes a shared library cheaper to change, but whether the library should exist is a separate question.
- “Monorepo” here means one repository for a team or product’s services and libraries. A whole company in one repo, Google-style, is a different project with a different budget.
Conclusion
Both models work, at every scale. Multi-repo is cheaper to set up, keeps permissions and autonomy simple, and fits code with different owners, rules or release cycles. A monorepo makes library changes, upgrades and refactors cheap, but asks for CI that understands what a change affects and, eventually, Git tuning.
For a backend team with a few services and shared Python libraries, I’d start with a monorepo: a uv workspace, path-filtered CI, CODEOWNERS and a merge queue. That setup is small, and it removes the round of re-pin PRs that follows every change to common. Across a whole organisation, the layout matters less than the rule Google, Spotify and Netflix all landed on: one version of each dependency, and automation that can change every place it’s used.
If you’re considering the move, don’t merge everything at once. Start with one shared library and the two or three services that use it most, and agree as a team on what counts as success. Good measures are time from a library fix to the last service running it, PRs per library change, CI wait time, and how many versions of each library are in production. Measure before and after, so the decision rests on numbers instead of arithmetic.
Questions or a different experience? I’d like to hear it.
References
- Software Engineering at Google, ch. 16: Version Control and Branch Management and ch. 22: Large-Scale Changes
- Why Google Stores Billions of Lines of Code in a Single Repository (CACM, 2016)
- Advantages and Disadvantages of a Monolithic Repository: A Case Study at Google (ICSE SEIP, 2018)
- Meta: Sapling, source control that’s user-friendly and scalable and Buck2
- Microsoft: The largest Git repo on the planet and Introducing Scalar
- Uber: Faster together, Uber Engineering’s iOS monorepo, Building Uber’s Go monorepo with Bazel and Continuous deployment for large monorepos
- Stripe: Selective test execution for a 50M-line Ruby monorepo
- Dropbox: Reducing our monorepo size to improve developer velocity
- Canva: We put half a million files in one Git repository
- Segment: Goodbye microservices
- Block: From polyrepo fragmentation to monorepo leverage
- Ledger: Ledger Live monorepo project, part 4
- DigitalOcean: cthulhu, organizing Go code in a scalable repo
- uv: Using uv in Docker
- release-please: Manifest releaser
- Spotify: How we use Golden Paths to solve fragmentation
- Improving Agility by Managing Shared Libraries in Microservices (University of Oslo, 2020)
- Proton: From polyrepo to monorepo
- Spotify: Fleet management, part 1
- Netflix: Scaling ArchUnit with Nebula ArchRules
- Kubernetes: staging repositories
- Matt Klein: Monorepos, please don’t!
- uv: Workspaces
- GitHub: Get up to speed with partial clone and shallow clone