# plane | Plane | Knowledge Base | Instagit

🔥🔥🔥 Open-source Jira, Linear, Monday, and ClickUp alternative. Plane is a modern project management platform to manage tasks, sprints, docs, and triage.

GitHub Stars: 51.8k

Repository: https://github.com/makeplane/plane

---

## Articles

### [How Logging Works in Plane: JSON Formatting, Custom Handlers, and Security](/makeplane/plane/what-kind-logging-implemented-plane)

Explore Plane's Python logging: JSON format, custom rotation, segregated loggers, and secure API token hashing. Understand how Plane logs effectively.

- Tags: internals
- Published: 2026-08-25

### [How to Run Plane in a Production-Like Environment: 3 Deployment Methods](/makeplane/plane/how-can-i-run-plane-production-like-environment)

Deploy Plane in a production-like environment using Docker Compose, Helm for Kubernetes, or an All-In-One script for easy setup. Get your Plane instance running efficiently.

- Tags: how-to-guide
- Published: 2026-08-25

### [Plane Deployment Strategy: A Complete Guide to Self-Hosting with Docker and Kubernetes](/makeplane/plane/what-is-deployment-strategy-plane)

Master Plane deployment strategy with Docker Compose, Docker Swarm, and Kubernetes. Self-host effectively using our comprehensive guide and versioned container images for seamless orchestration.

- Tags: how-to-guide
- Published: 2026-08-25

### [How Unit Tests Are Structured in the makeplane/plane Repository](/makeplane/plane/how-are-unit-tests-structured-makeplane-plane-repository)

Discover how unit tests are structured in the makeplane/plane repository. Learn about Vitest, co-located test files, and inline snapshot testing with TypeScript for robust assertions.

- Tags: how-to-guide
- Published: 2026-08-25

### [How to Contribute to makeplane/plane: A Complete Guide for Open Source Developers](/makeplane/plane/how-can-i-contribute-makeplane-plane-project)

Contribute to makeplane/plane easily. Fork the repo, set up locally with setup.sh, and submit pull requests following conventional commits and passing tests. Start contributing today.

- Tags: how-to-guide
- Published: 2026-08-25

### [Design Patterns Used in the Plane Codebase: A Technical Deep Dive](/makeplane/plane/are-there-specific-design-patterns-used-plane-codebase)

Explore seven design patterns like Decorator, Singleton, and Factory in the Plane codebase. Learn how they build a modular, type-safe architecture for HTTP handling, state management, and UI.

- Tags: deep-dive
- Published: 2026-08-25

### [How Plane Handles Authentication and Authorization: Django Sessions, CSRF Protection, and RBAC](/makeplane/plane/how-does-plane-handle-authentication-authorization)

Discover how Plane handles authentication and authorization with Django sessions, CSRF protection, and RBAC for secure access. Learn about its robust security features.

- Tags: deep-dive
- Published: 2026-08-25

### [What Database Technology Does Plane Use? PostgreSQL Configuration Explained](/makeplane/plane/what-database-technology-does-plane-use)

Discover how Plane leverages PostgreSQL as its core database. Learn about Django ORM configuration and essential environment variables for optimal performance. Get your setup right.

- Tags: deep-dive
- Published: 2026-08-25

### [Exploring the makeplane/plane Packages and Modules: A Complete Monorepo Guide](/makeplane/plane/are-there-separate-modules-packages-makeplane-plane)

Discover the makeplane/plane monorepo structure, featuring fourteen distinct packages and five applications, each with unique responsibilities and package.json manifests for organized development.

- Tags: deep-dive
- Published: 2026-08-25

### [How the Backend of Plane Is Developed and Organized](/makeplane/plane/how-is-backend-plane-developed-organized)

Discover how the Plane backend, a monolithic Django app, is developed and organized. Learn about its REST API, Celery background jobs, and domain-driven modules.

- Tags: architecture
- Published: 2026-08-25

### [Where to Find the Source Code for the Core Logic of Plane: A Complete Developer's Guide](/makeplane/plane/where-find-source-code-core-logic-plane)

Discover where the core logic source code for Plane lives. Navigate the Django backend, domain models, serializers, and view controllers in the makeplane/plane repository.

- Tags: how-to-guide
- Published: 2026-08-25

### [makeplane/plane Project Structure: A Complete Guide to the Monorepo Architecture](/makeplane/plane/how-is-makeplane-plane-project-structured)

Explore the makeplane/plane project structure. Discover how this pnpm monorepo organizes services in apps/ and libraries in packages/ for efficient development. Learn about its workspace setup.

- Tags: architecture
- Published: 2026-08-25

### [How to Contribute to Plane Project Development: A Complete Guide for Open-Source Contributors](/makeplane/plane/how-can-i-contribute-to-the-plane-project-development)

Learn how to contribute to Plane project development. Clone the monorepo, set up your environment, and start contributing to this open-source project with our complete guide.

- Tags: how-to-guide
- Published: 2026-08-23

### [Celery in Plane's Architecture: How the Open-Source Project Management Platform Handles Asynchronous Workflows](/makeplane/plane/what-is-the-role-of-celery-in-planes-architecture)

Discover how Plane leverages Celery for asynchronous workflows. See how this open-source platform handles background tasks like email, metrics, and maintenance for a smoother user experience.

- Tags: architecture
- Published: 2026-08-23

### [How Plane Abstracts Its API Client Services with APIService](/makeplane/plane/how-are-api-client-services-abstracted-in-plane)

Discover how Plane abstracts API client services using APIService. Learn to extend this base class for domain-specific endpoints and consistent request configuration.

- Tags: architecture
- Published: 2026-08-23

### [@plane/types Package: Complete Guide to TypeScript Types in Plane](/makeplane/plane/what-kind-of-types-are-defined-in-the-plane-types-package)

Explore the @plane/types package for over 50 domain-specific TypeScript types covering entities UI components integrations and utilities. Master Plane's type system.

- Tags: api-reference
- Published: 2026-08-23

### [How @plane/shared-state Manages MobX Stores: A Deep Dive into Plane's State Architecture](/makeplane/plane/how-does-the-plane-shared-state-package-manage-mobx-stores)

Discover how @plane/shared-state manages MobX stores with plain TypeScript classes, makeObservable, actions, and computed values for robust state architecture in Plane.

- Tags: deep-dive
- Published: 2026-08-23

### [What Is the @plane/ui Package? A Complete Guide to Plane's Shared UI Component Library](/makeplane/plane/what-is-the-function-of-the-plane-ui-package)

Discover the @plane/ui package, Plane's type-safe React component library. Ensure visual consistency across all front-end apps with reusable UI elements.

- Tags: deep-dive
- Published: 2026-08-23

### [What Are Modules in Plane's Project Management? Architecture, Implementation, and Usage](/makeplane/plane/what-is-the-purpose-of-modules-in-planes-project-management)

Understand Plane's project management modules. Learn how they group issues, track progress, and manage priorities for enhanced team workflow and better project organization.

- Tags: architecture
- Published: 2026-08-23

### [How Plane Manages Cycles for Sprint Planning: A Deep Dive into the Architecture](/makeplane/plane/how-does-plane-manage-cycles-for-sprint-planning)

Discover how Plane's three-layer architecture efficiently manages sprint cycles for planning. Learn about Django, TypeScript, and MobX for seamless synchronization and display.

- Tags: deep-dive
- Published: 2026-08-23

### [How Issues (Work Items) Are Structured in the Plane Database](/makeplane/plane/how-are-issues-work-items-structured-in-the-plane-database)

Discover how Plane structures work items as rich relational objects using the TBaseIssue interface. Learn about core attributes in issues_issue and auxiliary tables for relationships.

- Tags: internals
- Published: 2026-08-23

### [How Plane Implements Its Permission System: A Deep Dive into the Codebase](/makeplane/plane/how-does-plane-implement-its-permission-system)

