How to Deploy Plane: Complete Guide to Self-Hosting Deployment Options

Plane supports five primary containerized deployment methods: Docker Compose for straightforward multi-service stacks, Kubernetes for production-grade orchestration, Docker Swarm for cluster-aware environments, an all-in-one Docker image for rapid testing, and a CLI installer for guided VM setup.

Plane is an open-source project management platform developed by Makeplane. The repository provides infrastructure-as-code templates that let you self-host Plane using whichever container orchestrator matches your operational requirements, from single-node Docker Compose to distributed Kubernetes clusters.

Docker Compose Deployment

The simplest way to run Plane locally or on a single VM is via the root-level docker-compose.yml. This file defines the complete service stack—including the PostgreSQL database, Redis cache, Django backend API, Celery worker, and React frontend—making it ideal for small teams or development environments.

Configuration is handled through a variables.env file located in deployments/cli/community/. Copy this template to the repository root, adjust the database credentials and secret keys, then start the stack:

# Clone the repository

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

# Configure environment variables

cp deployments/cli/community/variables.env .env

# Start the multi-container application

docker compose up -d

The docker-compose.yml mounts persistent volumes for PostgreSQL data and exposes the web interface on port 3000 and the API on port 8000.

Kubernetes Deployment

For production environments requiring scalability and high availability, Plane provides raw Kubernetes manifests in deployments/kubernetes/community/. These manifests include Deployments for the API and worker pods, Services for internal communication, ConfigMaps for environment configuration, and optional Ingress resources for external traffic.

According to the deployments/kubernetes/community/README.md, you should first update the plane-config ConfigMap with your database endpoints and secrets, then apply the manifests:

# Apply all Kubernetes resources

kubectl apply -f deployments/kubernetes/community/

# Verify the deployment status

kubectl get pods -l app=plane

This method supports standard Kubernetes features like Horizontal Pod Autoscaling and Rolling Updates, making it suitable for GKE, EKS, or AKS clusters.

Docker Swarm Deployment

If your infrastructure already uses Docker Swarm, Plane includes a helper script at deployments/swarm/community/swarm.sh that converts the Compose definition into a Swarm stack. The script handles service creation, network configuration, and optional secret generation for database passwords.

Deploy to a Swarm manager node with:

cd deployments/swarm/community

# Make the script executable and run the stack

chmod +x swarm.sh
./swarm.sh up

# Verify the stack is running

docker stack ls

The Swarm configuration maintains service replicas across nodes and uses overlay networks for secure inter-service communication.

All-In-One (AIO) Docker Image

The deployments/aio/community/Dockerfile builds a single container image that bundles the Django backend, Celery worker, and React frontend into one process. This all-in-one image is useful for CI/CD pipelines, air-gapped environments, or quick demonstrations where you do not need service separation.

Build and run the AIO image using:

# Pull the pre-built image

docker pull makeplane/plane:aio:latest

# Run the container exposing web and API ports

docker run -d \
  -p 3000:3000 \
  -p 8000:8000 \
  makeplane/plane:aio

The AIO container internally manages process supervision via an init system, ensuring the worker and web server restart automatically if they fail.

CLI Community Installer

For automated setup on fresh virtual machines, the deployments/cli/community/ directory contains an interactive installer script. The install.sh script generates the .env file, pulls the correct Docker images, and optionally runs database migrations, abstracting the manual configuration steps required by the raw Compose method.

Execute the installer with:

cd deployments/cli/community

# Run the guided installation

./install.sh

The CLI installer checks for Docker and Docker Compose prerequisites, prompts for domain configuration, and can configure SSL certificates when deploying to public-facing servers.

Summary

• Docker Compose (docker-compose.yml) provides the fastest path to a working Plane instance on a single host.
• Kubernetes manifests in deployments/kubernetes/community/ support production workloads with auto-scaling and rolling deployments.
• Docker Swarm users can leverage deployments/swarm/community/swarm.sh for cluster-aware container orchestration.
• The All-In-One image (deployments/aio/community/Dockerfile) packages the entire application into a single container for isolated testing.
• The CLI Installer (deployments/cli/community/install.sh) automates environment setup and is ideal for first-time deployments on new VMs.

Frequently Asked Questions

What is the fastest way to test Plane locally?

The All-In-One Docker image is the fastest deployment option for local testing. Running docker run -p 3000:3000 -p 8000:8000 makeplane/plane:aio starts the complete application stack without requiring external databases or configuration files.

Can I deploy Plane on Kubernetes without using Helm?

Yes. Plane provides raw Kubernetes manifests in deployments/kubernetes/community/ that do not require Helm. You can deploy directly using kubectl apply -f deployments/kubernetes/community/ after configuring the plane-config ConfigMap values.

How do I migrate from Docker Compose to Kubernetes?

First, export your data from the PostgreSQL container running in Docker Compose using pg_dump. Then, deploy Plane to Kubernetes using the manifests in deployments/kubernetes/community/ and restore the database dump to the new PostgreSQL instance. Ensure you copy the SECRET_KEY and database credentials from your Compose .env file to the Kubernetes plane-config ConfigMap.

What are the hardware requirements for self-hosting Plane?

For the Docker Compose deployment, Plane requires at least 2 CPU cores and 4GB RAM to run the database, cache, and application services comfortably. Kubernetes deployments should allocate 1 CPU and 2GB RAM per pod for the API and worker services, with additional resources for the PostgreSQL and Redis StatefulSets.

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