What Database Technology Does Plane Use? PostgreSQL Configuration Explained

Plane uses PostgreSQL as its primary database technology, configured through Django's ORM with environment variables for connection credentials.

Plane is an open-source project management platform developed by MakePlane. The application is built on a Django backend that relies on PostgreSQL as its core database technology for production environments. While the codebase supports SQLite for local development, the official deployment architecture uses PostgreSQL as the primary data store.

PostgreSQL Configuration in Django

Plane's Django backend explicitly selects PostgreSQL through the django.db.backends.postgresql engine. In apps/api/plane/settings.py, the DATABASES dictionary constructs the connection string from environment variables, allowing flexible configuration across different deployment environments.

# apps/api/plane/settings.py (excerpt)

import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent

# PostgreSQL configuration – values are taken from the environment

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": os.getenv("POSTGRES_DB", "plane"),
        "USER": os.getenv("POSTGRES_USER", "plane_user"),
        "PASSWORD": os.getenv("POSTGRES_PASSWORD", ""),
        "HOST": os.getenv("POSTGRES_HOST", "localhost"),
        "PORT": os.getenv("POSTGRES_PORT", "5432"),
    }
}

This configuration reads five standard PostgreSQL connection parameters: POSTGRES_DB, POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_HOST, and POSTGRES_PORT. The os.getenv calls provide default values for local development, though production deployments should explicitly set these variables.

Docker Compose Database Service

The repository's container orchestration confirms PostgreSQL as the data layer. The docker-compose.yml file defines a dedicated db service using the official postgres:15-alpine image and persists data through a named volume.

# docker-compose.yml (excerpt)

services:
  api:
    image: plane/api:latest
    depends_on:
      - db
    env_file:
      - .env
  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: ${POSTGRES_DB:-plane}
      POSTGRES_USER: ${POSTGRES_USER:-plane_user}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-plane_pass}
    volumes:
      - postgres_data:/var/lib/postgresql/data
volumes:
  postgres_data:

The depends_on declaration in the API service ensures the database container starts before the application attempts to connect. This architecture demonstrates the production-grade database technology stack that Plane uses.

Environment Variable Configuration

Plane externalizes database credentials through environment variables defined in .env.example. This file serves as a template for configuring the PostgreSQL connection without hardcoding sensitive information in the source code.

# .env.example (excerpt)

POSTGRES_DB=plane
POSTGRES_USER=plane_user
POSTGRES_PASSWORD=plane_pass
POSTGRES_HOST=db
POSTGRES_PORT=5432

These variables map directly to the Django configuration in apps/api/plane/settings.py. The POSTGRES_HOST value of db corresponds to the service name defined in Docker Compose, enabling internal DNS resolution within the container network.

Development vs Production Databases

While PostgreSQL powers production instances, Plane's Django configuration allows SQLite as a fallback for local development environments. Developers can omit PostgreSQL environment variables to use a local SQLite file, though this configuration is not recommended for production deployments due to concurrency and durability limitations inherent to SQLite.

Summary

• Plane uses PostgreSQL as its primary database technology for production environments, configured through Django's PostgreSQL backend engine.
• The connection parameters are defined in apps/api/plane/settings.py and read from environment variables including POSTGRES_DB, POSTGRES_USER, and POSTGRES_HOST.
• Docker Compose orchestrates a PostgreSQL 15 container defined in docker-compose.yml with persistent volume storage.
• The .env.example file provides the template for database credentials required by the Django application.
• SQLite is supported only for local development and is not intended for production use.

Frequently Asked Questions

What database technology does Plane use in production?

Plane uses PostgreSQL as its production database technology. The Django backend explicitly configures the django.db.backends.postgresql engine in apps/api/plane/settings.py, and the official Docker Compose setup provisions a PostgreSQL 15 container for data persistence.

How does Plane connect to PostgreSQL?

Plane connects to PostgreSQL through Django's ORM using environment variables. The application reads POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DB, POSTGRES_USER, and POSTGRES_PASSWORD from the environment to construct the database connection string in the DATABASES configuration dictionary.

Can I use a different database with Plane?

While the codebase is architected for PostgreSQL, Django's ORM abstraction theoretically supports other databases that Django supports. However, the docker-compose.yml and configuration files in the makeplane/plane repository are specifically optimized for PostgreSQL, and migrating to MySQL or other databases would require modifying apps/api/plane/settings.py and potentially adjusting migration files.

Where are the database credentials configured in Plane?

Database credentials are configured through environment variables defined in an .env file (based on .env.example). These variables are imported in apps/api/plane/settings.py to populate the Django DATABASES dictionary. The Docker Compose configuration also references these variables to initialize the PostgreSQL container.

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