Applications in the makeplane/plane Monorepo: Complete Guide to the 6 Core Apps

TLDR: The makeplane/plane repository is a TurboRepo-managed monorepo containing six standalone applications—Web, Admin, API, Live, Space, and Proxy—each located under the top-level apps/ directory with independent build configurations and deployment capabilities.

The makeplane/plane project organizes its codebase as a monorepo, housing multiple front-end and back-end applications that together form the complete Plane project management platform. Each application resides in the apps/ directory as a standalone package with its own package.json, build tooling, and Docker configuration, while sharing common utilities from the packages/ workspace. This architecture enables independent development and deployment of services while maintaining code consistency across the platform.

Overview of the Monorepo Architecture

The repository follows a standard monorepo pattern where the apps/ directory contains deployable units, and the packages/ directory houses shared internal libraries. According to the source code, all applications are orchestrated by TurboRepo, allowing developers to run commands across the entire workspace or target specific applications using the pnpm --filter=@plane/<app> syntax.

The Six Core Applications

Web (Public Product UI)

The Web application serves as the primary user-facing interface that end-users interact with when using Plane. Built as a React application using Vite, its main entry point is located at apps/web/app/page.tsx. The application is configured via apps/web/package.json and apps/web/vite.config.ts, defining the build pipeline and development server settings.

Admin (Internal Administration Console)

The Admin application provides an internal management interface for workspace administrators to manage users, settings, and organizational configurations. Its root component resides at apps/admin/app/root.tsx, with build configuration specified in apps/admin/package.json and apps/admin/vite.config.ts.

API (Django REST Backend)

The API application contains the Django-based REST API that powers all front-end clients. Unlike the Node.js-based frontends, this application uses Python/Django with its entry point at apps/api/plane/wsgi.py. The apps/api/package.json serves as a Node wrapper for linting and Docker orchestration, while apps/api/Dockerfile defines the production container image for the Django service.

Live (Real-Time Collaboration Server)

The Live application handles real-time collaboration features including WebSocket connections and live editing capabilities. This Node.js/TypeScript service is located under apps/live/ and can be started independently using the @plane/live package filter. It includes its own development container configuration in apps/live/Dockerfile.dev.

Space (Secondary User Interface)

The Space application represents a secondary front-end interface for a different product surface within the Plane ecosystem. Similar to the Web app, it uses Vite for building and has its entry point at apps/space/app/page.tsx, with configuration files at apps/space/package.json and apps/space/vite.config.ts.

Proxy (Reverse Proxy Infrastructure)

The Proxy application provides infrastructure-level routing using Nginx/Caddy. Rather than application code, this directory contains configuration files such as apps/proxy/Caddyfile.ce and apps/proxy/Dockerfile.ce, which define the reverse proxy rules used in the Docker Compose stack for local development.

Development Workflow and Commands

Working with individual applications in the makeplane/plane monorepo leverages TurboRepo's filtering capabilities. Here are the essential commands for common development tasks.

To install dependencies for the entire workspace:

pnpm install

To run a single application in development mode (targeting the Web UI):

pnpm --filter=@plane/web dev

This command executes the Vite development server defined in apps/web/vite.config.ts.

To build a Docker image for the API service:

docker build -t plane-api -f apps/api/Dockerfile .

The Dockerfile pulls the Django project from apps/api/plane/ and installs Python requirements.

To execute a Node.js task from the Live application:

pnpm --filter=@plane/live exec node ./apps/live/src/tasks/someTask.js

To run linting and type-checking across all applications:

pnpm check
pnpm check:lint
pnpm check:types

Key Configuration Files and Entry Points

Each application maintains distinct configuration files that govern its behavior:

• Web: apps/web/app/page.tsx (entry), apps/web/package.json, apps/web/vite.config.ts
• Admin: apps/admin/app/root.tsx (entry), apps/admin/package.json, apps/admin/vite.config.ts
• API: apps/api/plane/wsgi.py (entry), apps/api/package.json, apps/api/Dockerfile
• Live: apps/live/app (entry), apps/live/package.json, apps/live/Dockerfile.dev
• Space: apps/space/app/page.tsx (entry), apps/space/package.json, apps/space/vite.config.ts
• Proxy: apps/proxy/Caddyfile.ce, apps/proxy/Dockerfile.ce

Summary

• The makeplane/plane monorepo contains six distinct applications under the apps/ directory: Web, Admin, API, Live, Space, and Proxy.
• Each application operates as a standalone package with its own package.json, build configuration, and deployment artifacts.
• The Web, Admin, and Space applications are Vite-based React frontends targeting different user personas.
• The API application provides the Django REST backend, while Live handles WebSocket-based real-time collaboration.
• TurboRepo orchestrates the entire workspace, enabling targeted builds and development via pnpm --filter=@plane/<app> syntax.
• The Proxy application provides reverse proxy configuration for local development stacks.

Frequently Asked Questions

What is the difference between the Web and Space applications in the makeplane/plane monorepo?

The Web application serves as the primary product interface that end-users interact with for project management, while the Space application represents a secondary UI surface for a different product context. Both are React applications built with Vite and located under apps/web/ and apps/space/ respectively, but they target different user workflows and deploy as separate services.

How do I run only the API backend without starting the frontend applications?

Use the Docker build approach specific to the API application: run docker build -t plane-api -f apps/api/Dockerfile . from the repository root. This Dockerfile located at apps/api/Dockerfile containerizes the Django service independently, allowing you to run the backend without installing Node.js dependencies or starting the Vite development servers.

Which application handles real-time collaboration features in Plane?

The Live application manages real-time collaboration, including WebSocket connections and live editing capabilities. Located under apps/live/, this Node.js/TypeScript service runs independently from the main Web UI and can be started using pnpm --filter=@plane/live dev during development or built using apps/live/Dockerfile.dev for containerized deployment.

Where are the shared components and utilities located if each application is standalone?

While each application in apps/ is standalone, they import shared code from the packages/ directory at the repository root. This workspace-based architecture allows Web, Admin, and Space to share UI components and utilities without duplicating code, while maintaining independent build and deployment pipelines as defined in their respective package.json files.

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