docker.recipes

Plane

intermediate

Open-source project management tool like Jira.

Overview

Plane is an open-source project management platform that serves as a compelling alternative to proprietary tools like Jira and Linear. Developed with modern web technologies, Plane offers comprehensive project tracking capabilities including issue management, sprint planning, and team collaboration features. The platform emphasizes user experience with a clean interface while maintaining powerful functionality for agile development workflows. This deployment stack combines Plane's frontend and backend services with PostgreSQL for robust data persistence and Redis for high-performance caching and session management. PostgreSQL provides the ACID compliance and complex query capabilities essential for project management data integrity, while Redis delivers sub-millisecond response times for real-time collaboration features and user sessions. The architecture separates concerns effectively, allowing the frontend to communicate with the API layer while maintaining data consistency across all project management operations. Organizations seeking to maintain control over their project management data while avoiding vendor lock-in will find this stack particularly valuable. The combination offers enterprise-grade reliability through PostgreSQL's proven stability, enhanced performance via Redis caching, and complete customization freedom through Plane's open-source nature. Development teams, startups prioritizing data sovereignty, and enterprises requiring on-premises project management solutions benefit from this self-hosted approach that rivals commercial alternatives.

Key Features

  • Complete issue tracking system with customizable workflows and status transitions
  • Sprint planning and agile project management with burndown charts and velocity tracking
  • Real-time collaboration powered by Redis pub/sub messaging for instant updates
  • Advanced project analytics and reporting backed by PostgreSQL's window functions
  • Team workspace management with role-based permissions and project access control
  • API-first architecture enabling custom integrations and workflow automation
  • Multi-project support with cross-project dependencies and portfolio views
  • PostgreSQL full-text search for comprehensive issue and project content discovery

Common Use Cases

  • 1Software development teams migrating from Jira to reduce licensing costs
  • 2Startups requiring full control over project management data and user information
  • 3Remote development teams needing real-time collaboration on project planning
  • 4Organizations with compliance requirements mandating on-premises data storage
  • 5Development agencies managing multiple client projects with separate workspaces
  • 6Open-source projects requiring transparent and customizable project management
  • 7Companies integrating project management with existing internal tools via API

Prerequisites

  • Minimum 2GB RAM recommended for optimal performance across all services
  • Docker and Docker Compose installed with support for multi-service orchestration
  • Available ports 3000, 8000 for frontend and API access respectively
  • Basic understanding of environment variable configuration for secrets management
  • Familiarity with PostgreSQL backup procedures for production deployments
  • Knowledge of agile project management concepts for effective Plane utilization

For development & testing. Review security settings, change default credentials, and test thoroughly before production use. See Terms

docker-compose.yml

docker-compose.yml
1services: 
2  plane-web: 
3    image: makeplane/plane-frontend:latest
4    container_name: plane-web
5    restart: unless-stopped
6    environment: 
7      NEXT_PUBLIC_API_BASE_URL: http://localhost:8000
8    ports: 
9      - "3000:3000"
10    depends_on: 
11      - plane-api
12    networks: 
13      - plane
14
15  plane-api: 
16    image: makeplane/plane-backend:latest
17    container_name: plane-api
18    restart: unless-stopped
19    environment: 
20      DATABASE_URL: postgres://plane:${DB_PASSWORD}@postgres:5432/plane
21      REDIS_URL: redis://redis:6379
22      SECRET_KEY: ${SECRET_KEY}
23    ports: 
24      - "8000:8000"
25    depends_on: 
26      - postgres
27      - redis
28    networks: 
29      - plane
30
31  postgres: 
32    image: postgres:15-alpine
33    container_name: plane-postgres
34    restart: unless-stopped
35    environment: 
36      POSTGRES_USER: plane
37      POSTGRES_PASSWORD: ${DB_PASSWORD}
38      POSTGRES_DB: plane
39    volumes: 
40      - postgres_data:/var/lib/postgresql/data
41    networks: 
42      - plane
43
44  redis: 
45    image: redis:alpine
46    container_name: plane-redis
47    restart: unless-stopped
48    networks: 
49      - plane
50
51volumes: 
52  postgres_data: 
53
54networks: 
55  plane: 
56    driver: bridge

.env Template

.env
1DB_PASSWORD=changeme
2SECRET_KEY=generate-a-secret-key

Usage Notes

  1. 1Frontend at http://localhost:3000
  2. 2API at http://localhost:8000
  3. 3Jira/Linear alternative