Discover how Plane implements its type-safe, reactive permission system. Explore its codebase for details on enumerated roles, BaseUserPermissionStore, and USER_ALLOWED_PERMISSIONS map.

- Tags: deep-dive
- Published: 2026-08-23

### [How Serializers Are Used in the Plane API: A Complete DRF Implementation Guide](/makeplane/plane/how-are-serializers-used-in-the-plane-api)

Learn how Plane API uses Django REST Framework serializers for model-to-JSON conversion and input validation. Explore BaseSerializer and DynamicBaseSerializer classes.

- Tags: how-to-guide
- Published: 2026-08-23

### [Role of Django REST Framework in the Plane Backend: API Architecture Explained](/makeplane/plane/what-is-the-role-of-django-rest-framework-in-the-plane-backend)

Discover the role of Django REST Framework in the Plane backend. Learn how DRF powers API architecture, handling authentication, serialization, and permissions for seamless development.

- Tags: architecture
- Published: 2026-08-23

### [How Plane Handles API Data Fetching: Axios, Services, and MobX Stores](/makeplane/plane/how-does-plane-handle-api-data-fetching)

Discover how Plane fetches API data using Axios, domain-specific services, and MobX stores for efficient data flow and UI updates. Learn about their centralized APIService.

- Tags: internals
- Published: 2026-08-23

### [What Libraries Are Used for Real-Time Collaboration in Plane?](/makeplane/plane/what-libraries-are-used-for-real-time-collaboration-in-plane)

Discover the core libraries enabling real-time collaboration in Plane. Learn how Yjs, Hocuspocus, y-indexeddb, and Tiptap power seamless multi-user editing.

- Tags: internals
- Published: 2026-08-23

### [How the React Router Application Works in Plane’s Frontend: File-Based Routes, SSR, and MobX State Management](/makeplane/plane/how-does-the-react-router-application-work-in-planes-frontend)

Explore how Plane uses React Router v7 file-based routing, SSR with @react-router/node, and MobX for reactive URL state management in its frontend architecture.

- Tags: deep-dive
- Published: 2026-08-23

### [What Is the Purpose of the apps/api Directory in Plane? Understanding the Backend Architecture](/makeplane/plane/what-is-the-purpose-of-the-apps-api-directory-in-plane)

Explore the apps/api directory in Plane and understand its role as the backend API layer. Discover how it manages REST endpoints, background tasks, and more.

- Tags: architecture
- Published: 2026-08-23

### [Plane Monorepo Structure Explained: A Deep Dive into the pnpm Workspace Architecture](/makeplane/plane/how-is-the-plane-monorepo-structured)

Explore the Plane monorepo structure, a pnpm workspace organizing apps and packages. Understand how Next.js UI, Django API, and libraries interact in this architecture.

- Tags: internals
- Published: 2026-08-23

### [Core Technologies Used in the Plane Project: Full Stack Architecture](/makeplane/plane/what-are-the-core-technologies-used-in-the-plane-project)

Discover the core technologies behind the Plane project. Explore its TypeScript React monorepo, Python Django backend, Turborepo, MobX, and custom ProseMirror editor.

- Tags: architecture
- Published: 2026-08-23

### [How Plane Handles Internationalization (i18n): Architecture and Implementation](/makeplane/plane/plane-internationalization-i18n-setup)

Discover how Plane handles internationalization (i18n) using a dedicated package, i18next, and type-safe translations with dynamic JSON loading for a seamless global user experience.

- Tags: architecture
- Published: 2026-08-22

### [What Technology Powers the @plane/editor Package in Plane?](/makeplane/plane/plane-editor-package-technology-tip-tap)

Discover the core technologies behind the @plane/editor package in Plane. Built with TipTap, Yjs, and Floating UI, it delivers a powerful real-time rich-text editing experience.

- Tags: internals
- Published: 2026-08-22

### [What Is the @plane/services Package Used For? A Complete Guide to Plane’s API Client SDK](/makeplane/plane/plane-services-package-usage)

Discover the @plane/services package, Plane's typed client-side SDK. This guide explains how it simplifies interaction with the Plane backend REST API for workspaces, users, and authentication.

- Tags: api-reference
- Published: 2026-08-22

### [What Is the @plane/shared-state Package? Purpose and Implementation in Plane](/makeplane/plane/plane-shared-state-package-purpose)

Discover the purpose of @plane/shared-state, a MobX library centralizing reactive stores for consistent, type-safe frontend state management in Plane.

- Tags: deep-dive
- Published: 2026-08-22

### [How to Run API Tests in the Plane Backend: A Complete Docker Guide](/makeplane/plane/plane-api-testing-workflow)

Learn how to run API tests in the Plane backend using Docker. This guide details the Docker Compose setup for isolated testing with temporary databases and services.

- Tags: how-to-guide
- Published: 2026-08-22

### [How Plane Uses Redis: Real-Time Collaboration, Caching, and Background Jobs](/makeplane/plane/redis-usage-plane-architecture)

Discover how Plane leverages Redis for real-time collaboration, efficient caching of tokens and codes, and robust background job processing with Celery workers.

- Tags: internals
- Published: 2026-08-22

### [How Plane Handles Background Processing and Asynchronous Tasks Using Celery](/makeplane/plane/plane-background-processing-celery)

Discover how Plane manages background processing and asynchronous tasks using Celery with Redis, Django integration, and django-celery-beat for efficient scheduling. Learn about its robust architecture.

- Tags: internals
- Published: 2026-08-22

### [What Database Does Plane Use? PostgreSQL 15.7 Configuration and Setup](/makeplane/plane/plane-database-technology)

Discover that Plane uses PostgreSQL 15.7 as its database. Learn about its configuration and setup with Django for robust data management.

- Tags: database-configuration
- Published: 2026-08-22

### [How the Django Backend API is Organized in Plane](/makeplane/plane/plane-django-api-organization)

Explore the Django backend API organization in Plane. Discover how Plane uses a modular app-per-domain architecture for distinct namespaces and efficient CRUD operations.

- Tags: architecture
- Published: 2026-08-22

### [Plane API Backend Technology Stack: Django, DRF, and Production Infrastructure Explained](/makeplane/plane/plane-api-backend-tech-stack)

Discover the Plane API backend tech stack: Django, DRF, PostgreSQL, Redis, Celery, RabbitMQ, and S3. Learn about the technologies powering this open-source project.

- Tags: api-reference
- Published: 2026-08-22

### [Drag-and-Drop Libraries in the Plane UI: Inside the Pragmatic Drag-and-Drop Implementation](/makeplane/plane/plane-ui-drag-and-drop-libraries)

Discover the pragmatic drag and drop libraries powering Plane UI reordering. Learn how @atlaskit packages enable seamless Kanban boards, lists, and sidebar interactions.

- Tags: internals
- Published: 2026-08-22

### [What Is the Plane UI Component Library Built With? React, TypeScript, and Tailwind Architecture](/makeplane/plane/plane-ui-component-library-tech)

Discover the Plane UI component library's architecture. Built with React, TypeScript, and Tailwind CSS, it leverages Headless UI and Radix UI for accessible, composable elements.

- Tags: architecture
- Published: 2026-08-22

### [What Is the apps/proxy Function in Plane? The Caddy Reverse Proxy Explained](/makeplane/plane/plane-proxy-app-function)

Discover how the apps/proxy in Plane uses Caddy as a reverse proxy to manage external traffic, route requests to microservices, and handle automatic TLS termination for your applications.

- Tags: deep-dive
- Published: 2026-08-22

### [How the Plane Live Application Handles Real-Time Collaboration: Yjs CRDT Architecture](/makeplane/plane/plane-live-app-realtime-collaboration)

Discover how Plane uses Yjs CRDT architecture for seamless real-time collaboration. Experience conflict-free merging and offline-first sync.

- Tags: architecture
- Published: 2026-08-22

### [What Functionality Does the Plane Space Application Provide?](/makeplane/plane/plane-space-app-functionality)

