# The Main Purpose of the Plane Project: Open-Source Project Management Explained

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

- Repository: [Plane/plane](https://github.com/makeplane/plane)
- Tags: getting-started
- Published: 2026-06-19

---

**Plane is an open-source project-management platform that provides teams with a complete, self-hostable alternative to proprietary tools, combining a Django REST API backend with a React TypeScript frontend to track issues, run sprints, and manage work across cycles and modules.**

The Plane project addresses the growing need for flexible, transparent project management software by delivering a full-stack solution that teams can either self-host or use as a managed service. According to the makeplane/plane repository, the main purpose of the Plane project is to eliminate vendor lock-in while offering modern features like issue tracking, sprint cycles, and real-time analytics through a clean, extensible web interface.

## What Is Plane? Core Purpose and Architecture

Plane is an open-source project-management platform designed as a monorepo combining a Django REST backend with a React TypeScript frontend. The architecture stores work items—including **issues**, **cycles**, **modules**, **views**, and **pages**—in a PostgreSQL database, exposing them through a clean JSON API consumed by the modern React interface.

The backend entry point is defined in [`apps/api/plane/wsgi.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/wsgi.py), which serves as the WSGI entry point for the Django application, while API routing is handled in [`apps/api/plane/web/urls.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/web/urls.py) where endpoints for workspaces, projects, and issues are registered.

## Backend Architecture: Django REST Framework

The backend layer relies on Django and Django REST Framework to handle data persistence, authentication, and business logic.

Key implementation details include:

- **WSGI Entry Point**: The [`apps/api/plane/wsgi.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/wsgi.py) file initializes the Django application for production deployment.
- **API Routing**: The [`apps/api/plane/web/urls.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/web/urls.py) module defines the URL patterns for all REST endpoints, including the issues endpoint accessed at `/api/workspaces/<workspace_slug>/projects/<project_id>/issues/`.
- **Permission Logic**: Access control is implemented in `apps/api/plane/utils/permissions/`, enforcing workspace-level and project-level security policies.

## Frontend Architecture: React, TypeScript, and MobX

The presentation layer is built as a modern React application using TypeScript for type safety and MobX for state management.

Critical frontend files include:

- **Application Entry**: [`apps/web/package.json`](https://github.com/makeplane/plane/blob/main/apps/web/package.json) defines the main web application dependencies and scripts.
- **Component Library**: [`packages/ui/README.md`](https://github.com/makeplane/plane/blob/main/packages/ui/README.md) documents the reusable React component library used across the interface.
- **State Management**: [`packages/shared-state/package.json`](https://github.com/makeplane/plane/blob/main/packages/shared-state/package.json) configures the MobX-based shared state layer.
- **Styling**: [`packages/tailwind-config/package.json`](https://github.com/makeplane/plane/blob/main/packages/tailwind-config/package.json) centralizes the Tailwind CSS configuration for consistent design.
- **Logging Utilities**: [`packages/logger/package.json`](https://github.com/makeplane/plane/blob/main/packages/logger/package.json) provides TypeScript utilities for application logging and debugging.

## Working with the Plane API

The Django backend exposes a RESTful API that the React frontend consumes. You can interact with this API directly using standard HTTP requests.

### Fetching Issues via cURL

To retrieve a list of issues from a specific project:

```bash
curl -H "Authorization: Bearer <YOUR_API_TOKEN>" \
     https://app.plane.so/api/workspaces/<workspace_slug>/projects/<project_id>/issues/

```

This endpoint, defined in the API router at [`apps/api/plane/web/urls.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/web/urls.py), returns a paginated JSON payload containing issue objects with metadata such as title, description, and completion status.

### Creating Issues from React Components

The frontend provides abstraction hooks to interact with these endpoints. In `packages/ui`, the `useCreateIssue` hook handles the API communication:

```typescript
import { useCreateIssue } from '@plane/ui';

function NewIssueButton({ workspaceSlug, projectId }: Props) {
  const createIssue = useCreateIssue();

  const handleClick = async () => {
    await createIssue({
      workspaceSlug,
      projectId,
      title: 'My new issue',
      description: 'Add details here',
    });
  };

  return <button onClick={handleClick}>Create Issue</button>;
}

```

The hook POSTs payload data to `/api/workspaces/:slug/projects/:id/issues/`, automatically handling authentication headers and error states.

## State Management Implementation

Frontend state is managed through MobX stores defined in the `packages/shared-state` workspace. Developers can extend the system by creating custom stores:

```typescript
import { makeAutoObservable } from 'mobx';

export class IssueStore {
  issues: Issue[] = [];

  constructor() {
    makeAutoObservable(this);
  }

  setIssues(newIssues: Issue[]) {
    this.issues = newIssues;
  }

  get openIssues() {
    return this.issues.filter(i => !i.completed_at);
  }
}

```

These stores can be registered in the shared-state package and accessed throughout the UI via React context, providing reactive data synchronization across components.

## Deployment Options: Self-Hosted vs. Plane Cloud

The main purpose of the Plane project includes providing deployment flexibility. Teams can run Plane as a managed SaaS product (Plane Cloud) or self-host via Docker and Kubernetes. The monorepo structure, utilizing npm workspaces, allows developers to run the entire stack locally using `pnpm dev`, making customization and extension straightforward.

## Summary

- **Plane** is an open-source project-management platform combining Django REST and React TypeScript to provide a Jira alternative.
- The **backend** in `apps/api/plane/` handles data persistence and API routing through Django, with entry points at [`wsgi.py`](https://github.com/makeplane/plane/blob/main/wsgi.py) and [`urls.py`](https://github.com/makeplane/plane/blob/main/urls.py).
- The **frontend** uses React, MobX (in `packages/shared-state`), and Tailwind CSS (in `packages/tailwind-config`) to render the interface defined in [`apps/web/package.json`](https://github.com/makeplane/plane/blob/main/apps/web/package.json).
- Core entities include **issues**, **cycles**, **modules**, and **pages**, stored in PostgreSQL and exposed via REST endpoints.
- The architecture supports both **self-hosted** deployments and managed **Plane Cloud** instances.
- Developers can extend functionality through the npm workspaces structure, modifying both backend API logic and frontend state management.

## Frequently Asked Questions

### What is the main purpose of the Plane project?

The main purpose of the Plane project is to provide teams with an open-source, self-hosted alternative to proprietary project management tools like Jira or Linear. It delivers a complete full-stack solution for tracking issues, managing sprints through cycles, organizing work into modules, and collaborating on documents—all while maintaining full data ownership and avoiding vendor lock-in.

### How does Plane's architecture support self-hosting?

Plane uses a containerized architecture where the Django backend and React frontend can be deployed via Docker or Kubernetes. The backend at [`apps/api/plane/wsgi.py`](https://github.com/makeplane/plane/blob/main/apps/api/plane/wsgi.py) and the frontend at [`apps/web/package.json`](https://github.com/makeplane/plane/blob/main/apps/web/package.json) are configured to run independently or together, with the entire stack manageable through `pnpm` commands in the monorepo structure.

### What technologies power the Plane frontend and backend?

The backend relies on Django and Django REST Framework with PostgreSQL for data storage, while the frontend uses React with TypeScript, bundled with Vite/Next.js. State management is handled by MobX (configured in [`packages/shared-state/package.json`](https://github.com/makeplane/plane/blob/main/packages/shared-state/package.json)), and styling uses Tailwind CSS (defined in [`packages/tailwind-config/package.json`](https://github.com/makeplane/plane/blob/main/packages/tailwind-config/package.json)).

### Is Plane suitable as a replacement for enterprise tools like Jira?

Yes, Plane is designed to compete with enterprise project management software by offering comparable features—issue tracking, sprint cycles, custom views, and analytics—without licensing fees or vendor lock-in. The permission system in `apps/api/plane/utils/permissions/` supports workspace-level and project-level access control suitable for enterprise security requirements.