Turborepo vs Nx vs Lerna: 7x CI Speed Gap [2026]

Monorepos stopped being a niche choice years ago, and by August 2026 the fight over which tool orchestrates that monorepo has narrowed to three real contenders: Turborepo, Nx, and Lerna. Every JavaScript and TypeScript team running more than two or three packages in one repository eventually asks the same question: does the caching engine actually save CI money, or is it marketing? This comparison pulls version numbers, GitHub star counts, npm download figures, pricing tables, and independent benchmark data to answer that question with numbers instead of vibes.

The short version: Turborepo’s turbo package sits in the 2.10.x line as of early August 2026 (v2.10.8 published August 5), Nx just shipped its v23 major release on June 16 with 23.1 following in August, and Lerna — now stewarded by the Nx team since 2022 — has moved to a v10.0.x line as of late July 2026. None of the three is dead. All three ship active releases. But they solve different-sized problems, and picking the wrong one costs real engineering hours during CI waits.

·

Google · Preferred Sources

Don't miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Add Now

Turborepo vs Nx vs Lerna: Quick Comparison Table

Before diving into feature-by-feature detail, here’s the specs table engineering leads actually screenshot and paste into Slack when a team is deciding which build system to adopt.

Spec	Turborepo	Nx	Lerna
Latest version (Aug 2026)	2.10.8 (npm), 2.10.11 (source)	23.1.x	10.0.1
Maintainer	Vercel	Nx Inc. (formerly Nrwl)	Nx Inc. (stewardship since 2022)
License	MPL-2.0, open source	MIT (core), paid Nx Cloud	MIT, fully open source
GitHub stars (approx.)	~30-31K	~29K	~36K
Weekly npm downloads	16-22M (turbo package)	~8.4M (nx package)	1.3-2.1M (lerna package)
Core role	Task runner + caching	Full build system + platform	Versioning + publishing (delegates builds to Nx)
Remote caching	Yes, via Vercel Remote Cache or self-hosted	Yes, via Nx Cloud	Inherited from Nx integration
Distributed task execution	No native distribution	Yes, Nx Agents	No (relies on Nx)
Affected-graph detection	Yes, via --affected/--filter	Yes, Nx Affected	Via Nx integration only
Package manager support	npm, Yarn, pnpm, Bun	npm, Yarn, pnpm, Bun	npm, Yarn, pnpm, Bun
Free tier ceiling	Free CLI; remote cache free on all Vercel plans (fair-use limited)	50,000 credits/month, up to 5 contributors	Free, no paid tier
Config complexity	Low (single turbo.json)	Higher (project graph, plugins, generators)	Low (delegates to package manager workspaces)
Best fit	Small-to-mid JS/TS monorepos, Next.js shops	Large polyglot enterprise monorepos	npm package publishing across multiple packages

That table alone answers most quick decisions. The rest of this piece covers where those numbers came from, what they mean in practice, and which one actually saves CI minutes at your team’s scale.

What Each Tool Actually Is (and Isn’t)

These three tools get lumped together as “monorepo tools,” but they aren’t interchangeable. Turborepo is a task runner. It takes your existing package.json scripts, builds a dependency graph between packages, and caches the output of each task so re-running an unchanged task is instant. Nx is a broader build platform: it does everything Turborepo does, plus code generation, plugin ecosystems for specific frameworks (Angular, React, .NET, Java are all GA as of the v23 line), and distributed task execution across multiple CI machines via Nx Agents. Lerna, meanwhile, isn’t really a build tool anymore. It’s a versioning and publishing layer — the tool that bumps package versions, writes changelogs, and pushes to npm across dozens of packages in one command — and as of 2022 it delegates the actual build/task-running work to Nx under the hood.

That distinction matters because “Turborepo vs Nx vs Lerna” isn’t really a three-way fight for most teams. It’s closer to “Turborepo vs Nx” for build orchestration, with Lerna sitting alongside either one when a team needs to publish many packages to npm with synchronized or independent versioning. Understanding that upfront saves a lot of confused Slack threads.

Turborepo: Built by Vercel, Optimized for Simplicity