Individual Services(4 services)

Copy individual services to mix and match with your existing compose files.

plane-web
plane-web:
  image: makeplane/plane-frontend:latest
  container_name: plane-web
  restart: unless-stopped
  environment:
    NEXT_PUBLIC_API_BASE_URL: http://localhost:8000
  ports:
    - "3000:3000"
  depends_on:
    - plane-api
  networks:
    - plane
plane-api
plane-api:
  image: makeplane/plane-backend:latest
  container_name: plane-api
  restart: unless-stopped
  environment:
    DATABASE_URL: postgres://plane:${DB_PASSWORD}@postgres:5432/plane
    REDIS_URL: redis://redis:6379
    SECRET_KEY: ${SECRET_KEY}
  ports:
    - "8000:8000"
  depends_on:
    - postgres
    - redis
  networks:
    - plane
postgres
postgres:
  image: postgres:15-alpine
  container_name: plane-postgres
  restart: unless-stopped
  environment:
    POSTGRES_USER: plane
    POSTGRES_PASSWORD: ${DB_PASSWORD}
    POSTGRES_DB: plane
  volumes:
    - postgres_data:/var/lib/postgresql/data
  networks:
    - plane
redis
redis:
  image: redis:alpine
  container_name: plane-redis
  restart: unless-stopped
  networks:
    - plane

Quick Start

terminal
1# 1. Create the compose file
2cat > docker-compose.yml << 'EOF'
3services:
4  plane-web:
5    image: makeplane/plane-frontend:latest
6    container_name: plane-web
7    restart: unless-stopped
8    environment:
9      NEXT_PUBLIC_API_BASE_URL: http://localhost:8000
10    ports:
11      - "3000:3000"
12    depends_on:
13      - plane-api
14    networks:
15      - plane
16
17  plane-api:
18    image: makeplane/plane-backend:latest
19    container_name: plane-api
20    restart: unless-stopped
21    environment:
22      DATABASE_URL: postgres://plane:${DB_PASSWORD}@postgres:5432/plane
23      REDIS_URL: redis://redis:6379
24      SECRET_KEY: ${SECRET_KEY}
25    ports:
26      - "8000:8000"
27    depends_on:
28      - postgres
29      - redis
30    networks:
31      - plane
32
33  postgres:
34    image: postgres:15-alpine
35    container_name: plane-postgres
36    restart: unless-stopped
37    environment:
38      POSTGRES_USER: plane
39      POSTGRES_PASSWORD: ${DB_PASSWORD}
40      POSTGRES_DB: plane
41    volumes:
42      - postgres_data:/var/lib/postgresql/data
43    networks:
44      - plane
45
46  redis:
47    image: redis:alpine
48    container_name: plane-redis
49    restart: unless-stopped
50    networks:
51      - plane
52
53volumes:
54  postgres_data:
55
56networks:
57  plane:
58    driver: bridge
59EOF
60
61# 2. Create the .env file
62cat > .env << 'EOF'
63DB_PASSWORD=changeme
64SECRET_KEY=generate-a-secret-key
65EOF
66
67# 3. Start the services
68docker compose up -d
69
70# 4. View logs
71docker compose logs -f

One-Liner

Run this command to download and set up the recipe in one step:

terminal
1curl -fsSL https://docker.recipes/api/recipes/plane/run | bash

Troubleshooting

  • Frontend shows connection errors: Verify NEXT_PUBLIC_API_BASE_URL matches your actual API endpoint and plane-api container is running
  • Database connection refused: Check DATABASE_URL format and ensure postgres container started before plane-api, verify DB_PASSWORD matches between services
  • Redis connection timeout: Confirm redis container is accessible on port 6379 and REDIS_URL environment variable is correctly formatted
  • Plane API returns 500 errors: Check SECRET_KEY environment variable is set and container logs for Django/PostgreSQL connection issues
  • Slow project loading times: Monitor PostgreSQL performance and consider increasing shared_buffers, check Redis memory usage for caching efficiency
  • User sessions not persisting: Verify Redis container has sufficient memory allocation and is not experiencing eviction policies

Community Notes

Loading...
Loading notes...

Download Recipe Kit

Get all files in a ready-to-deploy package

Includes docker-compose.yml, .env template, README, and license

Components

planepostgresredisminio

Tags

#plane#project#management#jira

Category

Productivity & Collaboration

Related Recipes

Ad Space