What Is the Purpose of the apps/ Directory in the Plane Monorepo?

The apps/ directory serves as the operational core of Plane's multi-application architecture, housing independent yet tightly-coupled runnable projects—including the web UI, admin console, Django backend, and support services—that collectively deliver the full product stack.

The apps/ folder organizes the makeplane/plane repository into discrete, deployable units. According to the source code, each subdirectory functions as a standalone package with its own build configuration, while shared tooling like Turbo and pnpm workspaces unifies development across the monorepo.

Core Applications Inside apps/

web – The Primary User Interface

Located at apps/web/, this directory contains the main end-user interface that serves as the browser-based entry point for Plane. The apps/web/package.json defines the development scripts and dependency tree, including the pnpm dev command that launches the application locally. Routing logic is configured separately in apps/web/react-router.config.ts, which manages client-side navigation for the React-based frontend.

admin – Instance Management Console

The apps/admin/ directory hosts the administrative console used for workspace and instance-wide configuration. Like the main web application, apps/admin/package.json specifies independent scripts and dependencies, while apps/admin/react-router.config.ts handles the routing layer for administrative workflows. This separation allows the admin interface to evolve independently from the core user experience.

api – Django Backend Service

Unlike the frontend applications, apps/api/ contains the Django-based backend service that powers data persistence, authentication, and business logic. The directory includes apps/api/Dockerfile, which containerizes the Python environment for consistent deployment. Developers can launch this service independently using Docker Compose commands without bootstrapping the Node.js frontend toolchain.

space – Embedded Lightweight UI

The apps/space/ directory provides a minimal UI layer designed for embedding within third-party portals or external contexts. The apps/space/package.json configures this as a discrete package within the workspace, optimized for scenarios requiring a stripped-down Plane interface.

live – Document Rendering Service

Located at apps/live/, this service handles on-the-fly document generation, specifically live PDF rendering. The apps/live/package.json defines the service's execution context and dependencies, isolating resource-intensive rendering tasks from the main application thread.

proxy – Reverse Proxy Configuration

The apps/proxy/ directory contains infrastructure configurations for self-hosted deployments, including apps/proxy/Caddyfile.ce. This file defines reverse-proxy rules for Caddy or Nginx, handling SSL termination and request routing between the frontend and API services in production environments.

Architectural Benefits of the apps/ Structure

Independent Development

Each application within apps/ operates as a standalone unit with isolated dependencies defined in its respective package.json or Dockerfile. Developers can run pnpm dev from within apps/web/ to spin up only the user interface, or execute docker compose -f docker-compose-test.yml up api to target backend changes, eliminating the overhead of bootstrapping the entire ecosystem.

Shared Code via Workspace Imports

Despite their independence, these applications leverage shared libraries located in the packages/ directory. Components and utilities are imported using workspace syntax, such as import { Button } from '@plane/ui', allowing consistent design patterns while maintaining strict package boundaries through pnpm workspace protocols.

Consistent CI/CD

The monorepo structure enables unified versioning and testing across all applications. A single repository contains the full stack—from the apps/api/Dockerfile build process to the apps/web/ static assets—simplifying deployment pipelines and ensuring compatibility between frontend and backend releases.

Practical Development Examples

Starting the main web application:

cd apps/web
pnpm dev

Launching the admin console independently:

cd apps/admin
pnpm dev

Running the backend API service:

docker compose -f docker-compose-test.yml up api

Importing shared UI components from workspace packages:

import { Button } from '@plane/ui'

Summary

• The apps/ directory organizes Plane into discrete, runnable applications including web, admin, api, space, live, and proxy.
• Each sub-directory contains its own package.json or Dockerfile, enabling independent development and deployment cycles.
• Frontend applications use framework-specific configuration files such as apps/web/react-router.config.ts and apps/admin/react-router.config.ts for routing management.
• The backend service in apps/api/ is containerized via apps/api/Dockerfile for orchestrated, Docker-based deployments.
• Code sharing is facilitated through workspace imports (e.g., @plane/ui) from the shared packages/ directory, managed by pnpm workspaces and Turbo.

Frequently Asked Questions

What applications are contained in the apps/ directory?

The directory contains six primary applications: web (the main user interface), admin (the management console), api (the Django backend service), space (an embedded lightweight UI), live (the PDF rendering service), and proxy (reverse proxy configurations for self-hosting).

How does Plane handle routing in the frontend applications?

Frontend applications utilize framework-specific routing configurations separate from the main code. The primary UI defines routes in apps/web/react-router.config.ts, while the admin console manages its navigation logic in apps/admin/react-router.config.ts, allowing each interface to maintain independent routing tables.

Can I develop the Plane API without running the frontend applications?

Yes. The apps/api/ directory is fully containerized via apps/api/Dockerfile and can be launched independently using Docker Compose. This allows backend developers to work on Python/Django code without installing Node.js dependencies or building the frontend assets.

What is the purpose of the apps/proxy directory?

This directory houses infrastructure configuration files like apps/proxy/Caddyfile.ce, which define reverse-proxy rules for self-hosted Plane instances. These configurations handle SSL termination, load balancing, and request routing between the various services in production deployments.

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