# What Database Technology Does Plane Use? PostgreSQL Configuration Explained

> Discover how Plane leverages PostgreSQL as its core database. Learn about Django ORM configuration and essential environment variables for optimal performance. Get your setup right.

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

---

**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`](https://github.com/makeplane/plane/blob/main/apps/api/plane/settings.py), the `DATABASES` dictionary constructs the connection string from environment variables, allowing flexible configuration across different deployment environments.

```python

# 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`](https://github.com/makeplane/plane/blob/main/docker-compose.yml) file defines a dedicated `db` service using the official `postgres:15-alpine` image and persists data through a named volume.

```yaml

# 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.

```dotenv

# .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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/apps/api/plane/settings.py) to populate the Django `DATABASES` dictionary. The Docker Compose configuration also references these variables to initialize the PostgreSQL container.