Deploy Plane with Dokploy

Dokploy is an open-source server management platform that simplifies deploying Docker Compose applications on your VPS. It handles reverse proxy configuration, SSL certificates, and deployment management — making it practical to run Plane as your self-hosted project management tool.

This guide walks you through deploying the complete Plane stack: the web frontend, API server, background workers, PostgreSQL database, Redis cache, and MinIO for file storage, all with persistent data and automatic HTTPS.

Prerequisites

• A VPS with at least 4 vCPUs, 4 GB RAM, and 30 GB storage
• Dokploy installed and running on your server (installation docs)
• A domain name (e.g., plane.yourdomain.com) with DNS A record pointing to your server's IP

Docker Compose Configuration

Create a new Compose project in Dokploy and paste the following configuration:

version: "3.8"

services:
  plane-web:
    image: makeplane/plane-frontend:stable
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - NEXT_PUBLIC_API_BASE_URL=https://${PLANE_DOMAIN}
    depends_on:
      - plane-api

  plane-api:
    image: makeplane/plane-backend:stable
    restart: unless-stopped
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://plane:${DB_PASSWORD}@plane-db:5432/plane
      - REDIS_URL=redis://plane-redis:6379
      - SECRET_KEY=${SECRET_KEY}
      - CORS_ALLOWED_ORIGINS=https://${PLANE_DOMAIN}
      - WEB_URL=https://${PLANE_DOMAIN}
      - AWS_S3_ENDPOINT_URL=http://plane-minio:9000
      - AWS_ACCESS_KEY_ID=${MINIO_ROOT_USER}
      - AWS_SECRET_ACCESS_KEY=${MINIO_ROOT_PASSWORD}
      - AWS_S3_BUCKET_NAME=plane-uploads
      - AWS_REGION=us-east-1
      - USE_MINIO=1
    volumes:
      - ../files/plane-logs:/code/plane/logs
    depends_on:
      plane-db:
        condition: service_healthy
      plane-redis:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:8000/ || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 5

  plane-worker:
    image: makeplane/plane-backend:stable
    restart: unless-stopped
    command: ["celery", "-A", "plane", "worker", "-l", "info"]
    environment:
      - DATABASE_URL=postgresql://plane:${DB_PASSWORD}@plane-db:5432/plane
      - REDIS_URL=redis://plane-redis:6379
      - SECRET_KEY=${SECRET_KEY}
      - AWS_S3_ENDPOINT_URL=http://plane-minio:9000
      - AWS_ACCESS_KEY_ID=${MINIO_ROOT_USER}
      - AWS_SECRET_ACCESS_KEY=${MINIO_ROOT_PASSWORD}
      - AWS_S3_BUCKET_NAME=plane-uploads
      - AWS_REGION=us-east-1
      - USE_MINIO=1
    depends_on:
      plane-db:
        condition: service_healthy
      plane-redis:
        condition: service_healthy

  plane-beat:
    image: makeplane/plane-backend:stable
    restart: unless-stopped
    command: ["celery", "-A", "plane", "beat", "-l", "info"]
    environment:
      - DATABASE_URL=postgresql://plane:${DB_PASSWORD}@plane-db:5432/plane
      - REDIS_URL=redis://plane-redis:6379
      - SECRET_KEY=${SECRET_KEY}
    depends_on:
      plane-db:
        condition: service_healthy
      plane-redis:
        condition: service_healthy

  plane-db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_DB=plane
      - POSTGRES_USER=plane
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - ../files/plane-db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U plane"]
      interval: 10s
      timeout: 5s
      retries: 5

  plane-redis:
    image: redis:7-alpine
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  plane-minio:
    image: minio/minio:latest
    restart: unless-stopped
    command: ["server", "/data", "--console-address", ":9001"]
    environment:
      - MINIO_ROOT_USER=${MINIO_ROOT_USER}
      - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD}
    volumes:
      - ../files/plane-minio-data:/data

Note: Plane uses a multi-service architecture with separate frontend, API, worker, and scheduler containers. The worker and beat services handle background tasks like notifications and scheduled jobs using Celery.

Environment Variables

Set these in Dokploy's Environment tab for your compose project:

Variable	Purpose	Example
PLANE_DOMAIN	Your Plane domain name	plane.yourdomain.com
DB_PASSWORD	PostgreSQL database password	a-strong-random-password
SECRET_KEY	Django secret key for session encryption	openssl rand -hex 32 output
MINIO_ROOT_USER	MinIO admin username	plane-minio-admin
MINIO_ROOT_PASSWORD	MinIO admin password	a-strong-minio-password

In Dokploy, environment variables are set via the Environment editor in the project settings. Do not create a .env file manually — Dokploy manages this for you. Generate SECRET_KEY by running openssl rand -hex 32 on your server.

Volumes & Data Persistence

This setup uses Dokploy's ../files convention for bind-mounted volumes:

• ../files/plane-db-data — PostgreSQL database files (projects, issues, users)
• ../files/plane-minio-data — File uploads and attachments stored in MinIO
• ../files/plane-logs — API server application logs

The ../files path is relative to the compose file inside Dokploy's project directory. This ensures your data persists across redeployments. Avoid using absolute paths because Dokploy may clean them during redeployment.

Domain & SSL Setup

1. In your Dokploy project, navigate to the Domains tab
2. Click Add Domain and enter your domain (e.g., plane.yourdomain.com)
3. Set the container port to 3000 (the web frontend)
4. Enable HTTPS — Dokploy automatically provisions a Let's Encrypt SSL certificate
5. Save and wait for the certificate to be issued (usually under a minute)

Dokploy's built-in Traefik reverse proxy handles TLS termination and routes traffic to your Plane frontend container. The frontend proxies API requests to the backend service internally.

Verifying the Deployment

1. In Dokploy, go to your project's Deployments tab and click Deploy
2. Watch the build logs — all services should start (web, API, worker, beat, database, Redis, MinIO)
3. Check the Logs tab for plane-api. Look for the Django startup message
4. Open https://plane.yourdomain.com in your browser — you should see the Plane setup screen
5. Create your admin account and set up your first workspace

Troubleshooting

API server can't connect to database Check that plane-db is healthy in Dokploy's logs. PostgreSQL may take 10–20 seconds to initialize on first launch. Verify DB_PASSWORD matches between all services.

File uploads not working Ensure the MinIO service is running and the credentials match between plane-api and plane-minio. The MinIO bucket plane-uploads is created automatically on first use. Check MinIO container logs for access errors.

Background tasks not processing (notifications delayed) Check logs for plane-worker and plane-beat containers. Both need a working Redis connection. Ensure plane-redis is healthy and the REDIS_URL is correct.

SSL certificate not issuing Ensure your domain's DNS A record points to your server's IP and has propagated. Dokploy uses Let's Encrypt HTTP-01 challenges, so port 80 must be accessible. Check Traefik logs in Dokploy for certificate-related errors.

---

Learn more about Plane in our complete overview.

Need a VPS? Hostinger VPS starts at $4.99/mo — perfect for running Plane.

---

For more on Docker Compose deployments in Dokploy, see the Dokploy Docker Compose documentation.

App data sourced from selfh.st open-source directory.