Turborepo was built by Vercel (originally acquired from a separate startup in 2021) and its DNA shows: it favors minimal configuration, works out of the box with existing npm scripts, and integrates tightly with Vercel’s hosting platform. A turbo.json file defines the task pipeline — which tasks depend on which, what gets cached, what inputs invalidate the cache — and that’s largely it. According to Turborepo’s official documentation, the 2.10 release line (shipped June 24, 2026) added graceful task shutdown, deferred input hashing, and composable --affected/--filter flags for more precise change targeting.

Companies running Turborepo in production include Vercel itself, Netflix, Datadog, Shopify, and AWS Amplify, according to adoption discussions tracked on the project’s GitHub repository. That list skews toward teams already living in the Next.js/Vercel ecosystem, which tracks: Turborepo’s remote caching is free across all Vercel plans (Hobby, Pro, and Enterprise), subject to fair-use limits ranging from 100GB of monthly cache uploads on Hobby up to 4TB on Enterprise, per Vercel’s remote caching documentation.

Nx: The Platform Play

Nx takes the opposite bet: more configuration up front in exchange for more capability at scale. Its core documentation describes a project graph that maps every package’s dependencies, a plugin system that auto-configures build tooling for frameworks ranging from React and Angular to .NET and Java, and code generators that scaffold new packages with consistent structure. Nx v23 shipped June 16, 2026 with native Node TypeScript stripping, improved migration tooling, and deeper Vite integration. The 23.1 point release in August added per-run performance reports, TypeScript 6 support, and Angular 22 compatibility.

The feature that actually separates Nx from Turborepo at scale is Nx Agents — distributed task execution that splits a CI run across multiple parallel machines rather than just caching within a single runner. Nx’s own blog post on the topic, titled “Nx Agents, now 4x faster and 30% cheaper than GitHub Actions,” claims meaningful cost and speed advantages for large monorepos specifically because of that distribution model, not just caching. Enterprise adopters cited in Nx customer stories include Broadcom (177 projects, roughly 2x CI speed improvement after adopting remote caching and distribution) and Caseware (700+ projects, reporting 181 days of compute time saved weekly).

Lerna: The Veteran That Refused to Die

Lerna predates both Turborepo and Nx as a monorepo tool — it was the default answer for JavaScript monorepo management for years before either competitor existed. In 2022, Lerna’s original maintainer stepped down and effectively declared the project unmaintained. The Nx team (then Nrwl) stepped in with a blog post titled “Lerna is dead — Long Live Lerna,” taking over stewardship. As of the v9.x and v10.x releases in 2026, Lerna is explicitly positioned as a versioning and publishing tool that delegates task running, caching, and affected-graph detection to Nx under the hood, according to Lerna’s GitHub repository.

That’s a meaningful repositioning. Lerna in 2026 isn’t competing with Turborepo or Nx for build orchestration — it’s a companion tool many teams run on top of Nx (or even alongside Turborepo) specifically to handle the mechanics of bumping versions and publishing packages to npm in a coordinated way. Snyk’s package health assessment classifies Lerna’s maintenance status as “Healthy,” citing regular releases and commit activity well into 2026.

How Caching Actually Works Under the Hood

The marketing copy for both tools boils down to “we cache your builds,” but the mechanics differ enough to matter when you’re debugging a cache that refuses to invalidate. Turborepo computes a hash for each task based on the contents of the files it depends on, the task’s command, and any environment variables you’ve explicitly declared as cache-relevant. If that hash matches a previous run — whether stored locally on disk or fetched from Vercel’s remote cache — Turborepo skips execution entirely and replays the cached stdout/stderr plus restores any declared output files. According to Turborepo’s documentation, remote cache artifacts are content-addressed and signed with HMAC-SHA256 to guard against tampering when multiple developers or CI runners share a cache.

Nx follows a similar hashing principle but extends it further with what it calls the “affected graph.” Nx computes a hash based on a task’s inputs — source files, configuration, dependencies, environment, and command-line flags — then checks both local and Nx Cloud remote caches before running anything. Where Nx diverges is in how it decides what to run in the first place: it diffs your current branch against a base commit, maps every changed file back to the project(s) that own it via the project graph, then expands that set to include every project that depends on those changed projects. Only tasks touching that “affected” subgraph run at all — everything else is skipped by inference, not just cached. Turborepo added a comparable capability with its composable --affected and --filter flags in the 2.10 release, narrowing what used to be a meaningful Nx-only advantage.

