How Makeplane Plane Manages Its Monorepo with Turborepo and pnpm

Makeplane Plane organizes its codebase as a Turborepo-powered pnpm workspace, splitting deployable applications into apps/* and shared libraries into packages/* to enable incremental caching, unified dependency management, and parallel task execution across the entire repository.

The makeplane/plane repository follows a monorepo architecture designed to scale across multiple frontends, real-time services, and API layers. By combining Turborepo with pnpm workspaces, the project maintains a single source of truth for dependencies while allowing independent development and deployment of distinct services.

Monorepo Structure and Organization

The repository divides code into two primary categories, defined in [pnpm-workspace.yaml](https://github.com/makeplane/plane/blob/preview/pnpm-workspace.yaml), that separate deployable units from reusable infrastructure.

Apps Directory (Deployable Services)

The apps/* directory contains standalone applications that compile to production artifacts. These include:

• web: The primary Plane application interface
• admin: Administrative dashboard and management tools
• live: Real-time collaboration and WebSocket services
• space: Workspace and organization management frontend
• api: Backend service endpoints and server logic

Each application maintains its own package.json with runtime dependencies, entry-point scripts, and build configurations specific to its deployment target.

Packages Directory (Shared Libraries)

The packages/* directory houses code consumed by multiple applications, preventing duplication across the monorepo. Key shared modules include:

• ui: Reusable React component library
• utils: Common utility functions and helpers
• shared-state: Global state management logic and stores
• services: API clients and external service abstractions
• typescript-config: Centralized TypeScript compiler configurations
• tailwind-config: Shared Tailwind CSS theme and plugin settings

Because these reside in packages/*, pnpm automatically links them into the workspace graph, making them importable via the @plane/* namespace (for example, import { Button } from "@plane/ui").

Core Tooling and Configuration

Three root-level configuration files govern the monorepo's behavior, dependency resolution, and task execution.

pnpm Workspace Declaration

The [pnpm-workspace.yaml](https://github.com/makeplane/plane/blob/preview/pnpm-workspace.yaml) file at the repository root declares the workspace boundaries:

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

This configuration enables a single lockfile at the root, deduplicates node_modules across all projects, and allows atomic installation of every dependency with one command.

Turborepo Pipeline and Caching

Turborepo coordinates complex task graphs through [turbo.json](https://github.com/makeplane/plane/blob/preview/turbo.json). The configuration defines the build pipeline, task dependencies, and caching strategies for commands like build, dev, test, and check.

The engine respects topological ordering via dependsOn rules. For instance, dependsOn: ["^build"] ensures that shared packages compile before applications that depend on them, preventing race conditions and ensuring type safety across workspace boundaries.

Turborepo also maintains a content-addressable cache. When you modify code in one package, only that package and its dependents rebuild; unchanged packages restore instantly from cache, eliminating redundant compilation.

Root Package Management

The root [package.json](https://github.com/makeplane/plane/blob/preview/package.json) serves as the command orchestration center. It contains shared development dependencies like turbo, oxfmt, and oxlint, plus npm scripts that delegate to Turborepo:

{
  "scripts": {
    "dev": "turbo run dev --concurrency=18",
    "build": "turbo run build",
    "test": "turbo run test"
  }
}

Running pnpm dev from the repository root triggers parallel development servers across all applications with hot-reload enabled, managed by Turboreco's task scheduler.

Shared Configuration Strategy

To enforce consistency across dozens of modules, Plane centralizes tool configurations in dedicated packages within packages/*.

The packages/typescript-config directory exports base tsconfig.json files that other packages extend via the extends property. Similarly, packages/tailwind-config provides a single Tailwind CSS configuration imported by all frontend applications. This pattern ensures that compiler strictness, path aliases, and design tokens remain synchronized without duplication.

Development Workflow

Working in the Plane monorepo follows a standardized workflow optimized for high-performance parallel execution.

Running the Entire Repository

Bootstrapping the ecosystem requires two commands:

# Install dependencies once at the root

pnpm install

# Start all applications and file watchers

pnpm dev

The pnpm dev command executes turbo run dev --concurrency=18, which:

1. Analyzes the Git state to detect changed packages
2. Builds dependency packages first according to dependsOn: ["^build"] rules
3. Caches intermediate TypeScript outputs in .turbo/cache
4. Spins up development servers in the correct topological order

Adding a New Shared Library

To introduce a new shared package into the workspace:

1. Create the directory structure:

mkdir packages/my-lib

2. Define the package manifest at packages/my-lib/package.json:

{
  "name": "@plane/my-lib",
  "version": "0.1.0",
  "main": "dist/index.js",
  "scripts": {
    "build": "tsc -p .",
    "test": "vitest"
  },
  "devDependencies": {
    "typescript": "*"
  }
}

3. Extend the workspace TypeScript configuration in packages/my-lib/tsconfig.json:

{
  "extends": "../../packages/typescript-config/tsconfig.base.json",
  "include": ["src"]
}

4. Install to link the package into the workspace graph:

pnpm install

5. Consume the new library in any application:

cd apps/web
pnpm add @plane/my-lib

Because the package lives under packages/*, pnpm automatically includes it in the workspace graph, and Turborepo will trigger its build step whenever dependent apps compile.

Key Files in the Monorepo

Understanding these files accelerates onboarding and debugging:

• [pnpm-workspace.yaml](https://github.com/makeplane/plane/blob/preview/pnpm-workspace.yaml): Defines workspace boundaries and package locations
• [turbo.json](https://github.com/makeplane/plane/blob/preview/turbo.json): Configures task pipelines, caching rules, and dependency constraints
• [package.json](https://github.com/makeplane/plane/blob/preview/package.json) (root): Houses orchestration scripts and shared dev tools
• apps/*/package.json: Application-specific entry points and runtime dependencies
• packages/*/package.json: Library manifests exposing shared modules via the @plane scope
• packages/typescript-config/: Centralized compiler options for type safety consistency
• packages/tailwind-config/: Shared styling configuration for UI consistency

Summary

• Makeplane Plane uses a Turborepo-powered pnpm workspace to manage its monorepo architecture across multiple deployable services
• The repository splits into apps/* (web, admin, live, space, api) and packages/* (ui, utils, shared-state, services)
• [pnpm-workspace.yaml](https://github.com/makeplane/plane/blob/preview/pnpm-workspace.yaml) enables unified dependency management with a single root lockfile
• [turbo.json](https://github.com/makeplane/plane/blob/preview/turbo.json) orchestrates incremental builds and parallel task execution using dependsOn rules and content-addressable caching
• Shared configurations for TypeScript and Tailwind reside in packages/* to ensure consistency without duplication
• New packages require only directory creation and pnpm install to automatically join the workspace graph and build pipeline

Frequently Asked Questions

What monorepo tool does Plane use?

Plane uses Turborepo combined with pnpm workspaces. According to the makeplane/plane source code, Turborepo handles task orchestration and intelligent caching via turbo.json, while pnpm manages workspace linking and dependency deduplication through pnpm-workspace.yaml.

How does Plane handle shared TypeScript configuration?

Shared TypeScript settings live in packages/typescript-config/. Individual packages extend these base configurations using "extends": "../../packages/typescript-config/tsconfig.base.json" in their local tsconfig.json files. This ensures compiler options, strictness levels, and path aliases remain consistent across the entire monorepo.

Can I add a new application to the Plane monorepo?

Yes. Create a new directory under apps/* with a package.json containing the necessary scripts and dependencies. After running pnpm install, pnpm automatically includes the new application in the workspace. Turborepo will then include it in task execution pipelines defined in turbo.json, respecting dependency order during builds.

How does Turborepo improve build performance in Plane?

Turborepo analyzes the dependency graph and executes tasks in parallel where topological constraints allow. It caches build outputs by content hash in .turbo/cache, restoring them instantly when no source changes are detected. This prevents redundant compilation of unchanged packages like packages/ui when only apps/web source code changes, significantly reducing build times in large monorepos.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}