Discover the Plane space application functionality. This React frontend for the open-source Plane project management platform offers issue tracking, sprint cycles, publishing workflows, and user management.

- Tags: overview
- Published: 2026-08-22

### [What Is the Plane Admin Application? A Complete Guide to Instance Management in Plane](/makeplane/plane/plane-admin-app-purpose)

Master Plane instance management with the Plane Admin application. Configure authentication, manage workspaces, and control policies for your entire deployment. Learn more.

- Tags: deep-dive
- Published: 2026-08-22

### [How Styling Is Handled in Plane Frontend Applications: The Tailwind-First Architecture](/makeplane/plane/plane-frontend-styling-tailwind)

Discover how Plane frontend apps use a Tailwind CSS-first architecture with a custom cn helper for streamlined, maintainable styling across all applications. Learn more!

- Tags: architecture
- Published: 2026-08-22

### [What Is the Role of SWR in the Plane Frontend?](/makeplane/plane/swr-usage-plane-frontend)

Discover how SWR powers the Plane frontend with efficient data fetching, automatic caching, and background revalidation. Optimize your app's performance with the useSWR hook.

- Tags: deep-dive
- Published: 2026-08-22

### [How State Is Managed in the Plane Frontend Applications](/makeplane/plane/plane-frontend-state-management)

Discover how Plane frontend applications manage state with a centralized MobX store architecture, leveraging React context and the observer pattern for reactive UI. Learn about SSR support.

- Tags: internals
- Published: 2026-08-22

### [Technologies Used in Plane Web Application (apps/web): Complete Tech Stack Breakdown](/makeplane/plane/plane-web-app-technologies)

Explore the Plane web application tech stack. Discover its TypeScript React frontend, Vite build tool, MobX state management, SWR data fetching, and Tailwind CSS.

- Tags: tech-stack-breakdown
- Published: 2026-08-22

### [Understanding the `packages/` Directory in the Plane Monorepo](/makeplane/plane/packages-directory-purpose-plane)

Discover the purpose of the packages/ directory in the Plane monorepo. Learn how it manages shared code libraries with pnpm workspaces for efficient development.

- Tags: internals
- Published: 2026-08-22

### [What Is the Purpose of the apps/ Directory in the Plane Monorepo?](/makeplane/plane/apps-directory-purpose-plane)

Discover the purpose of the apps/ directory in the Plane monorepo. It houses runnable projects like the web UI, admin console, and backend, forming the operational core of the product.

- Tags: internals
- Published: 2026-08-22

### [Plane Project Monorepo Structure: A Deep Dive into the pnpm and Turbo Architecture](/makeplane/plane/plane-monorepo-structure)

Explore the Plane project monorepo structure. Discover how pnpm and TurboRepo efficiently manage frontend apps, backend services, and shared TypeScript libraries in one repository.

- Tags: deep-dive
- Published: 2026-08-22

### [Build Scripts Available for makeplane/plane: Complete Guide to TurboRepo Workflows](/makeplane/plane/build-scripts-available-makeplane-plane)

Explore makeplane/plane's TurboRepo build scripts. Learn how to run root-level commands and app-specific scripts for efficient monorepo builds.

- Tags: how-to-guide
- Published: 2026-06-26

### [How to Suggest a Feature for makeplane/plane](/makeplane/plane/how-to-suggest-feature-makeplane-plane)

Suggest a new feature for makeplane/plane by opening a GitHub issue. Use the feature request template for faster triage and proper labeling.

- Tags: how-to-guide
- Published: 2026-06-26

### [How Monorepo Tooling Works in Plane: pnpm Workspaces and TurboRepo Architecture](/makeplane/plane/monorepo-tooling-in-makeplane-plane)

Discover how Plane uses pnpm workspaces and TurboRepo for efficient monorepo management, ensuring fast builds and unified dependencies across all projects.

- Tags: internals
- Published: 2026-06-26

### [Dependencies for Each Package in Makeplane Plane: Complete Monorepo Guide](/makeplane/plane/dependencies-for-makeplane-plane-packages)

Discover dependencies for each package in the makeplane/plane monorepo. Learn how packages declare runtime and dev dependencies using workspace and catalog versions.

- Tags: how-to-guide
- Published: 2026-06-26

### [Where to Find makeplane/plane Documentation: Official Guides and Source Links](/makeplane/plane/documentation-for-makeplane-plane)

Find official makeplane/plane documentation easily. Access product guides, developer resources, and self-hosting instructions directly from the README.md file.

- Tags: getting-started
- Published: 2026-06-26

### [Purpose of the Apps Directory in makeplane/plane: Monorepo Architecture Explained](/makeplane/plane/purpose-of-apps-directory-makeplane-plane)

Discover the purpose of the apps directory in makeplane/plane. This monorepo structure houses all runnable applications, from the web frontend to the API, explaining their interconnected roles.

- Tags: architecture
- Published: 2026-06-26

### [What Is the Purpose of the `packages` Directory in makeplane/plane?](/makeplane/plane/purpose-of-packages-directory-makeplane-plane)

Explore the purpose of the packages directory in makeplane/plane. Discover how this modular backbone houses reusable npm packages for shared functionality across Plane's applications.

- Tags: internals
- Published: 2026-06-26

### [How to Set Up the Development Environment for Plane (makeplane/plane)](/makeplane/plane/setup-development-environment-makeplane-plane)

Easily set up the Plane development environment with our simple setup script. Launch Docker containers and Node.js services to access your Plane application quickly.

- Tags: how-to-guide
- Published: 2026-06-26

### [What Technologies Are Used in the Makeplane/Plane Project?](/makeplane/plane/technologies-used-in-makeplane-plane-project)

Explore the technologies behind the makeplane/plane project. Discover its React TypeScript frontend Vite Tailwind CSS, Python Django backend PostgreSQL Redis, and Docker Kubernetes deployment.

- Tags: internals
- Published: 2026-06-26

### [Plane Contribution Guide: How to Contribute to the makeplane/plane Monorepo](/makeplane/plane/contribution-guide-for-makeplane-plane)

New to makeplane/plane? Discover our comprehensive contribution guide detailing Docker-first development, coding standards, and the full PR process for our Django and React monorepo.

- Tags: contribution-guide
- Published: 2026-06-26

### [Applications in the makeplane/plane Monorepo: Complete Guide to the 6 Core Apps](/makeplane/plane/applications-in-makeplane-plane-monorepo)

Explore the 6 core applications in the makeplane/plane monorepo Web Admin API Live Space and Proxy. Discover their independent capabilities and configurations in this complete guide.

- Tags: deep-dive
- Published: 2026-06-26

### [Understanding the Tests Directory in makeplane/plane: Purpose and Structure](/makeplane/plane/function-tests-directory-makeplane-plane)

Explore the tests directory in makeplane/plane. Learn how its automated test suite ensures backend API correctness, stability, and security via unit, contract, and smoke tests.

- Tags: internals
- Published: 2026-06-25

### [How Makeplane Plane Manages Its Monorepo with Turborepo and pnpm](/makeplane/plane/monorepo-management-makeplane-plane)

Discover how Makeplane Plane manages its monorepo using Turborepo and pnpm. Learn about their app and package structure for efficient development and caching.

- Tags: how-to-guide
- Published: 2026-06-25

### [Independent Modules and Libraries in the makeplane/plane Packages Directory](/makeplane/plane/independent-modules-libraries-packages-directory-makeplane-plane)

Discover the 15 independent, versioned libraries within the makeplane/plane packages directory. Import utilities, UI components, and more via the @plane namespace.

- Tags: internals
- Published: 2026-06-25

### [What Is the Purpose of the `packages` Directory in makeplane/plane?](/makeplane/plane/purpose-packages-directory-makeplane-plane)

Discover the purpose of the packages directory in makeplane/plane. This directory holds independent npm modules, crucial for Plane's monorepo, promoting code reuse and efficient dependency management across applications.

