How to Run Plane in a Production-Like Environment: 3 Deployment Methods

Deploy Plane in production using Docker Compose for VM-based hosting, the official Helm chart for Kubernetes orchestration, or the All-In-One script for automated single-node installation.

Plane is an open-source project management platform developed by Makeplane. To run Plane in a production-like environment, the repository provides three officially supported deployment paths documented in the makeplane/plane source code. Each method utilizes the same core architecture—Django backend, React frontend, PostgreSQL, and Redis—but caters to different infrastructure requirements and scaling needs.

Prerequisites for Production Deployment

Before deploying Plane, clone the repository and prepare your environment configuration according to the templates in apps/api/.

1. Clone the repository:

git clone https://github.com/makeplane/plane.git
cd plane

2. Copy the environment template from apps/api/.env.example to apps/api/.env:

cp apps/api/.env.example apps/api/.env

3. Edit apps/api/.env to set production values for DATABASE_URL, REDIS_URL, SECRET_KEY, and other required variables.

4. Prepare frontend environment variables in apps/web/.env if customizing the React build.

Docker Compose Deployment

The Docker Compose method is ideal for production deployments on single virtual machines or bare-metal servers. The repository provides a multi-container configuration that isolates the backend, frontend, PostgreSQL, and Redis services.

Create a docker-compose.yml file in the project root:

version: "3.8"

services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_USER: plane
      POSTGRES_PASSWORD: plane
      POSTGRES_DB: plane
    volumes:
      - pg_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine

  backend:
    build: ./apps/api
    env_file: apps/api/.env
    depends_on:
      - postgres
      - redis
    command: >
      sh -c "python manage.py migrate &&
             gunicorn plane.wsgi:application --bind 0.0.0.0:8000"

  frontend:
    build: ./apps/web
    env_file: apps/web/.env
    depends_on:
      - backend
    ports:
      - "3000:3000"

volumes:
  pg_data:

Start the production stack:

docker compose up -d

The backend API becomes available at http://localhost:8000/api/ and the frontend at http://localhost:3000. Run migrations manually if your configuration does not include them in the startup command:

docker compose exec backend python manage.py migrate
docker compose exec backend python manage.py collectstatic --noinput
docker compose exec backend python manage.py createsuperuser

Kubernetes Helm Chart Deployment

For organizations running Kubernetes, Plane provides an official Helm chart available in the Artifact Hub repository (makeplane/plane-ce). This method handles scaling, rolling updates, and service discovery natively, as documented in deployments/kubernetes/community/README.md.

Add the Plane Helm repository:

helm repo add makeplane https://artifacthub.io/packages/helm/makeplane/plane-ce
helm repo update

Create a namespace and install the chart:

kubectl create namespace plane
helm install plane-ce makeplane/plane-ce \
  --namespace plane \
  -f values.yaml

Create a values.yaml file to override production settings:

backend:
  env:
    DATABASE_URL: "postgres://plane:secure_password@postgres-service:5432/plane"
    REDIS_URL: "redis://redis-service:6379/0"
    SECRET_KEY: "your-production-secret-key"
    SECURE_SSL_REDIRECT: "True"
  replicaCount: 2

frontend:
  replicaCount: 2
  service:
    type: LoadBalancer

postgres:
  enabled: true
  persistence:
    size: 50Gi

redis:
  enabled: true

Run database migrations after the pods are ready:

kubectl exec -it deployment/plane-ce-backend -n plane -- python manage.py migrate
kubectl exec -it deployment/plane-ce-backend -n plane -- python manage.py collectstatic --noinput

All-In-One Script Deployment

The All-In-One (AIO) script automates Docker Compose deployment for rapid testing or single-node production environments. This method executes the installation logic documented in deployments/aio/community/README.md.

Run the installation script:

curl -fsSL https://raw.githubusercontent.com/makeplane/plane/preview/deployments/aio/community/install.sh | bash

