Nx vs Turborepo vs pnpm Workspaces: Choosing Your Monorepo Tool in 2026

Monorepos are no longer just for giant tech companies. In 2026, organizations of every size use monorepos to keep shared libraries, microservices, and frontend applications in a single version-controlled repository — eliminating dependency drift, enabling atomic cross-package changes, and simplifying CI/CD.

But the tooling landscape has fragmented. Three approaches dominate: Nx, Turborepo, and pnpm Workspaces. Each has a distinct philosophy, capability set, and learning curve.

This guide breaks down all three with practical examples, real benchmarks, and a decision framework.

---

Why Monorepos? A Quick Primer

Before comparing tools, understand what problem they solve.

In a traditional multi-repo setup, sharing code between projects means publishing npm packages, managing version pinning, and dealing with “did the consumers update to v2.1.0 yet?” across teams. This creates:

• Dependency drift — different apps use incompatible versions of internal packages
• Slow feedback loops — package publish → version bump → PR cycle just to test a change
• Inconsistent tooling — each repo has its own ESLint config, test setup, and CI pipeline

A monorepo puts all code in one repository. The challenge then becomes: how do you build and test only what changed, without running the entire tree every time?

This is where Nx, Turborepo, and pnpm Workspaces each have opinions.

---

pnpm Workspaces: The Foundation Layer

What pnpm Workspaces Provides

pnpm Workspaces is not a build orchestrator — it’s a package manager with workspace support. It manages node_modules linking between packages in a monorepo, using efficient symlink-based node_modules that save disk space.

# pnpm-workspace.yaml
packages:
  - 'apps/*'
  - 'packages/*'
  - 'tools/*'

With this configuration, you can run commands across packages:

# Install all dependencies across all workspaces
pnpm install

# Run build in a specific package
pnpm --filter @myorg/ui build

# Run tests in all packages that match a pattern
pnpm --filter './packages/*' test

# Run build in a package and all its dependents
pnpm --filter @myorg/ui... build

pnpm Filter Syntax

The --filter flag is pnpm’s task targeting system:

pnpm --filter @myorg/ui          # exact package
pnpm --filter ./packages/ui      # path
pnpm --filter '@myorg/*'         # glob
pnpm --filter '@myorg/ui...'     # package + all dependents
pnpm --filter '...@myorg/ui'     # package + all dependencies
pnpm --filter '[origin/main]'    # changed since origin/main

What pnpm Workspaces Does NOT Provide

pnpm Workspaces has no:

• Remote caching — every CI run rebuilds from scratch
• Task dependency graph — you specify run order manually
• Build cache — no fingerprinting of input/output files
• Code generators — no scaffolding tooling

It is purely a package linking layer. Teams often combine it with Turborepo or Nx for the orchestration layer on top.

When to Use pnpm Workspaces Alone

• Small monorepos (< 10 packages) where full rebuilds are fast
• Teams that want minimal tooling and prefer simple pnpm --filter scripts
• As the underlying package manager for Turborepo or Nx (both support pnpm workspaces)

---

Turborepo: Fast Build Pipelines with Minimal Configuration

The Turborepo Philosophy

Turborepo (acquired by Vercel in 2021, open-sourced, now under the React ecosystem umbrella) focuses on build pipeline orchestration with aggressive caching. The goal: make incremental builds as simple as adding a turbo.json file.

turbo.json: Defining Your Pipeline