- Tags: internals
- Published: 2026-06-25

### [How Components Are Managed in the Plane Frontend: Inside the @plane/ui Monorepo Architecture](/makeplane/plane/component-management-makeplane-plane-frontend)

Discover how the @plane/ui monorepo architecture manages React components in the Plane frontend. Learn about pnpm, path aliasing, and efficient UI imports for multiple applications.

- Tags: internals
- Published: 2026-06-25

### [UI Framework Used in the Web Directory of Makeplane/Plane: React, Tailwind, and @plane/ui](/makeplane/plane/ui-framework-used-web-directory-makeplane-plane)

Discover the UI framework in makeplane/plane's web directory. Explore React, Tailwind CSS, and the internal @plane/ui component library for efficient web development.

- Tags: architecture
- Published: 2026-06-25

### [What Is the Web Directory in makeplane/plane? A Complete Guide to the Plane Frontend](/makeplane/plane/purpose-web-directory-makeplane-plane)

Explore the web directory in makeplane/plane, the client-side React app handling routing, state, API calls, and UI. Understand the Plane frontend with this complete guide.

- Tags: deep-dive
- Published: 2026-06-25

### [What Is the Common Directory in Plane? A Deep Dive into makeplane/plane's Shared Architecture](/makeplane/plane/purpose-common-directory-makeplane-plane)

Discover the purpose of the common directory in makeplane/plane. Learn how this shared architecture centralizes UI components and utilities for efficiency and consistency across modules.

- Tags: deep-dive
- Published: 2026-06-25

### [Database Migration Scripts in the Plane Repository: Location and Usage Guide](/makeplane/plane/database-migration-scripts-makeplane-plane-repository)

Find database migration scripts in the makeplane/plane repository. Learn their location and how to use them for your project. Essential guide for developers.

- Tags: how-to-guide
- Published: 2026-06-25

### [Backend Technologies Used in makeplane/plane: A Deep Dive into the Django API Stack](/makeplane/plane/technologies-used-backend-makeplane-plane)

Explore the Django API stack powering makeplane/plane. Discover its use of Django REST Framework, PostgreSQL, Redis, Celery, and Docker for a robust backend.

- Tags: deep-dive
- Published: 2026-06-25

### [Role of the Backend Directory in makeplane/plane: Django API Architecture](/makeplane/plane/role-backend-directory-makeplane-plane)

Discover the role of the backend directory in makeplane/plane. Learn how this Django API handles data persistence, business logic, authentication, and background tasks for project management.

- Tags: internals
- Published: 2026-06-25

### [Frontend Application in the makeplane/plane Repository: Architecture and Setup Guide](/makeplane/plane/frontend-application-makeplane-plane-repository)

Explore the React frontend application in makeplane/plane. Discover its Vite, React Router, and MobX architecture. Set up your development environment easily.

- Tags: architecture
- Published: 2026-06-25

### [What Files Are in the Apps Directory of makeplane/plane? A Complete Guide to the Monorepo Structure](/makeplane/plane/files-in-apps-directory-makeplane-plane)

Explore the makeplane/plane apps directory. Learn about the web, admin, and live applications, their Vite configs, TypeScript code, MobX stores, and static assets powering Plane's frontend.

- Tags: how-to-guide
- Published: 2026-06-25

### [Purpose of the Apps Directory in makeplane/plane: Monorepo Architecture Explained](/makeplane/plane/purpose-apps-directory-makeplane-plane)

Discover the purpose of the apps directory in the makeplane/plane monorepo. Understand how it organizes web frontend, backend, and microservices for shared code.

- Tags: architecture
- Published: 2026-06-25

### [What Programming Language is makeplane/plane Written In?](/makeplane/plane/what-programming-language-makeplane-plane-written-in)

Discover the programming languages behind MakePlane Plane. Explore the Python backend with Django and the TypeScript frontend with React

- Tags: programming-language-info
- Published: 2026-06-25

### [How Plane Implements Workspace Invitation and Member Management: Backend Models, Celery Tasks, and MobX State](/makeplane/plane/plane-workspace-invitation-member-management)

Learn how Plane implements workspace invitation and member management using Django models, Celery tasks, and MobX for frontend state. Discover the backend architecture and reactive state management.

- Tags: internals
- Published: 2026-06-23

### [WebSocket Communication Patterns for Real-Time Updates in Plane](/makeplane/plane/websocket-communication-patterns-real-time-updates)

Discover Plane's three-layer WebSocket architecture for real-time updates combining Express-WS Yjs synchronization and HTTP fallback. Learn efficient communication patterns.

- Tags: architecture
- Published: 2026-06-23

### [Issue Archival and Restore System in Plane: Technical Implementation Guide](/makeplane/plane/plane-issue-archival-restore-system)

Learn how Plane's issue archival and restore system works using a soft-delete mechanism with a nullable archived_at timestamp. Archive and restore issues easily with POST and DELETE requests.

- Tags: internals
- Published: 2026-06-23

### [How Plane Handles File Attachments and Storage: A Complete Architecture Guide](/makeplane/plane/plane-file-attachments-storage-architecture)

Explore Plane's architecture for file attachments and storage. Learn how signed URLs stream uploads directly to object storage, separating payload handling from metadata management.

- Tags: architecture
- Published: 2026-06-23

### [How Plane Calculates Analytics and Burndown Charts: Server-Side Architecture Explained](/makeplane/plane/plane-analytics-burndown-chart-calculations)

Discover how Plane calculates analytics and burndown charts. Explore the server-side architecture and Python utilities that aggregate issue data and track remaining work over time.

- Tags: architecture
- Published: 2026-06-23

### [How Plane Handles Workspace-Level vs Project-Level Settings and Permissions](/makeplane/plane/plane-workspace-project-settings-permissions)

Understand how Plane separates workspace and project settings and permissions. Learn about its hierarchical access control enforcing strict control over your Plane projects.

- Tags: architecture
- Published: 2026-06-23

### [Architecture of the Hocuspocus Collaborative Server in Plane: A Technical Deep Dive](/makeplane/plane/hocuspocus-collaborative-server-architecture)

Explore the Hocuspocus collaborative server architecture in Plane. Understand its singleton manager pattern, Express/WebSocket stack, and modular pipeline for real-time editing.

- Tags: architecture
- Published: 2026-06-23

### [Database Migration Strategy for Plane's Django ORM Models: A Complete Technical Guide](/makeplane/plane/database-migration-strategy-django-orm)

Learn Plane's Django ORM database migration strategy. Discover how they use Django migrations and a custom router to manage schema changes on the primary database and optimize read replicas for queries.

- Tags: how-to-guide
- Published: 2026-06-23

### [Pytest Testing Conventions and Fixtures in the Plane Django API: A Complete Guide](/makeplane/plane/pytest-testing-conventions-fixtures-django-api)

Explore pytest testing conventions and fixtures used in the Plane Django API for robust database isolation, authenticated clients, and service mocking across test layers.

- Tags: testing
- Published: 2026-06-23

### [How Plane Organizes Apps and Packages in Its PNPM Monorepo Workspace](/makeplane/plane/pnpm-monorepo-workspace-structure-apps-packages)

Understand how Plane organizes its pnpm monorepo workspace. Discover how apps and packages are structured within the codebase and learn how non-Node.js services are managed.

- Tags: internals
- Published: 2026-06-23

### [Redis Caching Strategy in the Plane Backend: Architecture and Implementation](/makeplane/plane/redis-caching-strategy-plane-backend)

Discover Plane's dual-layer Redis caching strategy. Learn how it uses django-redis and a raw client for HTTP responses, queries, real-time features, and background tasks. Optimize your backend.

- Tags: architecture
- Published: 2026-06-23

### [How Plane's Custom Views and Filtering System Works Under the Hood: A Technical Deep Dive](/makeplane/plane/plane-custom-views-filtering-system)

Explore how Plane's custom Views and filtering system work. Learn about persistent JSON filter trees and the reactive UI powered by a MobX tree.

