Plane Contribution Guide: How to Contribute to the makeplane/plane Monorepo

Yes, the makeplane/plane repository provides a comprehensive CONTRIBUTING.md file that outlines Docker-first development workflows, coding standards, and the complete pull request process for this Django and React monorepo.

The makeplane/plane project is an open-source project management platform structured as a monorepo containing both a Django-based backend and a TypeScript/React frontend. Whether you are fixing bugs or adding features, understanding the contribution guide for makeplane/plane is essential for submitting successful pull requests that align with the project's architectural standards.

Where to Find the Official Contribution Guide

The single source of truth for contributors is CONTRIBUTING.md located at the root of the repository. This document defines the complete workflow—from issue creation to code review—and specifies the Docker-first development philosophy that isolates dependencies and mirrors production environments. According to the makeplane/plane source code, all contributors must follow the issue naming conventions and testing requirements detailed in this file.

Prerequisites and System Requirements

Before cloning the repository, ensure your local machine meets the following specifications outlined in CONTRIBUTING.md:

• Node.js 20+ – Required for the PNPM workspace and frontend tooling.
• Python 3.8+ – Required for the Django backend located in apps/api/.
• Docker and Docker Compose – The entire stack (PostgreSQL, Redis, backend, frontend) runs inside containers defined in docker-compose-local.yml.
• PNPM – The monorepo uses PNPM workspaces to orchestrate all TypeScript packages.

Monorepo Architecture Overview

The contribution guide for makeplane/plane emphasizes understanding the repository's split architecture:

• apps/api/plane/ – Django backend source code handling REST APIs and business logic.
• apps/web/ – Next.js React application serving the primary user interface.
• packages/ui/ – Shared React UI components used across the frontend.
• packages/i18n/ – Internationalization files and translation utilities.
• pnpm-workspace.yaml – Declares the workspace layout for all TypeScript packages.

All frontend packages are managed through a unified pnpm workspace, while the backend remains a standard Django project.

Setting Up Your Local Development Environment

The repository provides an automated setup script to streamline initial configuration. Follow these steps from the CONTRIBUTING.md to boot the entire stack:

# 1️⃣ Clone the repository (replace <folder> with your desired directory)

git clone https://github.com/makeplane/plane.git <folder>
cd <folder>

# 2️⃣ Make the setup script executable and run it

chmod +x setup.sh
./setup.sh               # installs pnpm packages, builds the monorepo, creates .env files

# 3️⃣ Spin up the Docker services (Postgres, Redis, backend, frontend)

docker compose -f docker-compose-local.yml up

# 4️⃣ In a separate terminal, start the dev servers (web UI on 3000, admin UI on 3001)

pnpm dev                 # launches both web and admin apps with hot‑reloading

# 5️⃣ Open your browser

#   • http://localhost:3000 – regular UI

#   • http://localhost:3001/god-mode/ – admin UI (create the instance admin first)

The setup.sh script automates dependency installation, monorepo builds, and .env file generation, ensuring all contributors start with identical environments.

Coding Standards and Testing

Linting and Formatting

The project enforces strict code quality through OxLint and oxfmt with shared configuration files located at the repository root:

• .oxlintrc.json – Defines linting rules for all TypeScript packages.
• .oxfmtrc.json – Defines formatting standards to maintain consistency.

All code must pass these checks before merge, as the CI pipeline automatically runs lint and type-checks on every pull request.

Testing Requirements

Every new feature or bug-fix must include corresponding unit tests. The backend Django tests can be executed using the dedicated test composition:

docker compose -f docker-compose-test.yml up --build --abort-on-container-exit --exit-code-from api-tests

# Or inside the container:

docker exec -it plane-api pytest

Frontend tests follow the standard Jest or Vitest patterns within the respective packages/ directories.

Contribution Workflow

Issue Naming Conventions

Before writing code, contributors must open an issue using the provided forms. The Plane contribution guide requires specific prefixes:

• 🐛 Bug: – For bug reports (e.g., 🐛 Bug: Calendar view crashes on mobile).
• 🚀 Feature: – For feature requests (e.g., 🚀 Feature: Add dark mode toggle).

This convention helps maintainers triage and prioritize work efficiently.

Submitting Pull Requests

Once your issue is acknowledged, follow the standard fork-and-branch workflow:

1. Fork the repository and create a feature branch from preview.
2. Implement your changes following the coding standards defined in CONTRIBUTING.md.
3. Add tests for any new functionality.
4. Run pnpm dev locally to verify hot-reloading works correctly.
5. Submit a pull request referencing the original issue number.

For localization changes, modify the JSON files in packages/i18n/src/locales/:

// packages/i18n/src/locales/en/translations.json
{
  "greeting": "Hello, {name}!"
}

Then run pnpm dev to verify the new translation keys appear in the UI.

Summary

• The CONTRIBUTING.md file in the makeplane/plane repository provides the authoritative contribution guide for makeplane/plane.
• Development is Docker-first, using docker-compose-local.yml to run PostgreSQL, Redis, and the full application stack.
• The monorepo uses pnpm workspaces for TypeScript packages and standard Django tooling for the backend.
• OxLint and oxfmt enforce code quality, while every PR requires unit tests and must pass CI checks.
• Issue naming conventions (🐛 Bug:, 🚀 Feature:) streamline the triage process for maintainers.

Frequently Asked Questions

Where is the makeplane/plane contribution guide located?

The contribution guide is located at CONTRIBUTING.md in the root directory of the repository. This file contains detailed instructions for setting up Docker, running the development environment, and submitting pull requests that meet the project's coding standards.

What programming languages and tools do I need to contribute to Plane?

You need Node.js 20+ and Python 3.8+ installed locally, along with Docker and Docker Compose. The frontend uses TypeScript/React with PNPM workspaces, while the backend uses Django. All linting is handled by OxLint and oxfmt as configured in .oxlintrc.json and .oxfmtrc.json.

How do I run tests before submitting a pull request to makeplane/plane?

For backend changes, run the Django test suite using docker compose -f docker-compose-test.yml up --build --abort-on-container-exit --exit-code-from api-tests or execute pytest inside the running API container with docker exec -it plane-api pytest. Frontend tests should be run within the specific package directories using the standard test commands.

Can I contribute to Plane without using Docker?

While possible, the CONTRIBUTING.md explicitly recommends Docker-first development because the docker-compose-local.yml file defines the complete service stack (PostgreSQL, Redis, backend, frontend) and ensures your environment matches production. Manual setup is not officially documented and may lead to dependency conflicts.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}