# How Makeplane Plane Manages Its Monorepo with Turborepo and pnpm

> Discover how Makeplane Plane manages its monorepo using Turborepo and pnpm. Learn about their app and package structure for efficient development and caching.

- Repository: [Plane/plane](https://github.com/makeplane/plane)
- Tags: how-to-guide
- Published: 2026-06-25

---

**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/main/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`](https://github.com/makeplane/plane/blob/main/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/main/pnpm-workspace.yaml)](https://github.com/makeplane/plane/blob/preview/pnpm-workspace.yaml) file at the repository root declares the workspace boundaries:

```yaml
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/main/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/main/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:

```json
{
  "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`](https://github.com/makeplane/plane/blob/main/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:

```bash

# 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:

```bash
mkdir packages/my-lib

```

2. Define the package manifest at [`packages/my-lib/package.json`](https://github.com/makeplane/plane/blob/main/packages/my-lib/package.json):

```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`](https://github.com/makeplane/plane/blob/main/packages/my-lib/tsconfig.json):

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

```

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

```bash
pnpm install

```

5. Consume the new library in any application:

```bash
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/main/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/main/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/main/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/main/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/main/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`](https://github.com/makeplane/plane/blob/main/turbo.json), while pnpm manages workspace linking and dependency deduplication through [`pnpm-workspace.yaml`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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.