# Backend Technologies Used in makeplane/plane: A Deep Dive into the Django API Stack

> Explore the Django API stack powering makeplane/plane. Discover its use of Django REST Framework, PostgreSQL, Redis, Celery, and Docker for a robust backend.

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

---

**The makeplane/plane backend is built on Django with Django REST Framework, uses PostgreSQL as the primary database, Redis for caching and message brokering, and Celery for asynchronous task processing, all containerized with Docker.**

Plane is an open-source, full-stack project management platform. While its frontend utilizes React and TypeScript, the server-side architecture relies on a battle-tested Python ecosystem. Below is a comprehensive breakdown of the backend technologies that power the API, data layer, and background processing systems.

## Core Web Framework: Django and Python 3

The backend API is built on **Django** with **Django REST Framework (DRF)** serving as the foundation for handling HTTP requests, ORM operations, and administrative interfaces. The codebase resides primarily in `apps/api/plane/` and follows standard Django conventions for model-view-serializer patterns.

Key configuration files include:

- [`apps/api/plane/celery.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/celery.py) – Celery integration configuration
- `apps/api/plane/models/` – Database models for issues, cycles, modules, and workspaces
- `apps/api/plane/utils/openapi/` – OpenAPI specification utilities

The stack runs on **Python 3** and utilizes Django's built-in authentication system augmented with third-party packages for JWT token handling.

## Data Persistence: PostgreSQL and Redis

**PostgreSQL** serves as the primary relational database, storing structured data for work items, user accounts, project configurations, and activity logs. The Django ORM manages all database interactions through models defined in `apps/api/plane/models/`.

**Redis** operates as a dual-purpose component:

- **Caching layer** – Frequently accessed query results and session data
- **Message broker** – Transport for Celery task queues

This setup is defined in the Docker Compose configuration, where the Redis service connects to both the web API and Celery workers.

## Asynchronous Processing with Celery

Background tasks such as email notifications, data exports, and webhook deliveries are handled by **Celery**. The task queue system decouples time-consuming operations from the main request-response cycle, preventing API latency during heavy operations.

In [`apps/api/plane/celery.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/celery.py), the Celery application is initialized with Redis as the broker backend:

```python
from celery import Celery

app = Celery("plane")
app.config_from_object("django.conf:settings", namespace="CELERY")
app.autodiscover_tasks()

```

Example task implementation for sending notification emails:

```python

# apps/api/plane/tasks.py

from celery import shared_task
from django.core.mail import send_mail

@shared_task
def send_notification_email(recipient: str, subject: str, body: str):
    send_mail(
        subject,
        body,
        "no-reply@plane.so",
        [recipient],
        fail_silently=False,
    )

```

## API Documentation and Authentication

The backend exposes a RESTful API documented via **OpenAPI/Swagger** specifications, with utilities located in `apps/api/plane/utils/openapi/`. This auto-generation ensures the API contracts remain synchronized with the codebase.

Authentication leverages **JWT (JSON Web Tokens)** through Django REST Framework SimpleJWT. This stateless authentication mechanism allows the React frontend to securely communicate with the backend without server-side session storage.

## Testing and Deployment Infrastructure

The testing suite utilizes **pytest** combined with a dedicated Docker Compose configuration ([`docker-compose-test.yml`](https://github.com/makeplane/plane/blob/main/docker-compose-test.yml)) that spins up isolated PostgreSQL and Redis instances for CI/CD pipelines. This ensures database-dependent tests run in clean, reproducible environments.

**Docker** containerizes the entire backend stack, with services defined in:

- [`docker-compose.yml`](https://github.com/makeplane/plane/blob/main/docker-compose.yml) – Production-ready orchestration of web, API, database, and Redis services
- [`docker-compose-test.yml`](https://github.com/makeplane/plane/blob/main/docker-compose-test.yml) – CI-specific test harness

**Nginx** serves as the reverse proxy for HTTP termination and static asset serving within the containerized environment, while **Kubernetes** manifests support scalable production deployments for self-hosted instances.

## Summary

- **Django + Django REST Framework** provides the core web framework and ORM for the Plane API
- **PostgreSQL** handles persistent relational data storage for all project management entities
- **Redis** functions as both cache and message broker for the Celery task queue
- **Celery** processes background jobs asynchronously, keeping the API responsive
- **JWT tokens** secure API endpoints via Django REST Framework SimpleJWT
- **Docker and Docker Compose** enable consistent development, testing, and production deployments

## Frequently Asked Questions

### What database does makeplane/plane use?

Plane uses **PostgreSQL** as its primary relational database. The Django ORM manages all data persistence for entities such as issues, cycles, modules, and user workspaces. Redis supplements this as a caching layer and message broker for background tasks.

### Is the Plane backend built with Django REST Framework?

Yes. While the core framework is Django, the API layer specifically utilizes **Django REST Framework** (DRF) to handle serialization, viewsets, and authentication. This combination powers the RESTful endpoints that the React frontend consumes.

### How does Plane handle background tasks like email notifications?

Plane uses **Celery** with **Redis** as the message broker to process asynchronous tasks. Tasks are defined in files like [`apps/api/plane/tasks.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/tasks.py) and are executed by Celery workers, allowing the main API to return immediate responses while delegating time-consuming operations to the background queue.

### Can I self-host the Plane backend using Docker?

Yes. The repository includes [`docker-compose.yml`](https://github.com/makeplane/plane/blob/main/docker-compose.yml) files that containerize the Django API, PostgreSQL database, Redis instance, and Celery workers. This configuration supports single-click self-hosted deployments, with additional Kubernetes manifests available for scalable production orchestration.