# Build Scripts Available for makeplane/plane: Complete Guide to TurboRepo Workflows

> Explore makeplane/plane's TurboRepo build scripts. Learn how to run root-level commands and app-specific scripts for efficient monorepo builds.

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

---

**The makeplane/plane monorepo uses TurboRepo to orchestrate build scripts across multiple applications and libraries, with root-level commands like `pnpm run build` delegating to app-specific scripts such as `react-router build` for frontends and `tsdown` for the Live collaboration server.**

Plane is an open-source project management platform structured as a monorepo managed by TurboRepo. The build scripts available for makeplane/plane are distributed across the root [`package.json`](https://github.com/makeplane/plane/blob/main/package.json) and individual application directories, enabling both full-workspace compilation and targeted package builds.

## Root Workspace Build Scripts

The top-level [`package.json`](https://github.com/makeplane/plane/blob/main/package.json) serves as the central orchestration point for the entire monorepo. Located at the repository root, it defines TurboRepo-powered commands that execute across all packages and applications in dependency order.

The primary build scripts include:

- **`build`** – Executes `turbo run build` to compile all packages and applications according to the dependency graph defined in the workspace configuration.
- **`dev`** – Runs `turbo run dev --concurrency=18` to start development servers for every app simultaneously with optimized parallelization.
- **`start`** – Launches production builds via `turbo run start`, typically invoked after the build script completes.
- **`clean`** – Removes Turbo cache, `node_modules`, `dist` folders, and other generated artifacts across the entire repository.

Additional quality assurance scripts operate at the workspace level:

- **`fix`**, **`fix:format`**, **`fix:lint`** – Auto-correct formatting and linting issues repository-wide using Turborepo.
- **`check`**, **`check:lint`**, **`check:format`**, **`check:types`** – Validate code quality without modifying files, including TypeScript type-checking across the workspace.
- **`prepare`** – Installs Husky Git hooks for pre-commit validation.
- **`doctor`** – Runs `react-doctor` to diagnose common React-specific issues.

## Application-Specific Build Scripts

Each application in the `apps/` directory maintains its own [`package.json`](https://github.com/makeplane/plane/blob/main/package.json) with specialized build pipelines tailored to its runtime requirements.

### Web UI (apps/web)

The main frontend application uses React Router's Vite-based build system. In [`apps/web/package.json`](https://github.com/makeplane/plane/blob/main/apps/web/package.json), the scripts handle bundling and serving:

```bash

# Production build

pnpm run build        # Executes: react-router build

# Development server

pnpm run dev          # Executes: react-router dev --port 3000

# Preview built assets

pnpm run preview      # Builds then serves static files on port 3000

# Start production server

pnpm run start        # Serves build/client directory on port 3000

```

### Admin UI (apps/admin)

The administrative interface follows an identical pattern to the Web UI but operates on port 3001. The [`apps/admin/package.json`](https://github.com/makeplane/plane/blob/main/apps/admin/package.json) defines:

```bash
pnpm run build        # react-router build

pnpm run dev          # react-router dev (port 3001)

pnpm run start        # serve production build

```

### Live Collaboration Server (apps/live)

The real-time collaboration backend uses a TypeScript compilation and bundling workflow distinct from the frontend applications. In [`apps/live/package.json`](https://github.com/makeplane/plane/blob/main/apps/live/package.json):

```bash

# Type-check and bundle

pnpm run build        # Executes: tsc --noEmit && tsdown

# Development with hot reload

pnpm run dev          # tsdown --watch --no-clean --onSuccess "node --env-file=.env ."

# Start production server

pnpm run start        # node --env-file=.env .

```

The `tsdown` tool (an esbuild wrapper) produces the production bundle, while the `--env-file=.env` flag automatically loads environment variables when starting the server.

### Space UI (apps/space)

The Space application provides another frontend entry point using React Router on port 3002. The [`apps/space/package.json`](https://github.com/makeplane/plane/blob/main/apps/space/package.json) contains:

```bash
pnpm run build        # react-router build

pnpm run dev          # Development server on port 3002

pnpm run start        # Production server

```

## Library Build Scripts

Shared packages in the `packages/` directory expose build scripts for compiling reusable components and utilities.

### UI Component Library (packages/ui)

The shared React component library uses `tsdown` for bundling and includes Storybook generation. In [`packages/ui/package.json`](https://github.com/makeplane/plane/blob/main/packages/ui/package.json):

```bash

# Build component library

pnpm run build        # tsdown

# Development Storybook server

pnpm run storybook    # storybook dev -p 6006

# Static Storybook generation

pnpm run build-storybook   # storybook build

```

Output artifacts are written to the `dist/` directory for consumption by applications.

### Utilities Library (packages/utils)

Shared helper functions compile to a lightweight ESM bundle. The [`packages/utils/package.json`](https://github.com/makeplane/plane/blob/main/packages/utils/package.json) defines:

```bash
pnpm run build        # tsdown

```

The build outputs to `dist/` and serves as a dependency for multiple frontend applications.

## How Build Scripts Work Together

TurboRepo coordinates execution across the monorepo using the dependency graph defined in each package's [`package.json`](https://github.com/makeplane/plane/blob/main/package.json). When you invoke `pnpm run build` from the root:

1. **Dependency analysis** – Turbo analyzes the dependency tree to determine build order.
2. **Library compilation** – Shared packages (`@plane/ui`, `@plane/utils`) execute first via `tsdown` in [`packages/ui/package.json`](https://github.com/makeplane/plane/blob/main/packages/ui/package.json) and [`packages/utils/package.json`](https://github.com/makeplane/plane/blob/main/packages/utils/package.json).
3. **Application bundling** – Frontend apps (`web`, `admin`, `space`) invoke `react-router build` to create `build/` directories, while the `live` server compiles TypeScript to a single bundled output.
4. **Caching** – Results are cached for subsequent incremental builds.

This architecture ensures that changes to shared libraries automatically trigger rebuilds of dependent applications while maintaining efficient caching.

## Common Build Commands and Examples

Execute these commands from the repository root to interact with the build system:

```bash

# Build entire monorepo (all apps and libraries)

pnpm run build

# Build specific package only

pnpm --filter=@plane/ui run build
pnpm --filter=web run build

# Run development server for single application

pnpm --filter=web run dev        # http://localhost:3000

pnpm --filter=admin run dev      # http://localhost:3001

pnpm --filter=live run dev       # Watch mode with auto-restart

# Generate static Storybook site

pnpm --filter=@plane/ui run build-storybook

```

All commands use `pnpm` as the package manager, consistent with the repository's lockfile configuration.

## Summary

- **Root-level scripts** in [`package.json`](https://github.com/makeplane/plane/blob/main/package.json) orchestrate the entire monorepo via TurboRepo, with `build`, `dev`, and `start` as the primary entry points.
- **Frontend applications** (`web`, `admin`, `space`) use `react-router build` for Vite-based bundling on ports 3000-3002.
- **Live collaboration server** employs `tsdown` (esbuild-based) for TypeScript compilation with distinct `build`, `dev`, and `start` workflows in [`apps/live/package.json`](https://github.com/makeplane/plane/blob/main/apps/live/package.json).
- **Shared libraries** (`@plane/ui`, `@plane/utils`) compile via `tsdown` to `dist/` directories, with the UI package additionally supporting Storybook generation.
- **TurboRepo caching** optimizes builds by executing tasks in dependency order and reusing cached outputs when source files remain unchanged.

## Frequently Asked Questions

### What command builds the entire makeplane/plane repository?

Run `pnpm run build` from the repository root. This executes `turbo run build`, which coordinates the build process across all applications and libraries in the correct dependency order, ensuring shared packages compile before dependent applications.

### How do I build only the Live collaboration server without building the frontend apps?

Use the filter flag: `pnpm --filter=live run build`. This executes only the `build` script defined in [`apps/live/package.json`](https://github.com/makeplane/plane/blob/main/apps/live/package.json), which runs `tsc --noEmit && tsdown` to type-check and bundle the server code without touching other workspace packages.

### What is the difference between the `build` and `start` scripts in makeplane/plane?

The `build` script compiles source code into production assets—`react-router build` creates static files for frontends, while `tsdown` generates JavaScript bundles for libraries. The `start` script serves these built assets, typically using `serve` for static files or `node` for the Live server, and is usually run after `build` completes successfully.

### Which port does each application use during development?

The Web UI runs on port 3000, the Admin UI on port 3001, and the Space UI on port 3002. The Live collaboration server port is configurable via environment variables, while Storybook for the UI library runs on port 6006.