{
  "$schema": "https://turbo.build/schema.json",
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": [".next/**", "!.next/cache/**", "dist/**"]
    },
    "test": {
      "dependsOn": ["build"],
      "outputs": [],
      "cache": true
    },
    "lint": {
      "outputs": []
    },
    "dev": {
      "cache": false,
      "persistent": true
    }
  }
}

The ^build notation means “run build in all dependencies first”. Turborepo computes the dependency graph from package.json and runs tasks in the correct order, in parallel where possible.

Local and Remote Caching

Turborepo’s killer feature is its cache. After a successful build, Turborepo hashes the task’s inputs (source files, env vars, dependencies). On subsequent runs, if nothing changed, it replays the cached output — including stdout, stderr, and output files.

# First run: actually builds
turbo build

# Second run: cache hit, replays output instantly
turbo build
# >>> FULL TURBO (cache hit)
# @myorg/ui:build  cache hit, replaying output

# Remote caching via Vercel
npx turbo login
npx turbo link  # links to your Vercel account

Remote caching stores the cache on Vercel’s infrastructure. When a CI run hits the same inputs as a previous run (on any machine), it skips the task entirely.

Self-hosted remote cache is possible via @ducktors/turborepo-remote-cache or custom S3/R2 backends:

{
  "remoteCache": {
    "enabled": true,
    "apiUrl": "https://your-cache-server.com"
  }
}

Turborepo Workspace Graph Visualization

turbo build --graph
# Opens a dependency graph visualization

Turborepo Performance Profile

In a typical JavaScript monorepo with 20–50 packages, Turborepo reduces CI time by 60–90% through caching after the first full build. Local development iteration (rebuild on change) is also dramatically faster.

Turborepo strengths:

• Minimal configuration to get started
• Excellent remote caching story (Vercel-hosted or self-hosted)
• Fast Rust-based task runner
• Great for teams that don’t want to learn a complex system
• Broad JavaScript/TypeScript ecosystem support

Turborepo weaknesses:

• No code generators (you scaffold manually or use other tools)
• Weaker built-in project graph analysis vs Nx
• Limited support for non-JavaScript projects
• Fewer official plugins and integrations

---

Nx: Full-Featured Monorepo Platform

The Nx Philosophy

Nx (by Nrwl) is not just a build orchestrator — it’s a monorepo platform with code generators, dependency graph analysis, constraint enforcement, and a plugin ecosystem. It has opinions about project structure and enforces them via configuration.

Nx is more powerful than Turborepo but requires more setup and learning.

Workspace Structure

Nx uses a nx.json for workspace configuration and maintains a project graph:

// nx.json
{
  "tasksRunnerOptions": {
    "default": {
      "runner": "nx/tasks-runners/default",
      "options": {
        "cacheableOperations": ["build", "test", "lint", "e2e"],
        "remoteCache": {
          "token": "...",
          "url": "https://api.nxcloud.app"
        }
      }
    }
  },
  "targetDefaults": {
    "build": {
      "dependsOn": ["^build"],
      "inputs": ["production", "^production"]
    }
  }
}

Running Tasks in Nx

# Build a single project
nx build my-app

# Build affected projects only (since last commit)
nx affected --target=build

# Run in parallel
nx run-many --target=test --all --parallel=4

# Show the dependency graph
nx graph

The nx affected command is particularly powerful: it uses the project graph to determine which projects are actually affected by your changes, running only what’s necessary.

Nx Generators: Code Scaffolding

Nx generators are one of its strongest differentiators. Official generators create applications, libraries, and components with correct project structure, wiring, and test setup:

# Generate a new Next.js app
nx generate @nx/next:application my-dashboard

# Generate a shared TypeScript library
nx generate @nx/js:library shared-utils --directory=libs/shared-utils

# Generate a React component
nx generate @nx/react:component Header --project=my-app

# Generate a custom Nx plugin
nx generate @nx/plugin:generator my-generator --project=my-plugin

Each generator scaffolds the code AND wires it into the workspace (adds to project.json, sets up dependencies, configures tests).

Module Boundary Rules (Enforced Architecture)

Nx’s most unique feature: enforced import constraints via ESLint:

// .eslintrc.json
{
  "rules": {
    "@nx/enforce-module-boundaries": [
      "error",
      {
        "allow": [],
        "depConstraints": [
          {
            "sourceTag": "type:app",
            "onlyDependOnLibsWithTags": ["type:feature", "type:ui", "type:util"]
          },
          {
            "sourceTag": "type:feature",
            "onlyDependOnLibsWithTags": ["type:ui", "type:util", "type:data-access"]
          },
          {
            "sourceTag": "scope:admin",
            "onlyDependOnLibsWithTags": ["scope:admin", "scope:shared"]
          }
        ]
      }
    ]
  }
}

When a developer tries to import a scope:checkout library from a scope:admin app, they get a lint error immediately. This prevents architectural violations from compiling silently into the codebase.

Nx Cloud Remote Caching

Nx Cloud provides managed remote caching and distributed task execution (DTE):

# Enable Nx Cloud
npx nx connect-to-nx-cloud

DTE distributes tasks across multiple CI agents, dramatically cutting wall-clock build time for large repos:

• Without DTE: 50 tasks × 2 min each = 100 min sequential
• With DTE (5 agents): ~20 min wall clock

Nx strengths:

• Best-in-class code generators
• Enforced module boundaries and architecture constraints
• Distributed task execution (Nx Cloud)
• Broad plugin ecosystem (React, Angular, Node, Go, Rust, Python)
• Excellent project graph visualization
• Built-in migration scripts (nx migrate)

Nx weaknesses:

• Steeper learning curve than Turborepo
• More opinionated about project structure
• Nx Cloud free tier has limits (paid for larger teams)
• Can feel heavy for small projects

---

Performance Comparison

Metric	pnpm Workspaces	Turborepo	Nx
First build time	Baseline	Baseline	Baseline
Cached rebuild	None	~0ms (cache hit)	~0ms (cache hit)
Remote cache	No	Yes (Vercel/self-host)	Yes (Nx Cloud)
Affected-only builds	Via --filter '[...]'	Via --filter	nx affected (graph-based)
Parallel execution	Manual	Auto (pipeline)	Auto (graph)
Setup complexity	Low	Low	Medium
Large repo (100+ pkgs)	Slow (no cache)	Fast	Fastest (DTE)

---

Real-World Use Cases

Startup with 3–5 packages

Recommendation: pnpm Workspaces + Turborepo

Simple turbo.json pipeline, Vercel remote cache, minimal configuration. Gets you 90% of the benefit with 10% of the complexity.

apps/
  web/          (Next.js)
  api/          (Express)
packages/
  ui/           (shared components)
  utils/        (shared utilities)
  types/        (shared TypeScript types)

Mid-size team with 10–30 packages

Recommendation: Turborepo or Nx

If you need code generators and architecture enforcement → Nx. If you want simplicity and good caching → Turborepo.

Enterprise monorepo with 50+ packages and multiple teams

Recommendation: Nx

Module boundary enforcement becomes essential at scale. Nx’s distributed task execution (Nx Cloud) cuts CI times from hours to minutes. The generator ecosystem ensures consistent project scaffolding across teams.

---

Decision Matrix

Use Case	Best Tool
Package manager only, minimal tooling	pnpm Workspaces
Fast builds + remote cache, simple config	Turborepo
Code generators + architecture enforcement	Nx
Large enterprise, 50+ packages	Nx
Vercel deployment pipeline	Turborepo (built-in Vercel integration)
Non-JS polyglot monorepo	Nx (Go, Rust, Python plugins)
Need distributed CI task execution	Nx Cloud

---

Getting Started

Turborepo (new project)

npx create-turbo@latest my-monorepo
cd my-monorepo
pnpm install
pnpm turbo build

Nx (new project)

npx create-nx-workspace@latest my-workspace
# Select preset: apps / integrated / standalone
cd my-workspace
nx build my-app

Add Turborepo to existing pnpm workspace

pnpm add turbo -D -w
# Add turbo.json to root
# Update package.json scripts to use turbo

Add Nx to existing workspace

npx nx@latest init
# Nx detects your existing tools and wraps them

---

Conclusion

All three tools solve real problems but at different levels of the stack:

• pnpm Workspaces is the foundation — great package linking and filtering, but no build orchestration. Combine it with Turborepo or Nx for full capability.
• Turborepo is the pragmatist’s choice — excellent caching, minimal learning curve, perfect for small to mid-size JavaScript monorepos.
• Nx is the platform choice — best generators, enforced architecture, distributed execution, and a rich plugin ecosystem. Overkill for small repos; essential for large teams.

Start with Turborepo if you want immediate value with low overhead. Graduate to Nx when architecture enforcement, code generators, or distributed CI become necessary.

---

Related tools on DevPlaybook: JSON Formatter · Regex Tester · Base64 Encoder