- Tags: deep-dive
- Published: 2026-06-23

### [Docker and Kubernetes Deployment Architecture for Self-Hosting Plane](/makeplane/plane/docker-kubernetes-deployment-self-hosting-plane)

Explore the Docker and Kubernetes deployment architecture for self-hosting Plane. Discover its microservices, background workers, and infrastructure components for seamless deployment.

- Tags: architecture
- Published: 2026-06-23

### [How the TipTap Rich Text Editor Integrates with the Backend for Document Storage in Plane](/makeplane/plane/tiptap-rich-text-editor-backend-integration)

Discover how Plane's TipTap rich text editor integrates with PostgreSQL for efficient, collaborative document storage using Yjs CRDT.

- Tags: internals
- Published: 2026-06-23

### [How Cycles and Modules Differ in Plane's Project Management Model](/makeplane/plane/plane-cycles-vs-modules-project-management)

Understand the key differences between Cycles and Modules in Plane's project management. Learn how time-boxed sprints and feature groupings impact your workflow and issue assignments.

- Tags: deep-dive
- Published: 2026-06-23

### [Plane Django API Backend Architecture: A Deep Dive into Service Layers and Code Organization](/makeplane/plane/django-api-backend-architecture-services)

Explore the modular Django API backend architecture of Plane and its distinct service layers. Understand routing, business logic, and data access within the makeplane repository for efficient development.

- Tags: architecture
- Published: 2026-06-23

### [Plane REST API Endpoints for Creating, Updating, and Managing Work Items (Issues)](/makeplane/plane/rest-api-endpoints-issues-management)

Explore the Plane REST API for managing work items. Discover endpoints to create, update, list, retrieve, patch, and delete issues within your workspace projects.

- Tags: api-reference
- Published: 2026-06-23

### [How the MobX State Management System Works in Plane Frontend Applications](/makeplane/plane/mobx-state-management-plane-frontend)

Understand MobX state management in Plane frontend apps. Explore its root store, observable state, actions, and observer HOC for efficient, boilerplate-free UI updates.

- Tags: internals
- Published: 2026-06-23

### [Django Database Schema Architecture for Workspaces, Projects, and Issues in Plane](/makeplane/plane/django-database-schema-workspaces-projects-issues)

Discover the Django database schema architecture for Workspaces, Projects, and Issues in Plane. Learn how it ensures data integrity with abstract models and composite constraints.

- Tags: architecture
- Published: 2026-06-23

### [How Plane Implements Real-Time Collaboration with Hocuspocus and Yjs](/makeplane/plane/how-plane-real-time-collaboration-hocuspocus-yjs)

Discover how Plane uses Hocuspocus and Yjs for real-time collaboration. Learn about CRDT documents, WebSocket providers, and offline caching for seamless editing.

- Tags: internals
- Published: 2026-06-23

### [Plane i18n Architecture Using i18next: Translation Structure and Implementation](/makeplane/plane/what-is-i18n-architecture-i18next-how-translations-structured)

Discover Plane's i18n architecture using i18next. Learn how translations are structured and implemented with automatic TypeScript generation for type-safe internationalization.

- Tags: architecture
- Published: 2026-06-22

### [How the React Router Layout System Handles Workspace/Project Routing in Plane](/makeplane/plane/how-does-react-router-layout-system-handle-workspace-project-routing)

Discover how Plane's React Router v6 layout system uses Next.js dynamic segments to manage workspace and project routing, centralizing state with RouterStore for seamless navigation.

- Tags: internals
- Published: 2026-06-22

### [Plane Analytics and User Activity Tracking Architecture Explained](/makeplane/plane/what-is-architecture-analytics-user-activity-tracking)

Discover the dual-layered architecture of Plane analytics and user activity tracking. Learn how React/MobX frontend and Django backend handle data aggregation and event processing.

- Tags: architecture
- Published: 2026-06-22

### [Data Model for User Favorites and Recent Visits in Plane: Architecture Guide](/makeplane/plane/what-is-data-model-user-favorites-recent-visits)

Discover the data model for user favorites and recent visits in Plane. Learn about its hierarchical JSON and PostgreSQL architecture for efficient UI state management.

- Tags: architecture
- Published: 2026-06-22

### [How the Plane Admin Panel Manages Instance-Level Settings: Architecture and Implementation](/makeplane/plane/how-does-admin-panel-manage-instance-level-settings)

Learn how the Plane admin panel efficiently manages instance level settings using a reactive MobX store and a REST service layer for seamless configuration updates via the UI.

- Tags: architecture
- Published: 2026-06-22

### [How the Plane Notification System Works Across Workspaces and Projects](/makeplane/plane/how-does-notification-system-work-across-workspaces-projects)

Discover how Plane's notification system uses Django, REST APIs, and a TypeScript frontend to deliver real-time workspace-specific alerts with project-level filtering. Understand its architecture.

- Tags: internals
- Published: 2026-06-22

### [How Plane's View System for Saved Filters and Custom Queries Works](/makeplane/plane/what-is-structure-view-system-saved-filters-custom-queries)

Explore Plane's View system architecture. Learn how saved filters and custom queries are managed using a three-layer approach with Django, MobX, and UI components for efficient issue tracking.

- Tags: internals
- Published: 2026-06-22

### [Workspace-Level Labels and Estimates Architecture in Plane: Backend and Frontend Deep Dive](/makeplane/plane/what-is-architecture-workspace-level-labels-estimates)

Explore the architecture of workspace-level labels and estimates in Plane. Discover how Django models, REST APIs, and React/MobX work together for efficient data management and UI rendering.

- Tags: deep-dive
- Published: 2026-06-22

### [How Workspace Invitations and Member Onboarding Work in Plane](/makeplane/plane/how-does-workspace-invitations-member-onboarding-flow-work)

Learn how Plane handles workspace invitations and member onboarding with the WorkspaceInvitationService. Effortlessly invite users, manage pending invites, and onboard new team members smoothly.

- Tags: how-to-guide
- Published: 2026-06-22

### [MobX Store Architecture for Global State Management in Plane](/makeplane/plane/what-is-mobx-store-architecture-global-state-management-frontend)

Explore the MobX store architecture for global state management in Plane. Learn how CoreRootStore aggregates feature stores via StoreContext for efficient frontend state handling.

- Tags: architecture
- Published: 2026-06-22

### [Celery Task Queue Architecture for Background Jobs in the Plane API](/makeplane/plane/what-is-celery-task-queue-architecture-background-jobs-api)

Understand the Celery task queue architecture powering Plane API background jobs. Explore its modular design with RabbitMQ, Django ORM, and `@shared_task` for efficient async execution.

- Tags: architecture
- Published: 2026-06-22

### [How Custom Issue Properties and Workspace-Level States Work in Plane's Data Model](/makeplane/plane/how-do-custom-issue-properties-workspace-states-work-data-model)

Understand Plane's data model for custom issue properties and workspace-level states. Learn how JSON schema and state groups manage your workflows efficiently.

- Tags: internals
- Published: 2026-06-22

### [Plane Cycle (Sprint) Architecture and Burndown Chart Calculation](/makeplane/plane/what-is-cycle-sprint-feature-architecture-burndown-charts-calculated)

Discover the Plane Cycle (Sprint) architecture, from React frontend to Django backend. Learn how burndown charts calculate progress by tracking completed issues against total scope daily.

- Tags: architecture
- Published: 2026-06-22

### [How Workspace-Level Permissions and Role-Based Access Control Work in Plane's Django API](/makeplane/plane/how-are-workspace-level-permissions-rbac-implemented-django-api)

Learn how Plane's Django API implements workspace-level permissions and role-based access control using integer-based role storage and DRF BasePermission subclasses for secure API access.

- Tags: deep-dive
- Published: 2026-06-22