The practical upshot: both tools will skip work that doesn’t need to happen, but Nx’s project graph model was purpose-built for that calculation from day one, while Turborepo bolted equivalent functionality on later. For teams with dozens of interdependent packages where “did this change actually affect that service” is a genuinely hard question, Nx’s graph-first design tends to produce fewer false positives — cases where a task re-runs even though nothing relevant changed.

Nx’s Plugin Ecosystem, and Why It Matters More Than It Sounds

One of the least-discussed but most consequential differences between these tools is what happens when a monorepo isn’t purely JavaScript and TypeScript. Nx ships official, GA-status plugins for Angular, React, Vite, Jest, ESLint, NestJS, and — as of the 2026 release cycle — .NET and Java, meaning a single Nx workspace can genuinely orchestrate a polyglot codebase where a Java microservice, a .NET API, and a React frontend all sit in the same repository with unified caching and affected-graph detection. Turborepo, by contrast, deliberately stays JS/TS-focused: it will happily run any shell command you point it at, including a Java build via Maven or Gradle, but it doesn’t understand the internal dependency structure of non-JS ecosystems the way Nx’s dedicated plugins do.

This is less a knock on Turborepo than a reflection of its design philosophy — it stays a lean task runner rather than trying to be a platform. But for organizations running mixed-language monorepos (increasingly common at companies that acquired teams with different tech stacks or that are consolidating microservices into one repo for easier cross-team refactoring), Nx’s plugin depth is the difference between “it technically works” and “it understands what changed and why.”

Benchmark Data: Who’s Actually Faster

This is where marketing claims and independent testing tend to diverge, so it’s worth walking through three separate benchmark sources rather than trusting any single vendor’s numbers.

The most-cited open source benchmark is the large-monorepo repository maintained by an Nx co-founder, which stress-tests build orchestration tools against a synthetic large-scale monorepo. Its published results show an average run time of 191.7 (arbitrary time units) for Nx versus 1,432.4 for Turborepo — a roughly 7.5x gap in Nx’s favor on that specific synthetic workload. Because the benchmark’s author co-founded Nx, treat the magnitude with some skepticism, but the directional finding (Nx pulling ahead at very large scale due to distributed execution) shows up in independently reported numbers too.

A second data point, reported via a daily.dev technical comparison, found that on a single CI runner Turborepo completed a build in 25 minutes 32 seconds versus Nx’s 21 minutes 56 seconds — about 16% faster for Nx, a far more modest gap than the synthetic benchmark suggests. The same source found that once distributed execution enters the picture (Nx Agents splitting work across machines), the gap widened dramatically: 9 minutes 20 seconds for Nx versus 19 minutes 18 seconds for Turborepo, more than 2x faster.

A third, more moderate comparison focused on smaller repositories found the two tools essentially tied. For a 30-project monorepo, both Turborepo and Nx cut CI time from roughly 45 minutes down to 12-15 minutes with similar cache-hit behavior. Another performance write-up measured a full clean build at 4 minutes 15 seconds for Turborepo versus 4 minutes 18 seconds for Nx — a 3-second difference that’s essentially noise. Full cache hits landed at 4 seconds for Turborepo and 3 seconds for Nx.

Benchmark Scenario	Turborepo	Nx	Source Type
Synthetic large monorepo (relative units)	1,432.4	191.7	Open-source benchmark repo (Nx-affiliated author)
Single-runner CI build	25m 32s	21m 56s	Independent technical blog
Distributed CI (Nx Agents vs single runner)	19m 18s	9m 20s	Independent technical blog
30-project repo, cold to cached CI	~12-15 min (from 45 min)	~12-15 min (from 45 min)	Community comparison article
Clean build (small repo)	4m 15s	4m 18s	Performance-focused write-up
Full cache hit	4s	3s	Performance-focused write-up

The pattern across all three sources is consistent even though the magnitude varies wildly: at small-to-medium scale, Turborepo and Nx perform within noise of each other. At large scale with distributed CI, Nx’s Agents feature creates a real, measurable advantage — because Turborepo has no native distributed execution model to compete with it. If your CI pipeline never grows past a single runner, the caching engine you pick barely matters. If it does, distribution becomes the deciding factor.

Pricing: What Remote Caching and Distribution Actually Cost

