I’ve been thinking about monorepos a lot lately. Not the abstract idea, but the real, daily grind of them. You know the feeling: you change one line in a shared utility, and suddenly you’re staring at a terminal, waiting for what feels like an eternity as every single app and package rebuilds. It’s frustrating. It kills momentum. For a long time, I accepted this as the tax you pay for the organizational clarity a monorepo provides. But what if you didn’t have to pay that tax? What if you could have the structure and the speed?

This question led me down a path, and I found a combination that changed my workflow: Turborepo and pnpm workspaces. It’s not just about using two tools together; it’s about how they complement each other to solve the fundamental problems of scale. Let me show you what I mean.

First, let’s talk about pnpm on its own. Its workspace feature is fantastic for structuring your code. You define your packages in a pnpm-workspace.yaml file, and pnpm handles linking them together. But the real magic is in how pnpm installs dependencies. Unlike other package managers, pnpm uses a single, global store and creates hard links. This means if ten packages in your monorepo use the same version of React, it’s stored on disk exactly once. The savings in disk space and installation time are immediate and substantial.

Here’s a basic workspace setup:

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

Now, enter Turborepo. While pnpm organizes and installs, Turborepo orchestrates and accelerates. It understands the dependency graph of your tasks. If you run build, it doesn’t just run the build script in every package. It figures out which packages depend on others, builds them in the correct order, and—critically—caches the results. Change a component in packages/ui? Turborepo will rebuild apps/web and apps/docs that use it, but it won’t touch apps/admin if it doesn’t import that component. It skips what it can.

The integration is seamless. You start by adding Turborepo to your pnpm workspace.

pnpm add -Dw turbo

Then, you create a turbo.json at the root. This is your command center. You define your pipelines—the relationships between tasks like build, test, and lint. You tell Turborepo what depends on what. The dependsOn key is where the intelligence lives.

{
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": [".next/**", "!.next/cache/**"]
    },
    "test": {
      "dependsOn": ["build"],
      "outputs": []
    },
    "lint": {
      "outputs": []
    }
  }
}

See that "^build"? That’s Turborepo syntax meaning “the build tasks of all my dependencies must complete first.” This declarative graph is what prevents chaos. Your apps/web build task automatically waits for packages/ui and packages/utils to finish building first. No more manual scripting of build orders.

But here’s a question: what happens when your teammate runs the same build on their machine, or in CI? Do they have to wait too? This is where Turborepo’s caching becomes a superpower. When a task runs, Turborepo takes a fingerprint of its inputs (files, environment variables, etc.) and saves the outputs to a local cache. Next time you run that task with the same fingerprint, it just replays the outputs from the cache. It’s instant.

You can take this further with Remote Caching. Connect to Vercel’s free remote cache (or host your own), and now your entire team and your CI server share a single cache. A branch build only runs tasks for code that has actually changed since the last successful main branch build. The time savings in CI are often measured in minutes, not seconds.

Let’s look at a practical script in your root package.json:

{
  "scripts": {
    "build": "turbo run build",
    "dev": "turbo run dev --parallel",
    "lint": "turbo run lint",
    "test": "turbo run test"
  }
}

Running pnpm run build now triggers an optimized, graph-aware, cached build across your entire monorepo. The --parallel flag on dev is a game-changer for development; it starts the dev servers for all your apps and their dependent packages simultaneously. You get a live, integrated development environment.

So, what does this feel like in practice? Imagine you’re fixing a bug in a shared hook inside packages/hooks. You make the change and save. In a naive monorepo setup, you might trigger a full re-lint, re-test, and re-build chain everywhere. With Turborepo + pnpm, only the packages that actually import that hook will be affected. Their lint and test tasks might run, but their build output could be pulled straight from the cache if nothing else changed. The feedback loop is tight, focused, and fast.

This combination has reshaped how I think about monorepo maintenance. pnpm handles the “supply chain” with ruthless efficiency, minimizing disk usage and installation times. Turborepo handles the “production line,” ensuring work flows through the dependency graph in the right order, avoiding redundant work at every step. Together, they turn a monorepo from a necessary burden into a genuine accelerator.

The setup is straightforward, but the impact is profound. You stop worrying about build times and start focusing on code. The tools handle the complexity, letting you and your team maintain the clean architecture of a monorepo without sacrificing the iterative speed of a small project.

Have you ever calculated how much time your team spends waiting for builds or CI? What could you build with that time back?

If this approach to taming monorepo complexity resonates with you, I’d love to hear about your experiences. Did this help? Do you have a different strategy? Share your thoughts in the comments below—let’s learn from each other. And if you know someone struggling with slow monorepo builds, pass this along. They’ll thank you for it.

---

As a best-selling author, I invite you to explore my books on Amazon. Don’t forget to follow me on Medium and show your support. Thank you! Your support means the world!

---

101 Books

101 Books is an AI-driven publishing company co-founded by author Aarav Joshi. By leveraging advanced AI technology, we keep our publishing costs incredibly low—some books are priced as low as $4—making quality knowledge accessible to everyone.

Check out our book Golang Clean Code available on Amazon.

Stay tuned for updates and exciting news. When shopping for books, search for Aarav Joshi to find more of our titles. Use the provided link to enjoy special discounts!

---

📘 Checkout my latest ebook for free on my channel!
Be sure to like, share, comment, and subscribe to the channel!

---

Our Creations

Be sure to check out our creations:

Investor Central | Investor Central Spanish | Investor Central German | Smart Living | Epochs & Echoes | Puzzling Mysteries | Hindutva | Elite Dev | JS Schools

---

We are on Medium

Tech Koala Insights | Epochs & Echoes World | Investor Central Medium | Puzzling Mysteries Medium | Science & Epochs Medium | Modern Hindutva