### [How Plane Implements Real-Time Collaboration Using Yjs and Hocuspocus WebSockets](/makeplane/plane/how-plane-implements-real-time-collaboration-yjs-hocuspocus-websockets)

Discover how Plane uses Yjs and Hocuspocus WebSockets for real-time collaboration. Learn about CRDTs, conflict resolution, and seamless network transport for your projects.

- Tags: how-to-guide
- Published: 2026-06-22

### [How to Run Plane’s Test Suite Using docker-compose-test.yml with pytest and Django Factories](/makeplane/plane/how-test-suite-runs-with-docker-compose-test-yml-using-pytest-and-django-factories)

Learn to run Plane's test suite using docker-compose-test.yml. This guide explains how pytest and Django factories orchestrate PostgreSQL, Redis, RabbitMQ, and MinIO for seamless testing.

- Tags: how-to-guide
- Published: 2026-06-22

### [React Component Theming: How Plane Implements Dark/Light Modes with CSS Variables and Tailwind](/makeplane/plane/how-react-component-theming-supports-dark-light-modes-with-css-variables-and-tailwind)

Discover how Plane implements React component theming for dark/light modes using CSS variables and Tailwind. Learn their innovative approach to style switching.

- Tags: how-to-guide
- Published: 2026-06-22

### [How Plane Implements Issue Archiving with Soft-Delete and Restore Functionality](/makeplane/plane/how-api-implements-issue-archiving-with-soft-delete-and-restore-functionality)

Discover how Plane archives issues using soft-delete and restore functionality. Learn how the archived_at field preserves data for restoration and audit trails.

- Tags: internals
- Published: 2026-06-22

### [How Plane Uses Celery Tasks to Handle Asynchronous Operations: Notifications, Exports, and Email](/makeplane/plane/how-celery-tasks-handle-async-operations-like-notifications-exports-and-email)

Discover how Plane leverages Celery tasks for asynchronous operations like notifications, exports, and email. Learn about beat scheduler and Redis locks to optimize background jobs.

- Tags: internals
- Published: 2026-06-22

### [How Plane Page Hierarchies Support Nested Documents and AI Capabilities](/makeplane/plane/how-page-hierarchies-support-nested-documents-with-ai-capabilities-integration)

Discover how Plane's page hierarchies enable nested documents and AI capabilities. Learn about its Django model, REST endpoints, and AI integration for context-aware menus. Explore Plane today!

- Tags: deep-dive
- Published: 2026-06-22

### [How Plane's i18n System Supports Multiple Locales Using next-i18next and react-i18next](/makeplane/plane/how-i18n-system-supports-multiple-locales-with-next-i18next-and-react-i18next)

Discover how Plane's i18n system uses next-i18next and react-i18next to seamlessly support multiple locales. Learn about automatic language switching and efficient translation management.

- Tags: how-to-guide
- Published: 2026-06-22

### [How Plane's Authentication System Works: Session Management, API Keys, and Token Refresh](/makeplane/plane/how-authentication-system-works-including-token-refresh-and-session-management)

Discover how Plane's authentication works with session cookies, API keys, and magic links. Learn about its robust session management and unique token approach for secure access.

- Tags: deep-dive
- Published: 2026-06-22

### [How Workspace Views Support Custom Filters, Sorting, and Saved Filter Persistence in Plane](/makeplane/plane/how-workspace-views-support-custom-filters-sorting-and-saved-filter-persistence)

Learn how Plane's workspace views empower custom filters, sorting, and saved filter persistence. Explore Plane's three-layer data model for advanced query logic and UI state restoration.

- Tags: deep-dive
- Published: 2026-06-22

### [How Plane Implements Label Management with Bulk Operations Across Projects](/makeplane/plane/how-api-implements-label-management-with-bulk-operations-across-projects)

Learn how Plane's API efficiently manages labels with bulk operations across projects. Discover its robust bulk-create endpoint, Django integration, and permission enforcement.

- Tags: api-reference
- Published: 2026-06-22

### [How Plane Differentiates Between Server State and Client State: SWR vs MobX Architecture](/makeplane/plane/how-state-management-differentiates-between-server-state-and-client-state)

Discover how Plane's architecture separates server state with SWR from client state with MobX. Learn about their distinct roles in managing remote data and local UI.

- Tags: architecture
- Published: 2026-06-22

### [How React Router Manages SPA Routing with Nested Layouts and Authenticated Routes in Plane](/makeplane/plane/how-react-router-handles-spa-routing-with-nested-layouts-and-authenticated-routes)

Learn how Plane uses React Router v6 for SPA routing. Discover nested layouts with Outlet and authentication wrappers for secure access.

- Tags: internals
- Published: 2026-06-22

### [How Plane Module Management Groups Related Issues Across Cycles and Tracks Dependencies](/makeplane/plane/how-module-management-groups-related-issues-across-cycles-and-tracks-dependencies)

Discover how Plane's module management groups related issues and tracks dependencies using a hierarchical data model and smart linking for cross-dimensional filtering.

- Tags: how-to-guide
- Published: 2026-06-22

### [How File Attachments Work in Plane: Storage, Size Limits, and API Endpoints](/makeplane/plane/how-file-attachments-are-handled-including-size-limits-storage-backend-and-api-endpoints)

Explore how Plane handles file attachments. Learn about storage options S3 Azure Blob local disk size limits and API endpoints for efficient file management.

- Tags: how-to-guide
- Published: 2026-06-22

### [How to Set Up Plane for Local Development Using Docker-Compose and the PNPM Monorepo](/makeplane/plane/how-to-set-up-plane-for-local-development-using-docker-compose-and-pnpm-monorepo)

Learn to set up Plane for local development with Docker Compose and PNPM monorepo. Easily launch the backend and frontend servers in minutes for a smooth workflow.

- Tags: how-to-guide
- Published: 2026-06-22

### [How Burndown Charts and Progress Metrics Are Calculated in Plane's Cycle Management](/makeplane/plane/how-plane-s-cycle-management-calculates-burndown-charts-and-progress-metrics)

Discover how Plane calculates burndown charts and progress metrics for effective cycle management. Understand your sprint progress with daily completions and ideal linear lines.

- Tags: internals
- Published: 2026-06-22

### [How the Plane React Frontend Manages Global State Using MobX Stores](/makeplane/plane/how-react-frontend-manages-global-state-using-mobx-stores)

Explore how the Plane React frontend uses MobX stores from shared-state to manage global state, integrating React Context and the observer pattern for efficient reactivity.

- Tags: deep-dive
- Published: 2026-06-22

### [How to Configure Custom Webhooks for Project and Issue Events in Plane](/makeplane/plane/how-to-configure-custom-webhooks-for-project-and-issue-events-in-plane)

Learn to configure custom webhooks for project and issue events in Plane. Easily set up real-time notifications for your development workflow via the API or UI.

- Tags: how-to-guide
- Published: 2026-06-22

### [How Plane Handles Workspace-Level Permission Checks and Authorization in Django](/makeplane/plane/how-django-backend-handles-workspace-level-permission-checks-and-authorization)

Discover how the Plane Django backend secures workspaces with DRF custom permission classes and WorkspaceMember model checks. Learn about authorization and user roles.

- Tags: architecture
- Published: 2026-06-22

### [How Plane Implements Real-Time Collaborative Document Editing Using Tiptap and Hocuspocus](/makeplane/plane/how-plane-implements-real-time-collaborative-document-editing-with-tiptap-and-hocuspocus)

Learn how Plane achieves real-time collaborative document editing with Tiptap and Hocuspocus. Discover its conflict-free concurrent editing and automatic reconnection features.

- Tags: internals
- Published: 2026-06-22

### [How to Manage User Roles and Permissions in Plane: A Complete Guide](/makeplane/plane/how-to-manage-user-roles-and-permissions-in-plane)

Master user roles and permissions in Plane. Learn how Plane enforces access control with enums and Django permission classes for robust security. 

- Tags: how-to-guide
- Published: 2026-06-20

