Section

languages-frameworks

Kind

Editorial

Reading time

5 min

Updated

8 September 2026

Selecting Monorepo or Multiple Repositories to Solve Operational Problems That Already Exist

Are you on a software engineering team struggling with code management? Do dependencies between repositories trip over each other in the CI/CD pipeline? Does coordinating across teams cause unnecessary project delays? You may be at a point of needing to evaluate whether your projects belong in a monorepo, or should spread out across repositories.

The choice between monorepo and multiple repositories is not a matter of style, a trend, or a developer preference. It's driven by operational failures: frequent cross-cutting changes, slow CI, and coordination challenges between teams.

Why? Because the operational costs of coordination are real. When teams are constantly copying each other's work, or are always anxiously testing every change to see if it affects what they are working on, you know you either need a monorepo - or to split work more cleanly into separate repositories.

The Symptoms That Offer the Question

Engineering teams arrive at the repository question the hard way - when operational symptoms, hiccups in the process - become impossible to ignore. This might come up when:

• Changes constantly spill into adjacent repositories, creating cross-cutting issues
• In CI, pulling builds of systems that aren't involved causes unnecessary delays
• Unclear ownership and responsibilities cause coordination problems

In each case, the problem lets us know that the current architecture is failing by enforcing boundaries in a way that's too coarse - deciding is simple when you name the things that tell you when you are doing it the wrong way. You're not sure whether to try monorepo - but you are pretty sure that structuring code around current boundaries is not enough.

Monorepos offer an alternative: bring interdependent code paths into a single repository, so that boundaries and updates are much finer, but all configuration is shared. A monorepo can prevent the worst of coordination problems. If teams often need to integrate code, or synchronization problems constantly derail other progress - this is a good indication that a monorepo can solve those problems.

But it's not free. Monorepos demand:

1. Build-time awareness of what has changed.
2. A strict selective testing plan, so that testing does not bog down.
3. Explicit boundary rules that tell teams and tools what is and is not part of a piece of work, pressuring them to make the own boundaries explicit.

What a Monorepo Demands

Monorepos carry the weight of their greater scale, size, and integration. CI must wisely skip most projects most of the time, skipping them unless they are directly affected by a change. CI runs have to validate that a change really does not touch a subsystem that would be impacted.

This is why monorepo CI tooling is built around the principle that CI should only operate on a limited number of projects - whether those are Tree-shaked from the code or Affected from the CI perspective. The vast majority of projects have to be omitted.

Selective testing of affected projects is not just an option as the scale of a monorepo grows: tests must be configured to be kept extremely limited as well, even though tools like Nx assure that Affected runs can be used to validate the build output, it needs to be kept aware of what has changed. the need to build only affected projects when a change is tested, and only run the dependent tests for a relevant library. This is good practice across branches, often used in project builds, requiring transparency in build details to increase public trust

Graphite de-emphasizes monorepo testing configuration, highlighting that even in a one-repo team boundaries can be set up and separation encouraged using Monorepos as testing a monorepo will need automation as well. In their real-world usage, the automation and tooling to separate changes is built into the GitHub CODEOWNERS gauge rely on a monorepo architecture, which packages repositories into separate files and allows managing builds and dependencies.

Ownership Is Not Optional

The lack of boundaries makes ownership harder in practice - because the team that makes a change may not own the code they have just affected. Monorepos shift boundaries while exponentially increasing the opportunities for teams to create confusing ownership arrangements - you need explicit rules for ownership to prevent a free for all.

Bringing in team boundaries requires both defining sets of owners for the different modules, and configuring the system to require that set for every branch. That's why GitHub's path-based CODEOWNERS files are so important: they give external administrators (branch protections) the ability to make ownership agreements cover the files as well.

Nx's approach encourages an assertive approach to ownership in modules

Without explicit rules about what belongs to a particular team or module, a monorepo is vulnerable to teams without editing permissions requesting to implement a large percentage of features. This is instead of having a central feature owner manage the repository actions.

These boundaries hold even though lines of growth are identical: they focus on ownership. Instead, Graphite's approach ensures ownership clarity in stable repositories.

CI has to stop consenting every change globally

Monorepos cannot operate without selective CI tools - and selective CI tools are tools that transcend those monorepos.

Buildkite, Nx, and Graphite highlight that in practice, monorepos are most usable when they can restrict the number of affected projects proactively: Nx's Affected tooling, Graphite's owned testing practices, and Buildkite's selective testing recommendations are each built around the notion that the vast majority of repository contents have to be off-limits for testing, preventing waste of cycles and time.

This selective CI is necessary - but it also carries the risk of siloing work. Teams come to have their heads down, their focus so lasered, that they lose sight of changes in other parts of the system. The whole risks falling apart when change happens.

Boundary discipline is the hidden work

Monorepos depend on invisible work that stays hidden: the monitoring of team boundaries. Create branches whose changes invalidate any boundaries or permissions - and if you cannot anticipate them, then you need to intervene when they come, disrupting work in process.

Monorepos require teams to manage testing scope manually for broad changes - but they need to have manual processes in place beforehand to handle those breaks to rules.

This intervening is continuous: teams have manual, formal ways of updating boundaries and sharing agreements about permissions on a regular basis, in agreement about the piecemeal nature of these changes

The Practical Takeaway

Engineering teams argue too much about labels - monorepo or repositories - when the real decision point is how to handle cross-cutting changes and outlined the steps. The practical decision is knowing when a project needs a monorepo - and practical fact-checking tools like Nx's Affected command provide the realism in development periods to make informed decisions.

The offered takeaway to how engineering teams justify describing what change is needed for, it recognizes that monorepos are inexpensive but risky default - readily capable of creating performance bottlenecks when a monolithic niche is needed less. Instead, break it down first into smaller repos to restore silos. In turn, select partners to grow the project, instead of trying to rush collaboration.

Where practical, though, a monorepo can initialize collaboration across teams - and set up ownership boundaries that sustain it.