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

> Discover the system requirements to run Plane, including Docker Engine Nodejs Python RAM and CPU needs. Get the full hardware and software guide for your Plane setup.

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

---

**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](https://github.com/makeplane/plane) source code, the entire application stack runs inside containers defined in [`docker-compose.yml`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/requirements/test.txt) for test containers) as referenced in [`apps/api/tests/RUNNING_TESTS.md`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/docker-compose.yml) overrides

## Architecture Overview

Understanding the service topology helps clarify why these requirements exist. The [`docker-compose.yml`](https://github.com/makeplane/plane/blob/main/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:

```bash

# 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`](https://github.com/makeplane/plane/blob/main/CONTRIBUTING.md)**: Lists version requirements for Docker, Node.js, Python, PostgreSQL, Redis, and hardware resources.
- **[`docker-compose.yml`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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.