Plane

Plane is a modern, open‑source project management platform built for developers who need full control over their data and infrastructure. At its core, Plane exposes a RESTful API layered on top of a rich GraphQL‑style query system, enabling fine‑grained access to issues, cycles, modules, and roadmap items. The application is designed around event sourcing for auditability: every state change emits an event that can be replayed or inspected, which is invaluable for debugging and compliance. Plane’s UI is a single‑page application that communicates with the backend via WebSocket for real‑time updates, ensuring a responsive experience even when multiple users collaborate simultaneously.

• Backend: Implemented in Go, leveraging the Gin web framework for routing and GORM as an ORM layer. Business logic is organized into domain services that enforce invariants and coordinate event publishing.
• Database: Uses PostgreSQL as the primary data store, with a separate Redis instance for caching and pub/sub. PostgreSQL’s JSONB columns store flexible issue metadata, while Redis streams hold real‑time notifications.
• Frontend: Built with React 18, using TypeScript for type safety. State is managed by Recoil and data fetching via React Query, which automatically syncs with the backend over HTTP/GraphQL.
• Infrastructure: Docker images are available for all components, with a docker‑compose template and Helm charts for Kubernetes. The architecture follows a micro‑service‑like pattern within a single repository, making it straightforward to scale individual services (e.g., the notification worker) horizontally.

• Rich Issue Tracking: Supports nested sub‑issues, custom properties (text, number, date), and file attachments stored in an S3-compatible bucket.
• Cycles & Roadmaps: Provides burn‑down charts, cycle planning boards, and milestone tracking. The API exposes endpoints for creating cycles, assigning issues, and fetching historical progress.
• Webhooks & Events: Developers can subscribe to events such as issue.created, cycle.completed, or module.updated via HTTP callbacks. A built‑in webhook dispatcher guarantees at‑least‑once delivery.
• Plugin Hooks: Plane exposes a lightweight plugin API that runs in the same process as the backend. Plugins can register custom endpoints, modify issue lifecycle events, or inject UI components into the React app.
• Search & Filters: Full‑text search powered by PostgreSQL’s tsvector, with advanced filtering on issue properties and cycle status.

Plane is designed for self‑hosting on any infrastructure that supports Docker or Kubernetes. The recommended stack includes:

1. Docker Compose – a single docker-compose.yml file that starts the API, frontend, PostgreSQL, Redis, and optional S3-compatible storage (MinIO).
2. Helm Charts – fully declarative deployments for Kubernetes, with separate values files for production and staging. The charts support horizontal pod autoscaling based on CPU/memory metrics.
3. CI/CD – the repository contains GitHub Actions that build Docker images, run tests, and push to a container registry. Developers can customize these workflows to fit their own pipelines.

Scalability is achieved by decoupling the WebSocket gateway from the API layer, allowing the latter to be horizontally scaled behind a load balancer. Redis streams ensure that notifications are delivered in order even across multiple instances.

• REST/GraphQL API: Full CRUD operations on all resources, with pagination and filtering. The GraphQL endpoint supports real‑time subscriptions over WebSocket.
• OAuth2 & SAML: Supports external identity providers for single‑sign‑on, which can be configured via environment variables or the admin UI.
• Custom Webhooks: Any external service (e.g., CI/CD pipelines, monitoring tools) can listen to events or trigger actions in Plane.
• SDKs: A lightweight TypeScript SDK is available on npm, simplifying client integration and providing typed request/response models.
• Plugin System: Plugins can add new UI panels, modify the data model, or expose additional REST endpoints. The plugin runtime is sandboxed using Go’s plugin package, ensuring isolation.

Plane’s documentation is hosted at docs.plane.so, offering a searchable API reference, deployment guides, and a plugin development tutorial. The community is active on Discord, where contributors discuss feature requests and debugging tips. Configuration is largely environment‑variable driven, making it easy to adapt to different hosting environments without code changes. The open‑source license (MIT) removes any vendor lock‑in, allowing developers to fork and customize the codebase as needed.

• Enterprise Self‑Hosting: Companies that require GDPR‑compliant data residency can deploy Plane on-premises, leveraging the full API for custom reporting.
• CI/CD Integration: Automate issue creation and status updates from pipelines by consuming the webhook API, enabling end‑to‑end visibility.
• Custom UI Extensions: Teams building internal tools can embed Plane’s issue board as a micro‑frontend or extend it with domain‑specific widgets via the plugin system.
• Education & Research: The event‑sourced architecture makes Plane a good testbed for studying distributed systems and audit logging.

• Performance: Go’s concurrency model and Redis streams provide low‑latency updates