# Key Features of the Plane Application: A Technical Guide to the Open-Source Project Management Platform

> Explore the key features of the Plane application, an open-source project management platform. Discover its work tracking, sprint cycles, analytics, and self-hosting capabilities.

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

---

**The Plane application is an open-source project management platform that combines a React TypeScript frontend with a Django REST API to deliver work item tracking, sprint cycles, modules, real-time analytics, and self-hosting capabilities through a modular monorepo architecture.**

Plane is an open-source project management platform maintained in the `makeplane/plane` repository on GitHub. The application provides a comprehensive solution for team collaboration through a clean separation between a polished web interface and a robust Python backend. Built as a modular monorepo, Plane delivers enterprise-grade features while supporting extensive customization and self-hosting options.

## Work Item Management and Issue Tracking

The core functionality of the Plane application revolves around **work items** (issues, tasks, and bugs) that teams can create, assign, and track through customizable workflows. In [`apps/api/plane/api/views/issue.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/api/views/issue.py), the `IssueListCreateAPIEndpoint` class implements the REST endpoints for listing, creating, retrieving, updating, and deleting work items (lines 48-84).

The backend optimizes database queries using Django's `select_related` and `prefetch_related` methods to ensure fast loading of issue lists with their related assignees, labels, and states. The API supports rich-text descriptions, file uploads, and sub-properties, enabling detailed documentation of tasks.

### Creating Work Items via the API

```python
import requests

BASE_URL = "https://app.plane.so/api"
TOKEN = "YOUR_PERSONAL_ACCESS_TOKEN"

payload = {
    "title": "Implement feature X",
    "description": "Detailed description with **markdown**",
    "project": "my-project",
    "workspace": "my-workspace",
    "state": "backlog",
    "assignees": ["user@example.com"],
    "labels": ["backend", "high-priority"]
}

headers = {"Authorization": f"Bearer {TOKEN}"}
response = requests.post(f"{BASE_URL}/workspaces/my-workspace/projects/my-project/issues/", json=payload)

print(response.status_code)  # 201 if created

print(response.json())

```

This Python example demonstrates the JSON API structure consumed by the React frontend, mapping directly to the `IssueListCreateAPIEndpoint` implementation (lines 51-61).

## Project Organization: Cycles and Modules

Plane provides sophisticated tools for organizing work beyond simple lists. **Cycles** enable sprint-style timeboxing with burndown charts for Agile teams, while **Modules** allow grouping related work items into logical containers for large-scale project management.

The module endpoints in [`apps/api/plane/api/views/module.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/api/views/module.py) (lines 573-865) support creating modules, adding work items to them, and managing project structure. These endpoints follow RESTful patterns consistent with the work item API, ensuring a uniform developer experience.

### Adding a New Module via API

```bash
curl -X POST "https://app.plane.so/api/workspaces/my-workspace/projects/my-project/modules/" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"UI Refactor","description":"All UI related tasks"}'

```

This cURL command interacts with the module creation endpoints, allowing programmatic organization of work items into logical groups.

## Real-Time Analytics and Reporting