### [What Background Jobs Does Plane Support? A Complete Guide to Celery Tasks in Plane](/makeplane/plane/what-kind-of-background-jobs-does-plane-support)

Explore background job support in Plane, including Celery tasks, asynchronous jobs, and soft-delete utilities. Understand how Plane handles background processes efficiently.

- Tags: how-to-guide
- Published: 2026-06-20

### [How the Frontend is Developed in the Plane Project: React, MobX, and Monorepo Architecture](/makeplane/plane/how-is-frontend-developed-in-plane-project)

Explore the Plane frontend development with React 18, MobX state management, and Turborepo monorepo architecture. Learn about routing, UI components, and Tailwind CSS.

- Tags: architecture
- Published: 2026-06-20

### [Can Plane Be Extended with Custom Plugins? A Guide to TipTap Extensions](/makeplane/plane/can-plane-be-extended-with-custom-plugins)

Yes Plane supports custom plugins using TipTap extensions. Learn how to pass custom extensions via the extensions prop in the @plane/editor package to enhance your Plane editor.

- Tags: how-to-guide
- Published: 2026-06-20

### [Where Are the Backend Services Located in the Plane Project Structure?](/makeplane/plane/where-are-backend-services-located-in-plane-project-structure)

Discover where backend services are in the Plane project structure. Explore the Django REST API in apps/api and the TypeScript service layer in packages/services for efficient development.

- Tags: internals
- Published: 2026-06-20

### [How to Use the Plane API: A Complete Guide to REST Integration](/makeplane/plane/how-to-use-api-provided-by-plane)

Incorporate the Plane API into your projects with this comprehensive guide. Learn how to generate API keys, authenticate requests, and integrate REST endpoints for seamless workflow automation.

- Tags: api-reference
- Published: 2026-06-20

### [What Are the Different Modules and Applications Within Plane? A Complete Architecture Guide](/makeplane/plane/what-are-different-modules-or-applications-within-plane)

Explore the distinct modules and applications within the Plane monorepo. Understand how apps/ and packages/ work together to create a unified project management platform.

- Tags: architecture
- Published: 2026-06-20

### [How to Configure Plane Settings: Complete Guide to Instance, Workspace, and Profile Management](/makeplane/plane/how-to-configure-plane-settings)

Learn to configure Plane settings for Instance, Workspace, and Profile management. Our guide covers UI and API configurations for seamless operation.

- Tags: how-to-guide
- Published: 2026-06-20

### [What Are the System Requirements to Run Plane? A Complete Hardware and Software Guide](/makeplane/plane/what-are-system-requirements-to-run-plane)

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.

- Tags: getting-started
- Published: 2026-06-20

### [How to Report a Bug or Issue in Plane: Complete Guide](/makeplane/plane/how-to-report-bug-or-issue-in-plane)

Learn how to report bugs in Plane. Search existing issues and use the GitHub bug report template with a minimal reproduction scenario for quick resolution.

- Tags: how-to-guide
- Published: 2026-06-20

### [Plane Project Roadmap: Public Kanban Board and Upcoming Features](/makeplane/plane/what-is-project-roadmap-for-plane)

Explore the Plane project roadmap on its public Kanban board. See upcoming features like timeline views, analytics, and AI pages synchronized with the repository issues.

- Tags: roadmap
- Published: 2026-06-20

### [How to Run Tests in the makeplane/plane Repository: Complete Guide](/makeplane/plane/how-to-run-tests-in-makeplane-plane-repository)

Master running tests in the makeplane/plane repository. This guide details pytest unit, contract, and smoke tests for Django backend services. Execute tests easily with standard commands or our helper script.

- Tags: how-to-guide
- Published: 2026-06-20

### [Database Requirements for Plane: PostgreSQL Configuration Guide](/makeplane/plane/what-are-database-requirements-for-plane)

Discover PostgreSQL database requirements for Plane, including version compatibility and environment variable configuration. Set up your Plane instance efficiently.

- Tags: configuration-guide
- Published: 2026-06-20

### [How to Integrate Plane with Other Tools: A Complete Guide to Workspace Integrations](/makeplane/plane/how-to-integrate-plane-with-other-tools)

Integrate Plane with other tools easily using its workspace-level model and REST endpoints. Enhance your workflow with seamless integrations. Learn how today.

- Tags: how-to-guide
- Published: 2026-06-20

### [How to Deploy Plane: Complete Guide to Self-Hosting Deployment Options](/makeplane/plane/what-are-deployment-options-for-plane)

Discover Plane deployment options: Docker Compose, Kubernetes, Swarm, all-in-one Docker, and CLI installer. Self-host Plane easily with this complete guide.

- Tags: how-to-guide
- Published: 2026-06-20

### [How to Install Plane on a Server: Complete Self-Hosting Guide](/makeplane/plane/how-to-install-plane-on-server)

Install Plane on your server with our complete self-hosting guide. Learn to deploy using Docker Compose or Kubernetes for effortless self-hosting.

- Tags: how-to-guide
- Published: 2026-06-20

### [Is Plane Open Source? License, Source Code, and Self-Hosting Guide](/makeplane/plane/is-plane-open-source-what-is-its-license)

Discover if Plane is open source. Learn about its AGPL-3.0 license, access the makeplane/plane repository, and get a guide for self-hosting this powerful tool.

- Tags: getting-started
- Published: 2026-06-19

### [How Plane's Authentication System Works: Backend and Frontend Implementation](/makeplane/plane/how-does-authentication-system-work-in-plane)

Discover how Plane's robust authentication system works. Explore backend API key validation and frontend session management, including magic links and OAuth.

- Tags: internals
- Published: 2026-06-19

### [Key Features of the Plane Application: A Technical Guide to the Open-Source Project Management Platform](/makeplane/plane/what-are-key-features-of-plane-application)

Explore the key features of the Plane application, an open-source project management platform. Discover its work tracking, sprint cycles, analytics, and self-hosting capabilities.

- Tags: deep-dive
- Published: 2026-06-19

### [Where to Find Documentation for makeplane/plane: Official Links and Repository Guide](/makeplane/plane/where-can-i-find-documentation-makeplane-plane)

Find official documentation for makeplane/plane. Access product docs, developer guides, and self-hosting instructions directly from the GitHub repo README. Get started now.

- Tags: getting-started
- Published: 2026-06-19

### [How to Contribute to the makeplane/plane Project: A Complete Developer's Guide](/makeplane/plane/how-to-contribute-to-makeplane-plane-project)

Learn how to contribute to the makeplane/plane project. Follow this developer's guide to clone the repo, set up your environment, and launch the application.

- Tags: how-to-guide
- Published: 2026-06-19

### [Technologies Used in the Makeplane Plane Project: Complete Stack Breakdown](/makeplane/plane/what-technologies-are-used-in-makeplane-plane-project)

Explore the makeplane plane project's tech stack: React, TypeScript, Vite, Tailwind CSS, Django, Python, PostgreSQL, Redis, Docker, Kubernetes, and GitHub Actions.

- Tags: technology-stack
- Published: 2026-06-19

### [The Main Purpose of the Plane Project: Open-Source Project Management Explained](/makeplane/plane/what-is-the-main-purpose-of-the-plane-project)

Discover the main purpose of the Plane project: an open-source management platform offering a self-hostable alternative to track issues, run sprints, and manage work.

- Tags: getting-started
- Published: 2026-06-19

### [How to Set Up a Local Development Environment for Plane (makeplane/plane)](/makeplane/plane/how-to-set-up-local-development-environment-makeplane-plane)

Learn how to set up a local development environment for Plane with Docker and pnpm. Discover the required tools and steps to get your Plane backend and frontend running quickly.

- Tags: how-to-guide
- Published: 2026-06-19

### [How to Create Custom Work Item Properties and Field Types in Plane](/makeplane/plane/how-to-create-custom-work-item-properties-and-field-types-in-plane)

