Plane: Self-Hosted Jira Alternative That Doesn't Fight You

Jira is the default for engineering project management. It also has a reputation: slow, complex, and expensive at scale. Teams that don't need Jira's enterprise features often want something lighter that covers issues, sprints, roadmaps, and cycles — without the administrative overhead.

Photo by JAVIER SEPULVEDA PASCUAL on Unsplash

Plane is an open-source project management tool designed to be that alternative. It covers Jira's core workflow — issues, sprints, modules, analytics — with a cleaner interface and a self-hosted option that keeps your data under your control.

What Plane Includes

Plane's feature set covers the essentials for engineering teams:

Issues: Create, assign, label, and prioritize work items. Set estimates, due dates, and link issues to each other with relationship types (blocks, duplicate, related).

Cycles (sprints): Plan time-boxed work periods with issue assignment, velocity tracking, and burndown charts.

Modules: Group issues by feature, milestone, or team. Modules are flexible containers — use them for epics, cross-functional initiatives, or release planning.

Views: Filter and save issue views by any combination of assignee, label, priority, state, or custom fields. Share views with teammates.

Pages: Document decisions, meeting notes, and technical designs in Plane Pages — a block-based editor that links to issues.

Analytics: Burn-up and burn-down charts, issue distribution by priority/state/assignee, and custom charts.

Deployment with Docker Compose

Plane provides an official Docker Compose setup. Requirements: a server with 2+ GB RAM and Docker installed.

# Download the setup script
curl -fsSL https://raw.githubusercontent.com/makeplane/plane/master/deploy/selfhost/install.sh -o install.sh

# Run the installer
chmod +x install.sh
./install.sh

The installer creates a plane-app/ directory with configuration files and starts the containers. The stack includes:

• plane-web: Next.js frontend
• plane-api: Django REST API
• plane-worker: Background task worker (Celery)
• plane-beat: Scheduled task scheduler
• PostgreSQL: Main database
• Redis: Cache and queue
• Minio: S3-compatible file storage for attachments

By default, Plane runs on port 80. For production, add a reverse proxy with SSL.

Environment Configuration

The main config file is plane-app/.env:

# Database
POSTGRES_USER=plane
POSTGRES_PASSWORD=strong-password-here
POSTGRES_DB=plane

# Secret key (generate with: openssl rand -hex 32)
SECRET_KEY=your-secret-key-here

# Email configuration (for invites and notifications)
EMAIL_HOST=smtp.gmail.com
[email protected]
EMAIL_HOST_PASSWORD=your-app-password
EMAIL_PORT=587
EMAIL_USE_TLS=True
[email protected]

# Storage (uses local Minio by default)
USE_MINIO=1
MINIO_ROOT_USER=minio-user
MINIO_ROOT_PASSWORD=minio-password

# App URL (used for email links)
WEB_URL=https://plane.yourdomain.com

Reverse Proxy Setup

Using Caddy for HTTPS:

plane.yourdomain.com {
    reverse_proxy localhost:80
}

After configuring your proxy, update WEB_URL in the .env file and restart: docker compose restart.

First-Time Setup

Navigate to https://plane.yourdomain.com and complete the setup wizard:

1. Create your account: The first user becomes the instance admin
2. Create a workspace: This is your top-level organization (like a GitHub organization)
3. Create a project: Projects are where issues live
4. Invite teammates: Send email invitations or share an invite link

Migrating from Jira

Plane supports importing from Jira and other tools:

From Jira: Go to Settings → Integrations → Import → Jira. You'll need a Jira API token and project key. Plane imports issues, comments, attachments, labels, and user assignments (matched by email).

From GitHub Issues: Similar integration — provide a GitHub token and repository. Issues import with labels, assignees, and comments.

Manual CSV import: For other tools, export to CSV and map columns to Plane fields.

Workflows and States

Plane uses configurable issue states organized into groups:

• Backlog: Work not yet planned
• Unstarted: Planned but not started
• Started: In progress
• Completed: Done
• Cancelled: Won't be done

Within each group, you can create custom states. For example, under "Started" you might have: "In Development", "In Review", "In QA". This gives you a Jira-like workflow without the complex transition rules.

Labels and Priority

Priority levels are fixed: Urgent, High, Medium, Low, None. Labels are fully customizable — create labels for team, type (bug/feature/chore), or component. Labels can be filtered in views and used for reporting.

GitHub Integration

Plane connects to GitHub to link commits and PRs to issues:

1. Install the Plane GitHub App on your repository
2. In Plane: Settings → Integrations → GitHub
3. Reference issues in commits with Fixes PROJ-123 or Closes PROJ-456

Linked PRs show up in the issue detail, and merged PRs can auto-transition issues to a completed state.

API Access

Plane has a full REST API with API key authentication. The API covers everything in the UI: create/update issues, manage cycles, run queries.

# Example: List issues in a project
curl -H "X-Api-Key: your-api-key" \
  "https://plane.yourdomain.com/api/v1/workspaces/your-workspace/projects/your-project/issues/"

The API is useful for integrations — CI/CD systems can create bug reports, scripts can bulk-update issue states, and dashboards can pull project metrics.

Updates

cd plane-app
docker compose pull
docker compose up -d

Check the Plane changelog before updating — breaking migrations occasionally require manual steps documented in the release notes.

Plane vs Alternatives

Plane sits between Linear (excellent UX, cloud-only) and Jira (full-featured, heavyweight). For small-to-medium engineering teams who want data ownership and Jira-level features without the Jira tax, it hits the right balance.

Resource Usage

A small team (5–10 people, a few active projects) needs:

• 2 CPU cores
• 2–4 GB RAM
• 20 GB disk (more if you store large attachments)

Plane is more resource-intensive than simpler tools (it runs 6+ containers) but stays manageable on a basic VPS or mini PC.

When to Use Plane

Plane works well for:

• Engineering teams currently using Jira who want to self-host
• Startups that want full project management without per-seat costs scaling with the team
• Teams with compliance requirements who can't use cloud project management tools
• Any team that wants Kanban, sprints, roadmaps, and analytics in one place

It's not ideal for very small teams (a simple issue tracker like GitLab Issues might suffice) or for non-technical project management where Notion or Asana's interface fits better.