Pricing models differ enough between these tools that a like-for-like comparison requires some translation. Turborepo’s CLI is free and open source under the MPL-2.0 license, full stop — there’s no paid tier for the tool itself. Its remote caching runs through Vercel’s infrastructure and is free on every Vercel plan (Hobby, Pro, Enterprise), constrained only by fair-use bandwidth and request-rate limits. Self-hosting a remote cache server is also supported for teams that don’t want to route cache traffic through Vercel.

Nx Cloud uses a credits-based usage model as of 2026, a shift from its older per-CI-execution pricing. The free Hobby tier includes 50,000 credits per month and supports up to five active contributors with remote cache access included. Paid Team pricing adds $19 per active contributor per month, plus $5.50 per 10,000 credits consumed beyond the free allotment, plus $2.25 per concurrent CI connection per month. Enterprise pricing is custom, though an AWS Marketplace listing shows example bundles at $40,800 per year for 60 million credits (“Essentials”) and $70,200 per year for 120 million credits (“Ultimate”), according to Nx’s official pricing page.

Tier	Turborepo / Vercel	Nx Cloud
Free tier	Free CLI + free remote cache on all Vercel plans (fair-use limited)	50,000 credits/month, up to 5 contributors
Entry paid tier	Vercel Pro from $20/user/month (general hosting, not cache-specific)	$19/active contributor/month + $5.50 per 10,000 credits + $2.25/CI connection
Enterprise	Custom Vercel Enterprise (4TB/month cache uploads)	Custom; example AWS Marketplace bundle: $40,800/year for 60M credits
Self-hosted option	Yes, self-hosted remote cache server supported	Limited; Nx Cloud is the primary distribution path
Lerna cost	Free, MIT-licensed, no paid tier of its own

The practical read: a small team doing local development and occasional CI runs pays nothing either way. The bill starts mattering once you’re running dozens of CI pipelines a day across a large contributor base — at that point Nx Cloud’s credit consumption can add up quickly for large teams, while Turborepo’s cost stays tied to whatever Vercel hosting tier you’re already on for deployment, which many Next.js-centric teams pay for regardless.

Setting Up a Basic Pipeline: Config Comparison

Configuration philosophy is one of the starkest differences between Turborepo and Nx. Here’s a minimal build pipeline defined in each.

Turborepo’s turbo.json for a basic build-then-test pipeline:

{
  "$schema": "https://turborepo.com/schema.json",
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", ".next/**"]
    },
    "test": {
      "dependsOn": ["build"],
      "outputs": []
    },
    "lint": {
      "outputs": []
    }
  }
}

Nx’s equivalent typically lives across nx.json plus per-project configuration, but a comparable minimal setup with target defaults looks like this:

{
  "targetDefaults": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["{projectRoot}/dist"],
      "cache": true
    },
    "test": {
      "dependsOn": ["build"],
      "cache": true
    }
  },
  "namedInputs": {
    "default": ["{projectRoot}/**/*"]
  }
}

The two configs look almost identical on the surface. The difference shows up once you add plugins: Nx auto-detects framework-specific defaults (Angular, Vite, Jest, ESLint) through its plugin system rather than requiring hand-written pipeline entries for every tool, which is faster to set up on day one but adds a layer of implicit behavior teams occasionally need to debug through. Turborepo’s plain-script approach means what’s in package.json is what runs — nothing implicit, but also nothing auto-configured.

Real-World Examples: Who’s Actually Using Each Tool

Abstract feature comparisons only go so far. Here’s how five different organization types have actually deployed these tools, based on adoption data tracked in each project’s community discussions and customer story pages.

• Vercel (Turborepo): As the maintainer, Vercel runs Turborepo across its own internal monorepo, unsurprisingly optimized for the Next.js and Vercel deployment workflow it also sells.
• Netflix and Datadog (Turborepo): Both are cited in Turborepo’s GitHub adoption discussion as production users, representative of large consumer-facing teams that prioritize simple CI acceleration over a full platform rewrite.
• Broadcom (Nx): A 177-project enterprise monorepo that reported roughly 2x CI speed improvement after adopting Nx’s remote caching and distributed task execution, according to Nx’s published customer story.
• Caseware (Nx): Running more than 700 projects in a single Nx workspace, reporting 181 days of aggregate compute time saved per week through caching and distribution — the kind of scale where Nx Agents’ distributed execution model pays for itself.
• Fresha and Vue Storefront (Lerna): Both appear in tech-stack tracking data as active Lerna users, representative of teams using it primarily for coordinated npm package publishing rather than build orchestration.

