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

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 – 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, the Celery application is initialized with Redis as the broker backend:

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:

# 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) 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 – Production-ready orchestration of web, API, database, and Redis services
• 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 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 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.

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