The script performs the following actions:

• Validates Docker and Docker Compose installation
• Generates a temporary .env file with default values in apps/api/
• Executes docker compose up -d using the multi-container configuration from the repository
• Outputs access URLs for the frontend (http://localhost:3000) and API (http://localhost:8000/api/)

Because the AIO script utilizes the same container images and networking as the manual Docker Compose method, it is suitable for production after updating the generated environment variables with secure credentials in apps/api/.env and configuring proper TLS termination.

Production Hardening and Scaling

After initial deployment, implement these production-specific configurations to secure and scale your Plane instance.

TLS and Reverse Proxy Configuration

Terminate TLS at a reverse proxy (Nginx, Traefik, or cloud load balancer) placed in front of the Plane services. Set SECURE_SSL_REDIRECT=True in apps/api/.env to enforce HTTPS redirection. Place the following Nginx configuration in front of your Docker Compose stack:

server {
    listen 443 ssl;
    ssl_certificate /etc/nginx/certs/fullchain.pem;
    ssl_certificate_key /etc/nginx/certs/privkey.pem;

    location / {
        proxy_pass http://frontend:3000;
    }

    location /api/ {
        proxy_pass http://backend:8000;
    }
}

Scaling Workers and Replicas

For Docker Compose, add dedicated Celery worker containers by extending the compose file with a worker service that runs the Django management command for background tasks. For Kubernetes, increase backend.replicaCount and frontend.replicaCount in your Helm values file to distribute load across multiple pods.

Database and Secret Management

Schedule pg_dump jobs for PostgreSQL persistence volumes or use cloud-native backup solutions. Replace .env files with Docker Secrets or Kubernetes Secrets, mounting sensitive values at runtime rather than baking them into images. Ensure the SECRET_KEY environment variable uses a cryptographically secure random string unique to your production deployment.

Summary

• Docker Compose provides the simplest path for VM-based production deployments, utilizing the multi-container configuration defined in docker-compose.yml at the repository root.

• Kubernetes Helm Chart offers enterprise-grade orchestration with horizontal scaling, available through the makeplane/plane-ce chart documented in deployments/kubernetes/community/README.md.

• All-In-One Script automates Docker Compose setup for rapid deployment scenarios, executing the installation logic from deployments/aio/community/install.sh.

• All methods require configuring apps/api/.env based on the apps/api/.env.example template, with special attention to DATABASE_URL, REDIS_URL, and SECRET_KEY for production security.

Frequently Asked Questions

Can I use an external PostgreSQL or Redis instance instead of the bundled services?

Yes. For Docker Compose, remove the postgres and redis services from your compose file and update DATABASE_URL and REDIS_URL in apps/api/.env to point to your external instances. For Kubernetes, set postgres.enabled: false and redis.enabled: false in your Helm values, then provide connection strings via the backend.env configuration.

How do I scale Plane for high availability?

In Docker Compose, scale by running multiple backend containers behind a load balancer and adding dedicated Celery worker containers for background task processing. In Kubernetes, increase the replicaCount for both backend and frontend components in your Helm values file. The Helm chart handles service discovery and load balancing automatically across available pods.

What is the difference between the AIO script and manual Docker Compose?

The AIO script in deployments/aio/community/install.sh automates the manual steps of environment setup and container orchestration. It generates default configurations and starts services automatically, whereas manual Docker Compose requires you to create and edit configuration files yourself. Both methods use identical container images and are equally production-ready when properly configured.

How do I handle SSL certificates in a production Plane deployment?

Terminate SSL at a reverse proxy (Nginx, Traefik, or cloud load balancer) placed in front of the Plane frontend and backend services. Set SECURE_SSL_REDIRECT=True in apps/api/.env to enforce HTTPS redirection. Mount your certificates as volumes in the reverse proxy container or use Kubernetes Ingress with TLS secrets referenced in your Helm values.

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