The pattern across these examples tracks the earlier benchmark data closely: teams under roughly 100-150 projects tend to land on Turborepo for its simplicity, while organizations pushing past that threshold — especially ones running distributed CI across many machines — gravitate toward Nx specifically for the Agents feature. Lerna shows up orthogonally, as a publishing layer rather than a build-speed decision.

Worth noting: none of these are static decisions. Broadcom’s 177-project Nx workspace and Caseware’s 700-plus-project setup both started smaller and grew into their current tooling choice rather than adopting it from day one — a reminder that “start simple, migrate when the pain shows up” is a defensible strategy rather than a compromise. The migration guide below exists specifically because so many teams follow exactly that path: Turborepo or plain npm scripts first, then a deliberate move to Nx once CI queue times start showing up as a recurring complaint in retros.

The Cost of Picking the Wrong Tool

It’s worth being blunt about what actually goes wrong when a team picks the mismatched tool for its scale, because the failure modes aren’t dramatic — they’re slow and expensive in a way that’s easy to ignore until a quarterly infrastructure review surfaces it. Teams that adopt Nx at small scale (under 20-30 packages) commonly report spending disproportionate time on initial setup: learning the project graph model, configuring plugins that may auto-detect defaults incorrectly for a nonstandard setup, and debugging why a task didn’t get marked as cached when it seemingly should have been. None of that is unsolvable, but it’s real onboarding cost that a five-person startup rarely has spare engineering hours to absorb.

The inverse mistake — sticking with Turborepo well past the point where a monorepo has outgrown single-runner CI — shows up differently. CI queue times creep upward as the project count grows, and because Turborepo has no native distributed execution, the only lever available is throwing a bigger single runner at the problem, which has diminishing returns and rising cloud compute costs. Teams in this position often end up building bespoke CI sharding scripts to manually split tasks across parallel jobs — essentially re-implementing a worse version of what Nx Agents already does out of the box. That’s engineering time that could have gone into product work instead.

The Lerna mistake is different in kind: teams sometimes assume adopting Turborepo or Nx automatically replaces Lerna’s publishing workflow, then discover mid-migration that neither tool has an opinion on semantic version bumping or changelog generation across packages. That’s not a bug in either tool — it’s simply outside their scope — but it catches teams off guard when they’ve mentally filed all three tools under “monorepo tooling” without realizing they solve different layers of the problem.

Migration Guide: Moving Between These Tools

Migrating a monorepo’s tooling is never zero-risk, but the path between these three tools is more forgiving than a full framework rewrite because all three build on top of standard package manager workspaces (npm, Yarn, pnpm, or Bun). Here’s the general sequence teams follow.

Migrating from Lerna to Turborepo or Nx

1. Audit your existing Lerna configuration (lerna.json) for version-bumping and publishing rules — these need to be preserved separately, since neither Turborepo nor Nx replaces Lerna’s publishing workflow outright.
2. Confirm your package manager workspaces are correctly configured (npm/Yarn workspaces field, or pnpm-workspace.yaml) since both target tools rely on this rather than Lerna’s older bootstrap/link commands.
3. Install Turborepo or Nx as a dev dependency and generate the base config file (turbo.json or nx.json).
4. Map each existing npm script (build, test, lint) into task definitions, being explicit about which tasks depend on which.
5. Run a full build locally to validate the dependency graph resolves correctly before touching CI.
6. Keep Lerna installed alongside the new tool if you still need its versioning/publishing commands — this is the standard “Lerna + Nx” or “Lerna + Turborepo” hybrid setup many teams run in 2026.
7. Update CI configuration to call the new tool’s commands, and enable remote caching only after local runs are verified stable.

Migrating from Turborepo to Nx (or Vice Versa)

1. Both tools officially publish migration tooling; Nx ships an @nx/next-style migration generator that can import an existing Turborepo config, easing a large portion of manual translation.
2. Translate turbo.json task definitions into Nx targetDefaults, paying close attention to output paths since Nx expects {projectRoot}-relative syntax rather than raw glob paths.
3. Decide whether to adopt Nx plugins for your frameworks (recommended for teams using Angular, NestJS, or Vite-based setups) or keep task definitions manual for parity with the old Turborepo behavior.
4. Re-point remote caching from Vercel Remote Cache to Nx Cloud (or the reverse), including updating any CI secrets/tokens tied to the old caching provider.
5. Run both tools in parallel for one or two CI cycles if possible, comparing build/test output to confirm no tasks silently changed behavior.
6. Remove the old tool’s config files and CI steps only after the team has confirmed a full sprint of stable builds on the new tool.

