What is a Monorepo?

Imagine you have one giant toybox instead of a bunch of little ones. A monorepo is just like that big toybox – it’s one repository that holds all the code for many projects. Developers love monorepos because they make sharing toys (code) super easy and updates a breeze. For example, you could put a shared UI library or utility functions in the monorepo and every app (say a Next.js website and a mobile app) can use the same code without copy-pasting. Fix a bug or upgrade a package once, and every project sees the update – instant win for everyone!

Share your toys: One repo means you can put reusable code (like components or utils) in a single spot so every project grabs the same pieces.
One fix, all win: Update code in one place, and all your apps instantly get the change. No more updating 10 separate repos.
Team play: Everyone on the team sees the whole code playground, so fewer “but it works on my machine!” surprises.

Under the hood, JavaScript monorepos use workspaces (in npm, Yarn, or pnpm) to manage these many packages. Workspaces tell the package manager which folders are part of the repo. For example, a pnpm-workspace.yaml might look like this:

packages:
  - "apps/*"
  - "packages/*"

This says “treat anything in apps/ or packages/ as a separate package.” It’s how our one-big-repo setup stays organized. (Yarn or npm users can do something similar in package.json with a workspaces field.)

Build Tools to the Rescue!

Okay, you’ve got one big toybox… but how do you clean up all those toys (build your code) without losing your mind? That’s where monorepo tools like Turborepo, Nx, and Lerna come in. They help you run tasks across your projects smartly.

But hold up — they’re not all the same! 🚨

Let’s break it down:

🚀 Turborepo – The Jetpack Janitor

Turborepo is a build system and task orchestrator. It doesn’t manage packages or versions. It just wants to do one thing: build/run your tasks FAST.

Parallelization: Run multiple scripts at once if they don’t depend on each other.
Caching: If you already built/tested something, Turbo remembers and skips it next time.
Zero config (mostly): Works with npm, pnpm, Yarn, etc.

Example root package.json:

{
  "private": true,
  "scripts": {
    "build": "turbo run build",
    "dev":   "turbo run dev",
    "lint":  "turbo run lint",
    "test":  "turbo run test"
  },
  "devDependencies": {
    "turbo": "latest"
  }
}

And turbo.json:

{
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", ".next/**", "!.next/cache/**"]
    },
    "test": {
      "dependsOn": ["build"],
      "outputs": ["coverage/**"]
    },
    "dev": {
      "cache": false,
      "persistent": true
    }
  }
}

🎒 Nx – The Swiss Army Kid

Nx is both a monorepo manager and a build orchestrator. It can do:

Task orchestration (like Turbo)
Package management (like Lerna)
Plugins, generators, dependency graphs, caching, CI optimizations
Works with many frameworks: React, Angular, Node, etc.

If you're building a big system and want extra tooling, Nx is your friend.

📦 Lerna – The Classic Toy Organizer

Lerna started as a package manager for JavaScript monorepos. It’s been around since 2015.

Handles versioning, publishing, and dependency linking
Doesn’t do task orchestration on its own (anymore it uses Nx under the hood)
Great for managing many internal libraries/packages

Think of Lerna as your project librarian — it catalogs everything, but doesn't run the tasks unless paired with something like Nx.

A Toy Example Monorepo

Here’s what a simple monorepo might look like:

my-monorepo/
  package.json
  pnpm-workspace.yaml
  turbo.json
  apps/
    web/
      package.json
    blog/
      package.json
  packages/
    ui-library/
      package.json
    utils/
      package.json

You define tasks in each package's package.json (like "build": "next build"), and Turbo or Nx runs them in the right order.

Summary Table

Feature	Turborepo	Lerna	Nx
Build orchestration	✅ Yes	❌ (uses Nx now)	✅ Yes
Package management	❌ Nope	✅ Yes	✅ Yes
Built-in generators	❌ Nope	❌ Nope	✅ Yes
Caching	✅ Yes	✅ Basic	✅ Advanced
Best for	Fast JS builds	Managing libs	Full-featured monorepos

TL;DR

Monorepo = one big repo for all your apps/libs.
Workspaces = organize packages (npm/Yarn/pnpm).
Turborepo = super-fast build system. Not a package manager.
Nx = full monorepo toolkit (build + manage + generate).
Lerna = package manager. Use it with Nx for builds.

Hope this made monorepos and build tools a little less scary. Now go forth and turbocharge your code! 🏎️💥

Monorepo Magic: Turbo, Nx & Lerna Make Your JS Code Fly!

Table of contents