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

> 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.

- Repository: [Plane/plane](https://github.com/makeplane/plane)
- Tags: contribution-guide
- Published: 2026-06-26

---

**Yes, the makeplane/plane repository provides a comprehensive [`CONTRIBUTING.md`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/CONTRIBUTING.md) to boot the entire stack:

```bash

# 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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/.oxlintrc.json)** – Defines linting rules for all TypeScript packages.
- **[`.oxfmtrc.json`](https://github.com/makeplane/plane/blob/main/.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:

```bash
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`](https://github.com/makeplane/plane/blob/main/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/`:

```json
// 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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/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`](https://github.com/makeplane/plane/blob/main/.oxlintrc.json) and [`.oxfmtrc.json`](https://github.com/makeplane/plane/blob/main/.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`](https://github.com/makeplane/plane/blob/main/CONTRIBUTING.md)** explicitly recommends Docker-first development because the [`docker-compose-local.yml`](https://github.com/makeplane/plane/blob/main/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.