The combination of Turborepo and pnpm is the preferred solution for modern JavaScript and TypeScript monolithic warehouses, because it provides fast installation, reliable dependency resolution, shared cache, parallel task execution and excellent tool support; first initialize the project and create pnpm-workspace.yaml to define the workspace structure, then install Turborepo as development dependencies, then configure turbo.json to define the build pipeline, then set up an independent package.json for each package and use pnpm's workspace protocol to reference the local package, and finally use pnpm to access pnpm's workspace protocol. The turbo command runs the build, test and development tasks. It is also recommended to enable pnpm's public-hoist-pattern to avoid the problem of the tool module being unable to find it, configure Turborepo remote cache to improve team collaboration efficiency, use pnpm's patch: protocol security management depends on patch, avoid mixing package managers, simplify scripts, use --filter filtering tasks reasonably, and exclude node_modules, dist, build and .turbo files in .gitignore, thereby achieving an efficient and extensible monolithic warehouse architecture.

Building monorepos with Turborepo and pnpm has become a go-to setup for modern JavaScript and TypeScript projects—especially when you're working across multiple packages or apps and want fast, efficient builds and dependency management. Here's how this combo works well together and how to set it up effectively.

Why Turborepo pnpm?

Turborepo is a high-performance build system optimized for JavaScript and TypeScript monorepos. It caches build results, parallelizes tasks, and leverages dependency graph analysis to avoid unnecessary work.

pnpm is a fast, disk-efficient package manager that uses hard links and symlinks to save space and speed up installs. It also enforces strict dependency resolution, which helps avoid "phantom dependencies"—a big win in monorepos.

Together, they offer:

• Fast installs (thanks to pnpm's efficient node_modules layout)
• Reliable dependency resolution
• Shared caching across packages
• Parallel task execution with intelligent invalidation (Turborepo)
• Excellent TypeScript and modern JS/TS tooling support

Setting Up a Monorepo with Turborepo and pnpm

1. Initialize the project

Start by creating a new directory and setting up pnpm with a pnpm-workspace.yaml file to define your monorepo structure:

 mkdir my-monorepo
cd my-monorepo
pnpm init

Create pnpm-workspace.yaml :

 packages:
  - 'apps/*'
  - 'packages/*'

This tells pnpm to include all packages under apps/ and packages/ as part of the workspace.

2. Install Turborepo

Install Turborepo as a dev dependency:

 pnpm add -D turbo

3. Configure turbo.json

Create a turbo.json at the root:

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

This defines common tasks ( build , test , lint , dev ) and their relationships. The dependsOn: ["^build"] means a package's build waits for its dependencies' builds.

4. Set up individual packages

Example structure:

 /apps/web
/apps/api
/packages/ui
/packages/utils

Each package has its own package.json . For example, /packages/ui/package.json :

 {
  "name": "@my-monorepo/ui",
  "version": "0.1.0",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
  "scripts": {
    "build": "tsc",
    "lint": "eslint src"
  },
  "dependencies": {
    "react": "^18.0.0"
  },
  "devDependencies": {
    "typescript": "^5.0.0"
  }
}

And /apps/web/package.json can depend on it:

 "dependencies": {
  "@my-monorepo/ui": "*",
  "next": "^13.0.0",
  "react": "^18.0.0"
}

Because it's a pnpm workspace, you can use * to reference local packages.

5. Run tasks with Turborepo

Now use turbo to run scripts across your monorepo:

 # Build all packages
pnpm turbo build

# Run tests in all packages
pnpm turbo test

# Start dev servers (eg, Next.js Express)
pnpm turbo dev

Turborepo will:

• Run tasks in topological order
• Cache results (local or remote)
• Skip work when inputs haven't changed

Optimize with pnpm and Turborepo Features

Use pnpm's public-hoist-pattern (if needed)

By default, pnpm hoists some packages to node_modules for tools like Jest or ESLint to find them. You can customize this in .npmrc :

 public-hoist-pattern[]=*eslint*
public-hoist-pattern[]=*jest*
public-hoist-pattern[]=*prettier*

This avoids "module not found" errors in tools that expect global-like access.

Enable Turborepo Remote Caching

For teams, set up Turborepo's remote cache :

 npx turbo login

Then:

 pnpm turbo build --remote-cache

Now CI and team members share cached builds—huge time savings.

Leverage pnpm's patch: protocol for forks

Need to patch a dependency? Use pnpm's patch: feature to apply and track local changes—safe and version-controlled.

Common Pitfalls & Tips

• Always use pnpm with Turborepo : Mixing package managers breaks symlinks and caching.

• Keep package.json scripts simple : Let Turborepo orchestrate; scripts should just call tools (eg, tsc , next dev ).

• Use --filter to run tasks on specific packages :

   pnpm turbo build --filter web

• Don't forget .gitignore :

   node_modules
  dist
  build
  .turbo

  ---

  Final Thoughts

  Turborepo and pnpm complement each other beautifully: pnpm handles dependencies efficiently and safely, while Turborepo orchestrates fast, cached task execution. This combo is lightweight, scalable, and ideal for teams building multiple apps and shared libraries.

  Set it up once, and you get fast local dev, optimized CI/CD, and a clean, maintainedable structure.

  Basically, if you're building a JS/TS monorepo today, this stack is one of the best choices out there.

  The above is the detailed content of Building Monorepos with Turborepo and pnpm. For more information, please follow other related articles on the PHP Chinese website!