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

> Discover the purpose of the apps/ directory in the Plane monorepo. It houses runnable projects like the web UI, admin console, and backend, forming the operational core of the product.

- Repository: [Plane/plane](https://github.com/makeplane/plane)
- Tags: internals
- Published: 2026-08-22

---

**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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/admin/package.json) specifies independent scripts and dependencies, while [`apps/admin/react-router.config.ts`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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:

```bash
cd apps/web
pnpm dev

```

Launching the admin console independently:

```bash
cd apps/admin
pnpm dev

```

Running the backend API service:

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

```

Importing shared UI components from workspace packages:

```tsx
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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/web/react-router.config.ts) and [`apps/admin/react-router.config.ts`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/web/react-router.config.ts), while the admin console manages its navigation logic in [`apps/admin/react-router.config.ts`](https://github.com/makeplane/plane/blob/main/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.