Plane

Plane is a modern, open-source project management platform built for teams that want Jira-class capabilities without the vendor lock-in. It unifies work items, sprints (cycles), modules, pages, and analytics into one workspace, letting engineering and product teams manage their entire workflow from a single tool.

Unlike cloud-only alternatives, Plane is designed to be self-hosted from day one. You can run the full stack — web frontend, Django REST API, real-time collaboration server, background workers, and admin interface — using a single Docker Compose file or a Kubernetes Helm chart. The platform supports air-gapped deployments for teams with strict data residency requirements.

Plane’s architecture is built around a modular monorepo with six independently deployable applications. The frontend recently migrated from Next.js to React Router 7 and Vite, delivering faster builds and a cleaner client-only SPA. Real-time collaborative editing is powered by a dedicated HocusPocus (Y.js CRDT) server that syncs document changes without conflicts. Background processing — notifications, imports, exports, AI tasks — runs through Celery workers backed by RabbitMQ.

The community edition ships fully-featured for self-hosters with work items, cycles, modules, views, pages, analytics, and intake (triage queue). Plane Cloud and enterprise tiers add managed hosting, SSO, advanced permissions, and SLA-backed support for organizations that prefer not to operate the infrastructure themselves.

What You Get

• Work Items — Create, assign, and track tasks with a rich-text editor supporting file attachments, sub-issues, labels, priorities, and cross-issue references for complete context preservation.
• Cycles — Run time-boxed sprints with burn-down charts, velocity tracking, and progress visualization to maintain team momentum without needing a separate agile tool.
• Modules — Decompose large initiatives into scoped, independently trackable modules with dedicated member lists and completion metrics for cross-functional teams.
• Views — Build and save filtered issue views scoped to any combination of assignee, label, priority, state, or date, then share them across the team as persistent dashboards.
• Pages — Write and collaborate on documents in real time using a CRDT-powered rich-text editor. Pages can reference work items, embed images, and export to PDF or Markdown without external tools.
• Analytics — Access real-time dashboards that visualize issue trends, cycle velocity, label distribution, and assignee workload across all projects in a workspace.
• Intake (Triage) — Route external bug reports and feature requests into a triage queue where they wait for review before ever touching the main project board.
• Self-hosting — Deploy the entire platform with a single Docker Compose command or Kubernetes Helm chart, with full support for air-gapped environments and custom storage backends.

Common Use Cases

• Replacing Jira for an engineering org — A software company migrates 10,000+ issues, comments, and workflow automations from Jira into Plane using the built-in import tool, gaining the same sprint and backlog features at zero licensing cost.
• Running a product team with living docs — A SaaS startup uses Plane Pages to write product specs alongside the related work items, keeping requirements and tasks in sync so nothing goes stale between planning and delivery.
• Self-hosting for data sovereignty — A fintech startup runs Plane on their own Kubernetes cluster to satisfy compliance requirements, storing all project data in their private PostgreSQL instance with no third-party cloud access.
• Triaging user-submitted bugs — A support team routes customer bug reports into Plane’s Intake queue, where engineers review and convert accepted items into tracked work items with a single click.
• Managing cross-team initiatives with modules — A platform team uses Modules to group related backend, frontend, and infrastructure work items under a single initiative, giving leadership a roll-up view of progress without switching tools.
• Real-time collaborative sprint planning — Distributed team members join a Plane workspace simultaneously, editing cycle boards and document pages in real time through the HocusPocus CRDT sync layer without merge conflicts.

Under The Hood

Architecture Plane is structured as a monorepo containing six independently deployable applications — web (client SPA), admin, space (public project view), api (Django backend), live (real-time collaboration), and proxy — alongside fourteen shared packages for types, constants, editor, hooks, UI, services, and utilities. The frontend runs as a fully client-side React Router 7 + Vite SPA with MobX observable stores managing all reactive state, cleanly separated into a community-edition layer and a plane-web extension layer for enterprise features. The API follows a strict Django REST Framework pattern with explicit serializer classes, service objects, and Celery workers consuming RabbitMQ queues for background jobs. The live server is a dedicated Node.js process running HocusPocus — a Y.js CRDT WebSocket server built on Hocuspocus — providing conflict-free real-time collaborative editing for Pages. Data flows from the browser through the API for persistent operations and through the live WebSocket server for ephemeral collaborative state, with Redis/Valkey bridging the two.

Tech Stack The frontend is TypeScript with React 19, React Router 7, Vite, and MobX, organized with Turbo and pnpm across the monorepo. oxlint and oxfmt replace ESLint and Prettier for dramatically faster linting and formatting. The backend is Python 3.10+ with Django 4.2, Django REST Framework 3.15, Celery 5.4, and django-channels for WebSocket support. The database layer uses PostgreSQL via psycopg3 with MinIO for object storage and Valkey (Redis-compatible) for sessions, caching, and rate limiting. The live collaboration server uses HocusPocus with the @effect/platform library for robust async effects, deploying as a separate container alongside Redis. Infrastructure is containerized with Docker Compose for development and Kubernetes Helm charts for production.

Code Quality The API has an extensive test suite structured into unit, contract, and smoke test tiers, with pytest factories for workspace and member fixtures and explicit @pytest.mark markers for selective test execution. The live server includes Vitest tests for PDF rendering and export utilities. The entire codebase enforces oxlint with per-app max-warnings budgets committed in package.json scripts, creating a ratchet mechanism against quality regression. MobX observable patterns are consistently applied across all store files with runInAction boundaries enforced for all mutations. The monorepo’s Turbo pipeline ensures that type-checking, linting, and formatting run in dependency order across all packages before any build artifact is produced.

What Makes It Unique Plane’s most distinctive technical decision is its community-edition/enterprise split implemented as import-level module aliasing rather than runtime feature flags — the CE web app simply imports stub implementations that the enterprise overlay replaces at build time, keeping the open-source codebase honest and auditable. The real-time collaboration layer uses Y.js CRDT through HocusPocus, which means document edits from multiple concurrent users merge automatically without server-side conflict resolution logic. The recent migration from Next.js to React Router 7 + Vite was done with explicit compatibility shim aliases so existing Next.js-style imports resolve at build time without a full rewrite, a pragmatic approach that preserved developer familiarity while eliminating SSR overhead.

Self-Hosting

Plane is released under the GNU Affero General Public License v3.0 (AGPL-3.0), a strong copyleft license that applies to software delivered over a network. In practical terms this means you can run Plane internally for your team at no cost, modify the source code, and distribute your changes — but if you modify Plane and offer it as a network service to others, you must publish those modifications under the same AGPL-3.0 license. For internal company use without redistribution, AGPL-3.0 poses no commercial restriction.

Self-hosting the full Plane stack is well-documented but operationally substantial. A production deployment requires running six containerized services — the web SPA, Django API, live HocusPocus server, admin interface, background Celery worker, and an nginx proxy — alongside PostgreSQL, Redis/Valkey, and optionally MinIO for object storage. You are responsible for all uptime, database backups, SSL termination, capacity planning, and version upgrades. The team publishes Docker Compose and Kubernetes Helm chart configurations to lower the barrier, and a God Mode admin interface is available for instance-level configuration without direct database access.

Compared to Plane Cloud or an enterprise license, self-hosters trade managed infrastructure for data control. The Cloud offering handles all the above operational burden, adds SLA-backed support, and unlocks advanced features like SAML/OIDC SSO, custom roles, and managed AI integrations that are gated behind an enterprise license in the self-hosted edition. Teams choosing self-hosting should budget for a dedicated ops engineer or existing Kubernetes expertise; the deployment is not a one-click install beyond basic evaluation.