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

> Deploy Plane in a production-like environment using Docker Compose, Helm for Kubernetes, or an All-In-One script for easy setup. Get your Plane instance running efficiently.

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

---

**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:

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

```

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

```bash
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`](https://github.com/makeplane/plane/blob/main/docker-compose.yml) file in the project root:

```yaml
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:

```bash
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:

```bash
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`](https://github.com/makeplane/plane/blob/main/deployments/kubernetes/community/README.md).

Add the Plane Helm repository:

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

```

Create a namespace and install the chart:

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

```

Create a [`values.yaml`](https://github.com/makeplane/plane/blob/main/values.yaml) file to override production settings:

```yaml
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:

```bash
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`](https://github.com/makeplane/plane/blob/main/deployments/aio/community/README.md).

Run the installation script:

```bash
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:

```nginx
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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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.