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

> Install Plane on your server with our complete self-hosting guide. Learn to deploy using Docker Compose or Kubernetes for effortless self-hosting.

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

---

**Plane can be installed on any Linux server using Docker Compose via the official [`setup.sh`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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:

```bash
mkdir plane-selfhost && cd plane-selfhost

```

### Step 2: Download the Official Installer Script

The [`setup.sh`](https://github.com/makeplane/plane/blob/main/setup.sh) script is released with every Plane version. It pulls the appropriate [`docker-compose.yaml`](https://github.com/makeplane/plane/blob/main/docker-compose.yaml) and sample `.env` file for that specific release:

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

```bash
./setup.sh

# Choose "1" when prompted

```

After this step completes, your directory contains two critical files:
- [`docker-compose.yaml`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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**:

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

```bash

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

Deploy using Helm:

```bash
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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/docker-compose.yaml) while preserving data volumes.

## Key Configuration Files

Understanding the installation files helps with troubleshooting and customization:

- **[`setup.sh`](https://github.com/makeplane/plane/blob/main/setup.sh)** — The automation script downloaded from GitHub releases that fetches version-appropriate assets
- **[`docker-compose.yaml`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/deployments/cli/community/README.md)** — The authoritative source for Docker Compose installation instructions
- **[`deployments/kubernetes/community/README.md`](https://github.com/makeplane/plane/blob/main/deployments/kubernetes/community/README.md)** — Reference documentation for Helm-based deployments

## Summary

- **Use the official installer**: Download [`setup.sh`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/./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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/./setup.sh), then select option **5) Upgrade**. This pulls the latest [`docker-compose.yaml`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/setup.sh) script located in `deployments/cli/community/`. While advanced users could theoretically extract the container definitions from the generated [`docker-compose.yaml`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/./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`](https://github.com/makeplane/plane/blob/main/docker-compose.yaml).