The riskiest part of any of these migrations isn’t the tool swap itself — it’s cache invalidation logic. Teams that skip carefully re-validating which files should trigger cache misses tend to ship stale builds that pass CI because a task was incorrectly marked cacheable. Budget real QA time for this step regardless of which direction you’re migrating.

Pros and Cons: Turborepo

Pros: Minimal configuration overhead, free and open source with no paid tier for the CLI, remote caching is free on all Vercel plans, tight integration with Next.js and Vercel deployments, supports npm/Yarn/pnpm/Bun workspaces natively, fast to adopt for teams under roughly 100 projects.

Cons: No native distributed task execution — CI speed plateaus once you exceed what a single runner can parallelize, no built-in code generation or plugin ecosystem, less suited to polyglot monorepos mixing multiple languages or frameworks, remote cache tied most naturally to Vercel’s infrastructure (self-hosting is possible but adds ops overhead).

Pros and Cons: Nx

Pros: Distributed task execution via Nx Agents delivers measurable CI speed gains at large scale, extensive plugin ecosystem covering React, Angular, .NET, Java and more, code generators enforce consistent project structure, strong enterprise adoption with published case studies (Broadcom, Caseware), supports the same npm/Yarn/pnpm/Bun workspace models as Turborepo.

Cons: Steeper configuration learning curve, Nx Cloud’s credit-based pricing can become expensive for teams running high CI volume, benchmark advantage over Turborepo shrinks to near-parity at small-to-medium scale, plugin “magic” occasionally makes debugging build behavior less transparent than Turborepo’s explicit script model.

Pros and Cons: Lerna

Pros: Purpose-built for coordinated multi-package versioning and npm publishing, fully free and MIT-licensed with no paid tier, actively maintained under Nx stewardship with regular releases through 2026, integrates cleanly alongside either Turborepo or Nx for build orchestration.

Cons: No longer a standalone build/caching solution — v9 removed bootstrap/add/link commands in favor of native package manager workspaces, effectively requires pairing with Nx to get modern caching and affected-graph features, smaller relevance for teams that don’t publish packages to a public or private npm registry, the “is Lerna still needed” question comes up constantly since much of its historic value proposition has been absorbed by workspaces tooling.

5 Use Cases and Which Tool Fits

Specs and benchmarks matter less than matching the tool to your actual repo shape. Here’s how the decision typically shakes out across common team profiles.

• Small startup, single Next.js app plus a shared UI package: Turborepo. The setup overhead is minimal, remote caching is free through Vercel (which you’re likely already paying for hosting), and Nx’s plugin ecosystem is overkill for two or three packages.
• Mid-size SaaS company, 15-40 packages, single CI runner: Either works, but Turborepo’s simpler mental model usually wins here since the benchmark data shows near-parity at this scale. Pick based on whether you need Nx’s code generators for team consistency.
• Large enterprise, 150+ projects, distributed CI budget: Nx. This is exactly the scale where Nx Agents’ distributed execution creates a measurable, not marginal, speed advantage — the Broadcom and Caseware case studies both fall into this bracket.
• Open source maintainer publishing 10+ npm packages from one repo: Lerna, paired with either Turborepo or Nx for the actual build steps. Lerna’s version-bumping and changelog generation remain genuinely useful here even though its build-orchestration role has faded.
• Polyglot monorepo mixing Angular, .NET, and Java services: Nx. Its plugin ecosystem explicitly supports non-JavaScript stacks in ways Turborepo, which is JS/TS-focused, does not attempt to match.

The Verdict: Which One Should You Actually Pick

Based on the version history, pricing structures, and three independent benchmark sources reviewed here, the honest verdict is that Turborepo and Nx are both correct answers depending on repo size, and Lerna solves a different problem entirely from either of them.

If your monorepo runs under roughly 100-150 packages and CI fits on a single runner, Turborepo’s free CLI, free Vercel-backed remote caching, and minimal configuration make it the lower-friction choice — the benchmark data shows it’s within single-digit-percentage build times of Nx at this scale, so you’re not sacrificing meaningful speed for simplicity. If you’re already deployed on Vercel, the decision gets even easier since remote caching costs nothing extra.