The Plane application includes comprehensive **analytics** capabilities that provide visibility into team velocity, bottlenecks, and project trends. The analytics endpoints in [`apps/api/plane/api/views/analytic/project_analytics.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/api/views/analytic/project_analytics.py) (lines 60-62) deliver real-time dashboards showing cycle times, completion rates, and workload distribution.

These endpoints aggregate data across work items, cycles, and modules to generate insights without requiring external business intelligence tools. The system calculates metrics such as burndown rates and velocity trends directly from the database, presenting them through the React frontend or the JSON API.

## Frontend Architecture and Component Library

The Plane frontend is architected as a **modular monorepo** using pnpm workspaces, separating concerns between a base component library (`packages/ui`) and a design system (`packages/propel`). This structure enables independent versioning and fast incremental builds across the codebase.

The UI utilizes **React with TypeScript** configured with strict type checking, **MobX** for state management, and **Tailwind CSS** for styling. Reusable components such as dropdowns, tooltips, and spinners are documented with Storybook and exported for use across the application. The internationalization layer in [`packages/i18n/src/provider/index.tsx`](https://github.com/makeplane/plane/blob/main/packages/i18n/src/provider/index.tsx) ensures UI strings support multiple languages.

### Fetching Work Items in React

```tsx
import { useEffect, useState } from "react";
import axios from "axios";

export const useWorkItems = (workspace: string, project: string) => {
  const [items, setItems] = useState<any[]>([]);
  const [next, setNext] = useState<string | null>(null);

  const fetchPage = (url: string) =>
    axios.get(url, { headers: { Authorization: `Bearer ${TOKEN}` } })
      .then(res => {
        setItems(prev => [...prev, ...res.data.results]);
        setNext(res.data.next);
      });

  useEffect(() => {
    fetchPage(`/api/workspaces/${workspace}/projects/${project}/issues/`);
  }, [workspace, project]);

  return { items, loadMore: () => next && fetchPage(next) };
};

```

This React hook demonstrates how the frontend consumes the paginated endpoints from `IssueListCreateAPIEndpoint`, supporting infinite scroll patterns for large issue lists.

## API Design and Documentation

The Plane backend automatically generates a complete **OpenAPI specification** from code annotations using decorators such as `@extend_schema` and `@work_item_docs`. This ensures the API documentation remains synchronized with the implementation, providing first-class support for client generation and third-party integrations.

The API layer relies on Django REST Framework serializers and maintains a fully-typed contract that the React frontend consumes. Presigned URLs for direct S3 uploads and external link management are handled through dedicated endpoints in [`apps/api/plane/api/views/attachment.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/api/views/attachment.py) and [`apps/api/plane/api/views/work_item_link.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/api/views/work_item_link.py).

## Authentication and Authorization

Plane supports multiple **OAuth providers** including Google, GitHub, GitLab, and Gitea, implemented in `apps/api/plane/authentication/provider/oauth/`. The authentication system combines OAuth 2.0 flows with session-based cookies for web clients, ensuring secure access control.

Permission enforcement uses Django REST Framework permission classes such as `ProjectEntityPermission` and `WorkspaceEntityPermission` located in `apps/api/plane/utils/permissions/`. These classes enforce fine-grained access control, ensuring only workspace admins or project creators can perform mutation operations on sensitive resources.

## Background Processing and Infrastructure

The application architecture includes **Celery workers** defined in `apps/api/plane/bg_tasks/` for handling asynchronous operations such as S3 file copies, email notifications, and data cleanup. Unit tests for these background tasks exist in `apps/api/plane/tests/unit/bg_tasks/`.

Middleware components in `apps/api/plane/middleware/` handle request logging, database read-replica routing, and rate limiting. This infrastructure ensures the Plane application can scale to handle enterprise workloads while maintaining data integrity.

## Self-Hosting and Deployment Options

Plane is designed for **self-hosting** through official Docker Compose configurations and Helm charts. The repository includes production-ready deployment documentation in [`deployments/docker/README.md`](https://github.com/makeplane/plane/blob/main/deployments/docker/README.md) and [`deployments/kubernetes/README.md`](https://github.com/makeplane/plane/blob/main/deployments/kubernetes/README.md), enabling teams to run the entire stack on their own infrastructure.

The deployment architecture supports the React frontend, Django API, PostgreSQL database, and Celery workers as separate containers, allowing for independent scaling of web and background processing tiers.

## Summary

- **Work Items** serve as the central entity in Plane, with CRUD operations optimized in [`apps/api/plane/api/views/issue.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/api/views/issue.py) using Django's query optimization techniques.
- **Cycles and Modules** provide sprint planning and logical grouping capabilities through dedicated API endpoints in the Django backend.
- **Real-Time Analytics** endpoints deliver insights into velocity and bottlenecks without requiring external tools.
- The **Modular Monorepo** architecture separates the React TypeScript frontend (`packages/ui`, `packages/propel`) from the Python API (`apps/api`), enabling independent development and deployment.
- **Automatic OpenAPI Generation** keeps API documentation synchronized with code changes through decorators like `@extend_schema`.
- **OAuth Integrations** and fine-grained permission classes ensure secure, role-based access control across workspaces and projects.
- **Celery Workers** and middleware components handle background tasks, rate limiting, and database routing for production scalability.
- Official **Docker and Kubernetes** deployment guides support self-hosting in production environments.

## Frequently Asked Questions

### What is the Plane application used for?

The Plane application is an open-source project management platform used for tracking work items, organizing sprints through cycles, managing project modules, and analyzing team productivity. It provides a centralized workspace for software teams to collaborate on issues, tasks, and documentation while supporting self-hosting for data privacy and security compliance.

### How does the Plane application handle authentication and permissions?

Plane implements authentication through multiple OAuth providers (Google, GitHub, GitLab, Gitea) located in `apps/api/plane/authentication/provider/oauth/`, alongside session-based authentication for web clients. The system uses Django REST Framework permission classes such as `ProjectEntityPermission` and `WorkspaceEntityPermission` to enforce role-based access control, ensuring only authorized users can modify workspace and project resources.

### What technology stack powers the Plane application?

The Plane application uses a **React TypeScript** frontend built with Tailwind CSS and MobX for state management, and a **Django REST Framework** backend with PostgreSQL. The codebase is organized as a pnpm monorepo containing UI packages (`packages/ui`, `packages/propel`) and the API (`apps/api`), with Celery handling background tasks and OpenAPI specifications generated automatically from code annotations.

### Can I self-host the Plane application on my own infrastructure?

Yes, Plane is designed specifically for self-hosting with official support for Docker Compose and Kubernetes deployments. The repository includes production-ready configurations in [`deployments/docker/README.md`](https://github.com/makeplane/plane/blob/main/deployments/docker/README.md) and [`deployments/kubernetes/README.md`](https://github.com/makeplane/plane/blob/main/deployments/kubernetes/README.md), allowing teams to deploy the full stack including the React frontend, Django API, PostgreSQL database, and Celery workers on private servers or cloud infrastructure.