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

> Explore the 6 core applications in the makeplane/plane monorepo Web Admin API Live Space and Proxy. Discover their independent capabilities and configurations in this complete guide.

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

---

**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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/web/app/page.tsx). The application is configured via [`apps/web/package.json`](https://github.com/makeplane/plane/blob/main/apps/web/package.json) and [`apps/web/vite.config.ts`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/admin/app/root.tsx), with build configuration specified in [`apps/admin/package.json`](https://github.com/makeplane/plane/blob/main/apps/admin/package.json) and [`apps/admin/vite.config.ts`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/api/plane/wsgi.py). The [`apps/api/package.json`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/space/app/page.tsx), with configuration files at [`apps/space/package.json`](https://github.com/makeplane/plane/blob/main/apps/space/package.json) and [`apps/space/vite.config.ts`](https://github.com/makeplane/plane/blob/main/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:

```bash
pnpm install

```

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

```bash
pnpm --filter=@plane/web dev

```

This command executes the Vite development server defined in [`apps/web/vite.config.ts`](https://github.com/makeplane/plane/blob/main/apps/web/vite.config.ts).

To build a Docker image for the API service:

```bash
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:

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

```

To run linting and type-checking across all applications:

```bash
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`](https://github.com/makeplane/plane/blob/main/apps/web/app/page.tsx) (entry), [`apps/web/package.json`](https://github.com/makeplane/plane/blob/main/apps/web/package.json), [`apps/web/vite.config.ts`](https://github.com/makeplane/plane/blob/main/apps/web/vite.config.ts)
- **Admin**: [`apps/admin/app/root.tsx`](https://github.com/makeplane/plane/blob/main/apps/admin/app/root.tsx) (entry), [`apps/admin/package.json`](https://github.com/makeplane/plane/blob/main/apps/admin/package.json), [`apps/admin/vite.config.ts`](https://github.com/makeplane/plane/blob/main/apps/admin/vite.config.ts)
- **API**: [`apps/api/plane/wsgi.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/wsgi.py) (entry), [`apps/api/package.json`](https://github.com/makeplane/plane/blob/main/apps/api/package.json), `apps/api/Dockerfile`
- **Live**: `apps/live/app` (entry), [`apps/live/package.json`](https://github.com/makeplane/plane/blob/main/apps/live/package.json), `apps/live/Dockerfile.dev`
- **Space**: [`apps/space/app/page.tsx`](https://github.com/makeplane/plane/blob/main/apps/space/app/page.tsx) (entry), [`apps/space/package.json`](https://github.com/makeplane/plane/blob/main/apps/space/package.json), [`apps/space/vite.config.ts`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/package.json) files.