If your monorepo has crossed into enterprise scale — 150+ projects, multiple teams, CI runs that benefit from splitting across parallel machines — Nx’s distributed task execution via Nx Agents is the feature that actually moves the needle, backed by the Broadcom and Caseware case studies showing real-world 2x CI improvements. Budget for Nx Cloud’s credit-based pricing scaling with team size, but weigh that against the engineering hours saved by CI runs that finish in 9 minutes instead of 19.

Lerna isn’t really competing for either of those decisions in 2026. If you’re publishing multiple npm packages from one repository and need coordinated version bumps and changelogs, run Lerna alongside whichever build tool you picked. It’s free, actively maintained, and does that one job well — it just isn’t the build-speed decision anymore.

Frequently Asked Questions

Is Lerna still maintained in 2026?

Yes. After its original maintainer stepped down in 2022, the Nx team took over stewardship. Lerna has shipped releases through 2026, reaching a v10.0.x line by late July, and Snyk’s package health assessment classifies its maintenance status as “Healthy” based on release and commit frequency.

Can I use Turborepo and Lerna together?

Yes, and many teams do exactly this: Turborepo handles build/test task orchestration and caching, while Lerna handles version bumping and npm publishing across packages. The two don’t conflict since they operate on different layers of the workflow.

Which is faster, Turborepo or Nx?

It depends heavily on repo size. At small-to-medium scale, independent benchmarks show the two are within a few percent of each other, sometimes with Turborepo edging ahead on tiny repos. At large scale with distributed CI, Nx pulls meaningfully ahead — one benchmark showed Nx finishing in 9 minutes 20 seconds versus Turborepo’s 19 minutes 18 seconds — specifically because of Nx Agents’ distributed execution, which Turborepo doesn’t natively offer.

Does Nx Cloud have a free tier?

Yes. Nx Cloud’s Hobby tier is free, includes 50,000 credits per month, supports up to five active contributors, and includes remote cache access. Paid Team pricing starts at $19 per active contributor per month plus metered credit and CI connection charges once you exceed the free allotment.

Is Turborepo’s remote caching really free?

Yes, on every Vercel plan, subject to fair-use limits. Hobby plans get 100GB of monthly cache uploads and 100 artifact requests per minute; Pro and Enterprise get progressively higher ceilings up to 4TB per month on Enterprise. Self-hosting a remote cache server outside Vercel is also supported for teams that want to avoid the fair-use constraints entirely.

Do Turborepo, Nx, and Lerna all support pnpm and Bun workspaces?

Yes, all three support npm, Yarn, pnpm, and Bun workspaces as of their 2026 releases. Lerna’s own documentation explicitly lists all four as supported package managers via its packageManager config option, and both Turborepo and Nx provide first-class setup commands for each.

Should a small team even bother with a monorepo tool?

If you’re running two or three tightly coupled packages, the overhead of adopting any of these tools may not pay off immediately, but Turborepo’s near-zero configuration cost means most teams find it worth adopting even at small scale simply to avoid re-running unchanged builds during local development, not just CI.

What happened to Lerna’s bootstrap and add commands?

Lerna v9 removed the bootstrap, add, and link commands that historically handled cross-package linking. Modern Lerna expects teams to rely on their package manager’s native workspaces feature (npm, Yarn, or pnpm workspaces, or Bun’s workspace support) for that functionality instead, reflecting how much the ecosystem around it has matured since Lerna’s original 2015-era design.

How do I know when my team has outgrown Turborepo?

The clearest signal is CI queue time that keeps climbing even after remote caching is fully enabled and cache-hit rates look healthy. If a single CI runner is consistently the bottleneck — meaning tasks that could theoretically run in parallel are instead queuing behind each other because there’s no distribution mechanism — that’s the point where Nx Agents’ distributed execution starts paying for itself. As a rough guideline based on the case studies here, teams crossing roughly 100-150 packages with multiple engineering teams committing daily are the ones most likely to feel this pain first.

Does switching build tools require rewriting my package.json scripts?

No. Both Turborepo and Nx are designed to wrap existing npm/Yarn/pnpm/Bun scripts rather than replace them. The migration work is almost entirely in the orchestration config (turbo.json or nx.json) that defines task dependencies and caching rules, not in rewriting the underlying build, test, or lint commands themselves.