How to Install Plane on a Server: Complete Self-Hosting Guide

Plane can be installed on any Linux server using Docker Compose via the official setup.sh installer, or deployed to Kubernetes using the official Helm chart, with all configuration centralized in a single plane.env file.

Plane is an open-source project management platform developed by MakePlane (makeplane/plane). Self-hosting Plane on your own server gives you complete control over your data and infrastructure. This guide covers the recommended Docker Compose installation path using the official CLI tools, plus the Kubernetes alternative for container orchestration environments.

Prerequisites for Self-Hosting Plane

Before you begin, ensure your server meets these requirements:

• Linux-based operating system (Ubuntu/Debian recommended, though macOS and Windows with Git Bash are supported)
• Docker Engine installed and running
• Docker Compose (v2 plugin or standalone)
• Bash-compatible shell for executing the installer scripts
• A user account with sudo privileges for Docker operations

All installation logic is documented in deployments/cli/community/README.md within the Plane repository.

Installing Plane with Docker Compose

The Docker Compose method is the simplest and most thoroughly documented path to install Plane on a server. The official setup.sh script automates fetching the correct container definitions and environment templates.

Step 1: Prepare the Installation Directory

Create a dedicated directory for your Plane installation to keep configuration files organized:

mkdir plane-selfhost && cd plane-selfhost

Step 2: Download the Official Installer Script

The setup.sh script is released with every Plane version. It pulls the appropriate docker-compose.yaml and sample .env file for that specific release:

curl -fsSL -o setup.sh \
  https://github.com/makeplane/plane/releases/latest/download/setup.sh
chmod +x setup.sh

Step 3: Run the Interactive Installer

Execute the script and select 1) Install when prompted. This option downloads the Docker Compose configuration and generates your environment file:

./setup.sh

# Choose "1" when prompted

After this step completes, your directory contains two critical files:

• docker-compose.yaml — Defines the Plane API, worker, PostgreSQL, Redis, and MinIO services
• plane.env — Template environment file containing all required variables

Step 4: Configure Environment Variables

Edit plane.env to match your infrastructure before starting services. The most critical variables according to deployments/cli/community/README.md are:

• LISTEN_HTTP_PORT — The port your server will listen on (default is 80)
• WEB_URL — The public URL you'll access Plane through, e.g., https://plane.example.com or https://your-server-ip:8080
• CORS_ALLOWED_ORIGINS — Must match your WEB_URL exactly to prevent cross-origin errors

Additionally, configure any SMTP settings for email notifications, S3-compatible storage credentials, or OAuth providers as needed.

Step 5: Start the Plane Services

Run the installer script again and select 2) Start:

./setup.sh

# Choose "2"

Docker will pull the required images, create containers, run database migrations automatically, and expose the service. Successful startup is confirmed by logs showing Listening at: http://0.0.0.0:8000.

Complete Docker Installation Example

For Ubuntu servers, the full workflow looks like this:

# Install Docker prerequisites

sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
  | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Add Docker repository

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker and Compose plugin

sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io \
  docker-buildx-plugin docker-compose-plugin

# Prepare Plane installation

mkdir -p /opt/plane && cd /opt/plane
curl -fsSL -o setup.sh \
  https://github.com/makeplane/plane/releases/latest/download/setup.sh
chmod +x setup.sh

# Install and configure

./setup.sh  # Select "1" for Install

nano plane.env  # Set WEB_URL, LISTEN_HTTP_PORT, and CORS_ALLOWED_ORIGINS

# Start services

./setup.sh  # Select "2" for Start

Installing Plane on Kubernetes

For production environments running Kubernetes, Plane provides a Helm chart documented in deployments/kubernetes/community/README.md.

Deploy using Helm:

helm repo add makeplane https://github.com/makeplane/plane
helm repo update

helm install plane-ce makeplane/plane-ce \
  --set ingress.host=plane.example.com \
  --set env.LISTEN_HTTP_PORT=8080 \
  --set env.EMAIL_HOST=mail.example.com

The Helm chart handles the same component architecture (API, worker, PostgreSQL, Redis, MinIO) but manages them as Kubernetes resources rather than Docker containers.

Managing Your Plane Server

The setup.sh script provides lifecycle management commands accessible by re-running the script:

• Stop services — Select option 3 to gracefully shut down all containers
• Restart — Select option 4 to restart the stack
• Upgrade — Select option 5 to download the latest docker-compose.yaml and plane.env templates from the current release
• View logs — Select option 6 to stream logs from a specific service (API, worker, database, etc.)

These operations modify the containers defined in your generated docker-compose.yaml while preserving data volumes.

Key Configuration Files

Understanding the installation files helps with troubleshooting and customization:

• setup.sh — The automation script downloaded from GitHub releases that fetches version-appropriate assets
• docker-compose.yaml — Generated orchestration file defining the Plane API, Celery worker, PostgreSQL, Redis, MinIO, and proxy services
• plane.env — Centralized environment configuration loaded by all containers; edit this rather than modifying individual container settings
• deployments/cli/community/README.md — The authoritative source for Docker Compose installation instructions
• deployments/kubernetes/community/README.md — Reference documentation for Helm-based deployments

Summary

• Use the official installer: Download setup.sh from the latest GitHub release to automate fetching the correct Docker Compose configuration
• Configure before starting: Edit plane.env to set WEB_URL, LISTEN_HTTP_PORT, and CORS_ALLOWED_ORIGINS before launching services
• Manage via menu: Use the same ./setup.sh script for installation, startup, upgrades, and log viewing rather than manual Docker commands
• Kubernetes alternative: Deploy using the plane-ce Helm chart from the makeplane repository if running on Kubernetes clusters

Frequently Asked Questions

What are the minimum server requirements for self-hosting Plane?

Plane requires a Linux server with Docker Engine and Docker Compose installed. While the repository doesn't enforce rigid hardware limits, allocate at least 2GB RAM and 20GB storage to comfortably run the PostgreSQL, Redis, MinIO, and application containers simultaneously. The deployments/cli/community/README.md assumes a standard Ubuntu/Debian environment but provides compatibility notes for macOS and Windows via Git Bash.

How do I upgrade Plane to the latest version?

Navigate to your Plane installation directory and run ./setup.sh, then select option 5) Upgrade. This pulls the latest docker-compose.yaml and plane.env templates from the current GitHub release, ensuring your configuration files match the new version's requirements. Always back up your database before upgrading.

Can I install Plane without using Docker?

The officially supported method to install Plane on a server uses Docker Compose via the setup.sh script located in deployments/cli/community/. While advanced users could theoretically extract the container definitions from the generated docker-compose.yaml and run services directly, there is no supported bare-metal installation path, as the application architecture depends on linked services (PostgreSQL, Redis, MinIO) defined in the container orchestration.

Where are the logs stored when running Plane on a server?

Rather than searching log directories manually, use the management interface by running ./setup.sh and selecting option 6) Logs. This presents a menu to select specific services (API, worker, beat-worker, database, Redis, or MinIO) and streams real-time Docker logs. This method is recommended over manual docker logs commands because it automatically targets the correct container names defined in the generated docker-compose.yaml.

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