What Are the System Requirements to Run Plane? A Complete Hardware and Software Guide

To run Plane, you need Docker Engine 20.10+, Node.js 20 LTS, Python 3.8+, 12 GiB of RAM, and at least two CPU cores to support the full-stack Docker containers and React front-end builds.

Plane is a full-stack, Docker-based project management platform that combines a Django API backend with several React-based front-ends. According to the makeplane/plane source code, the entire application stack runs inside containers defined in docker-compose.yml, meaning the host machine only needs to satisfy specific runtime prerequisites rather than complex manual installations.

Software Prerequisites

Plane orchestrates multiple services through Docker Compose, but your host machine must provide the core runtime environment to build and manage these containers.

Docker Engine

Docker Engine 20.10 or newer is required to run Plane. This version ensures support for docker compose (the modern plugin) and the multi-container orchestration defined in the repository's docker-compose.yml file. The compose configuration pulls official images for PostgreSQL, Redis, RabbitMQ, and MinIO while building custom containers for the application services.

Node.js Runtime

The front-end monorepo requires Node.js 20 LTS or newer, as specified in CONTRIBUTING.md. This version powers the React applications (apps/web, apps/space, apps/admin, apps/live) and ensures compatibility with the modern ECMAScript modules and TypeScript configuration used throughout the UI packages. The project uses pnpm as its package manager for dependency resolution and parallel builds.

Python Environment

The Django API requires Python 3.8 or newer. The backend installs its dependencies from requirements/*.txt files (such as requirements/test.txt for test containers) as referenced in apps/api/tests/RUNNING_TESTS.md. While Docker containers isolate the runtime, Python 3.8+ is necessary for local development tasks and management scripts outside the containerized environment.

Database and Infrastructure Dependencies

Plane relies on several data stores and message brokers that run as Docker services:

• PostgreSQL: Version 14 is listed in the requirements, though the docker-compose.yml currently pulls postgres:15.7-alpine for the plane-db service.
• Redis: Version 6.2.7 or newer handles caching, background job queuing, and rate-limiting.
• RabbitMQ: Any recent version works; the compose file specifies rabbitmq:3.13.6-management-alpine for the plane-mq service.
• MinIO: Provides S3-compatible object storage for file uploads, using the minio/minio image.

Hardware Requirements

Running the complete Plane stack is resource-intensive due to parallel container builds and multiple running services.

Memory Allocation

12 GiB of RAM is the minimum recommended allocation for the host machine. The official documentation in CONTRIBUTING.md notes that 8 GiB may cause crashes during container builds, particularly when pnpm performs parallel installations or when Django compiles assets. If using Docker Desktop, allocate at least 12 GiB under Settings → Resources → Memory to prevent out-of-memory errors during the initial setup.

Processing Power

A modern multi-core processor with 2 or more cores is recommended. The build process benefits significantly from parallel compilation, especially when pnpm dev starts the web, admin, space, and live applications simultaneously. Background workers (Celery beat and worker containers) also consume CPU cycles when processing asynchronous tasks.

Network Configuration

Plane requires specific ports to be available on the host network:

• 3000-3002: For the web, admin, and space front-end development servers
• 80/443: For the Nginx reverse proxy in production deployments
• Additional custom ports as defined in your docker-compose.yml overrides

Architecture Overview

Understanding the service topology helps clarify why these requirements exist. The docker-compose.yml file defines six primary application services:

1. api: The Django REST API container built from apps/api/Dockerfile.api
2. web, admin, space: React front-end containers built from their respective Dockerfiles (e.g., apps/web/Dockerfile.web)
3. worker and beat-worker: Celery containers for background task processing

Supporting infrastructure includes plane-db (PostgreSQL), plane-redis (Redis), plane-mq (RabbitMQ), plane-minio (object storage), and proxy (Nginx).

Quick Start Verification

After cloning the repository, verify your environment meets these requirements:

# Clone the repository

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

# Run the setup script to check dependencies

chmod +x setup.sh
./setup.sh

# Start the infrastructure

docker compose -f docker-compose-local.yml up -d

# Launch front-end development servers

pnpm dev

The pnpm dev command starts all React applications on ports 3000-3002, while the Docker Compose services handle the backend API on port 8000 (proxied through Nginx).

Key Configuration Files

These source files define the exact system requirements:

• CONTRIBUTING.md: Lists version requirements for Docker, Node.js, Python, PostgreSQL, Redis, and hardware resources.
• docker-compose.yml: Defines service images, build contexts, and environment variables for the complete stack.
• apps/api/Dockerfile.api: Shows Python environment construction and dependency installation from requirements/*.txt.
• apps/web/Dockerfile.web: Demonstrates the Node.js build process for the primary web interface.

Summary

• Docker Engine 20.10+ is mandatory for container orchestration via docker compose.
• Node.js 20 LTS and Python 3.8+ are required for front-end and backend development workflows.
• PostgreSQL 14+, Redis 6.2.7+, RabbitMQ, and MinIO run as containerized services.
• 12 GiB RAM is the practical minimum to prevent crashes during builds and runtime.
• Ports 3000-3002 must be free for development, plus 80/443 for production proxy access.

Frequently Asked Questions

Can I run Plane with 8 GiB of RAM?

While Plane may start with 8 GiB of RAM, the official documentation explicitly warns against this configuration. Memory-related crashes commonly occur during container builds or when running pnpm dev with parallel front-end compilation. Allocate at least 12 GiB to ensure stable operation of the API, workers, and React development servers.

What Docker version is required for Plane?

Plane requires Docker Engine 20.10 or newer, which includes the modern docker compose plugin (V2 syntax). This version supports the multi-service orchestration and health checks defined in the repository's docker-compose.yml file.

Do I need to install PostgreSQL and Redis manually?

No. When running Plane via Docker Compose, PostgreSQL, Redis, RabbitMQ, and MinIO run as separate containers defined in docker-compose.yml. The host machine only needs Docker installed; the compose file automatically pulls postgres:15.7-alpine, redis:6.2.7-alpine, and other required images.

Which ports need to be open to access Plane?

For local development, ensure ports 3000 (web), 3001 (admin), and 3002 (space) are available for the React front-ends, plus port 8000 for the Django API if accessing directly. In production configurations, the Nginx proxy container typically exposes 80 and 443 for HTTP and HTTPS traffic.

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