Learn to create custom work item properties and field types in Plane using the customproperty_ prefix and pluggable exporter framework. Enhance your project management capabilities.

- Tags: how-to-guide
- Published: 2026-06-18

### [Plane's Tailwind CSS Configuration and Theming Strategies: The Complete Guide](/makeplane/plane/what-are-planes-tailwind-css-configuration-and-theming-strategies)

Explore Plane's Tailwind CSS configuration in its workspace package. Learn about powerful theming strategies using CSS custom properties and Tailwind 4 directives for instant runtime theme switching.

- Tags: deep-dive
- Published: 2026-06-18

### [How Plane's Notification System Handles Real-Time Alerts](/makeplane/plane/how-does-planes-notification-system-handle-real-time-alerts)

Discover how Plane's notification system handles real-time alerts using MobX and REST APIs for instant UI updates without WebSockets. Learn more now.

- Tags: internals
- Published: 2026-06-18

### [Integration Patterns for the Plane API: A Complete Guide to Third-Party Connections](/makeplane/plane/what-are-the-integration-patterns-for-the-plane-api)

Explore integration patterns for the Plane API. Learn how to connect third-party services like Slack, GitHub, and GitLab for bidirectional sync using REST endpoints, OAuth, and webhooks.

- Tags: how-to-guide
- Published: 2026-06-18

### [How Workspace and Project Views Operate in Plane: MobX State Architecture Explained](/makeplane/plane/how-do-the-workspace-and-project-views-operate-within-plane)

Understand Plane's workspace and project views. Learn how MobX and reactive caches power the user interface using WorkspaceStore and ProjectViewStore.

- Tags: internals
- Published: 2026-06-18

### [Best Practices for Writing Tests in the Plane Codebase: A Complete Guide](/makeplane/plane/what-are-the-best-practices-for-writing-tests-in-the-plane-codebase)

Master writing tests in the Plane codebase with our definitive guide. Learn Vitest for frontend and pytest for backend to ensure reliable code changes and successful merges.

- Tags: best-practices
- Published: 2026-06-18

### [Plane Module and Project Organization: Inside the pnpm Monorepo Architecture](/makeplane/plane/how-is-the-module-and-project-organization-structured-in-plane)

Explore the pnpm monorepo architecture of Plane. Discover how runnable services are in apps and libraries in packages, promoting clear separation and code sharing across backends and frontends.

- Tags: architecture
- Published: 2026-06-18

### [Complete Guide to Self-Hosting Plane in Production: Key Configurations and Setup](/makeplane/plane/what-are-the-key-configurations-for-self-hosting-plane-in-production)

Learn to self-host Plane in production. Configure environment variables, deploy Docker Compose, run migrations, and set up Caddy for TLS termination. Your essential production guide.

- Tags: how-to-guide
- Published: 2026-06-18

### [How to Set Up Local Development for Plane Using Docker and pnpm](/makeplane/plane/how-to-set-up-local-development-for-plane-using-docker-and-pnpm)

Easily set up local development for Plane with Docker and pnpm. Follow our step by step guide to clone the repo, configure, and run Plane locally for seamless development.

- Tags: how-to-guide
- Published: 2026-06-18

### [Security Configurations and Authentication Mechanisms in Plane: A Complete Technical Guide](/makeplane/plane/what-are-the-security-configurations-and-authentication-mechanisms-in-plane)

Explore Plane's robust security: API keys, Django sessions, CSRF tokens, secret keys, and JWT invitations. Secure your project management resources with our technical guide.

- Tags: deep-dive
- Published: 2026-06-18

### [How Plane's i18n Internationalization System Works with i18next](/makeplane/plane/how-does-planes-i18n-internationalization-system-work-with-i18next)

Discover how Plane's i18n internationalization system leverages i18next React bindings ICU formatting and dynamic JSON loading for robust multilingual support. Learn about its custom hook for error prevention.

- Tags: internals
- Published: 2026-06-18

### [React Performance Optimizations in Plane's Frontend: 8 Techniques from the Open Source Codebase](/makeplane/plane/what-performance-optimizations-are-used-in-planes-react-frontend)

Discover 8 React performance optimizations in Plane's open source frontend including memoization code splitting MobX and virtualized lists to boost UI thread speed.

- Tags: performance
- Published: 2026-06-18

### [How Cycle (Sprint) Management and Burn-Down Charts Work in Plane](/makeplane/plane/how-does-the-cycle-sprint-management-and-burn-down-chart-system-work-in-plane)

Understand Plane's cycle sprint management and burn-down charts. Learn how Plane visualizes progress and actual velocity against ideal completion lines for efficient agile workflows.

- Tags: how-to-guide
- Published: 2026-06-18

### [Plane Django Database Models: Complete Schema and Relationship Guide](/makeplane/plane/what-are-the-database-models-and-relationships-in-planes-django-models)

Explore Plane's Django database models, schema, and relationships. Understand multi-tenant project management, soft-delete models, UUID keys, and complex many-to-many connections.

- Tags: deep-dive
- Published: 2026-06-18

### [How to Create Custom Components Using the @plane/ui Component Library](/makeplane/plane/how-to-create-custom-components-using-the-plane-ui-component-library)

Learn to build custom components with the @plane/ui library. Extend interfaces and merge Tailwind styles using type-safe React primitives for flexible UI development.

- Tags: how-to-guide
- Published: 2026-06-18

### [How WebSocket Decorators Enable Real-Time Updates in Plane](/makeplane/plane/how-do-websocket-decorators-facilitate-real-time-updates-in-plane)

Discover how WebSocket decorators in Plane automate real-time updates. Learn how @WebSocket marks handlers for bidirectional communication with Express-compatible routing.

- Tags: internals
- Published: 2026-06-18

### [Plane Permission and Role System Architecture: A Deep Dive into RBAC Implementation](/makeplane/plane/what-is-the-architecture-of-planes-permission-and-role-system)

Explore Plane's RBAC system architecture. Discover how integer roles, DRF permissions, and a TypeScript front-end store ensure robust access control. Learn more about Plane's permission system.

- Tags: architecture
- Published: 2026-06-18

### [How to Add a New API Endpoint to Plane's Django Backend (apps/api)](/makeplane/plane/how-to-add-a-new-api-endpoint-to-planes-django-backend)

Easily add a new API endpoint to Plane's Django backend by creating serializers, implementing ViewSets, and registering routes. Learn the steps for apps api.

- Tags: how-to-guide
- Published: 2026-06-18

### [How Plane's Work Item Filter and Query System Works in the Utils Package](/makeplane/plane/how-does-the-work-item-filter-and-query-system-function-in-planes-utils-package)

Explore Plane's work item filter and query system. Learn how its rich filter architecture transforms UI selections into efficient backend queries via configurable definitions and a store adapter for seamless state management.

- Tags: internals
- Published: 2026-06-18

### [How to Extend Tiptap Rich Text Editor with Custom Extensions in Plane](/makeplane/plane/how-to-extend-tiptap-rich-text-editor-with-custom-extensions)

Learn how to extend Tiptap rich text editor in Plane by creating custom extensions and registering them in the extension registry. Enhance your editor easily and efficiently.

- Tags: how-to-guide
- Published: 2026-06-18

### [How MobX Manages Shared State Across Plane's Frontend Applications](/makeplane/plane/how-does-mobx-manage-shared-state-across-planes-frontend-applications)

Discover how MobX manages shared state in Plane's frontend. Learn about observable stores, CoreRootStore, and React Context integration for seamless data synchronization.

- Tags: internals
- Published: 2026-06-18

### [Plane Monorepo Architecture: How pnpm Workspaces and Turbo Power the Codebase](/makeplane/plane/what-is-the-architecture-of-the-plane-monorepo-with-pnpm-workspaces-and-turbo)

Explore the Plane monorepo architecture. Discover how pnpm workspaces and Turbo manage dependencies and accelerate builds for efficient codebase development.

- Tags: architecture
- Published: 2026-06-18