Features Overview

Comprehensive Project Management

Plane provides everything you need to manage modern software projects, from issue tracking to analytics. Built on a robust tech stack with React Router, Django, and TypeScript, Plane offers flexibility and power for teams of all sizes.

All features are available in both Plane Cloud and self-hosted deployments. Some advanced features may require specific configurations.

Core Features

Work Items

Powerful issue tracking with rich text editing, file uploads, and custom properties

Cycles

Time-boxed sprints with burn-down charts and progress tracking

Modules

Organize issues into larger feature sets or milestones

Views

Custom filters and saved queries for focused workflows

Pages

AI-powered documentation and knowledge management

Analytics

Real-time insights and custom reports

Work Items

Efficiently create and manage tasks with a robust rich text editor that supports file uploads, markdown, and advanced formatting.

Rich Text Editor

// Editor features from @plane/editor
import { RichTextEditor } from '@plane/editor';

// Supported extensions:
- Document structure (headings, paragraphs)
- Text formatting (bold, italic, underline, strike)
- Lists (ordered, unordered, task lists)
- Code blocks with syntax highlighting
- Blockquotes and horizontal rules
- Tables for structured data
- Images with drag-and-drop support
- Links and mentions (@user)
- Real-time collaboration via Yjs
- Markdown shortcuts

Key Capabilities

Sub-Properties & Relationships

Enhance organization with:

Parent/Child Issues - Break down large tasks into sub-issues
Related Issues - Link connected work items
Blocking/Blocked By - Track dependencies
Duplicate Detection - Automatic de-duplication

// Issue relationship types from @plane/types
interface IIssue {
  parent_id: string | null;
  sub_issues_count: number;
  related_issues: string[];
  blocked_issues: string[];
  blocker_issues: string[];
}

Custom Properties

Track additional metadata:

Estimates - Story points or time tracking
Labels - Flexible tagging system
Priority - Urgent, High, Medium, Low, None
State - Customizable workflow states
Assignees - Multiple assignees per issue
Due Dates - Deadline tracking
Custom Fields - Project-specific properties

File Attachments

Upload and manage files:

Drag-and-drop file uploads
Image preview and inline display
Document attachments
Asset management via API

// File asset types from @plane/types
interface IAsset {
  id: string;
  asset: string;
  attributes: Record<string, any>;
}

Activity History

Complete audit trail:

All field changes tracked
Comment history
State transitions
Assignment changes
Timestamp and user attribution

// Activity tracking from @plane/types
interface IIssueActivity {
  id: string;
  verb: string;
  field: string;
  old_value: string;
  new_value: string;
  created_at: string;
  actor: string;
}

Multiple View Options

List View
Kanban Board
Calendar
Spreadsheet
Gantt Chart

Traditional row-based layout:

Group by any property
Inline quick editing
Bulk selection and actions
Sortable columns
Collapsible groups

Cycles

Maintain your team’s momentum with Cycles—Plane’s implementation of time-boxed work periods (sprints).

Cycle Management

// Cycle structure from @plane/types
interface ICycle {
  id: string;
  name: string;
  description: string;
  start_date: string;
  end_date: string;
  status: "draft" | "current" | "upcoming" | "completed";
  view_props: IIssueFilterOptions;
  owned_by_id: string;
  // Progress tracking
  total_issues: number;
  completed_issues: number;
  cancelled_issues: number;
  started_issues: number;
  unstarted_issues: number;
  backlog_issues: number;
}

Features

Progress Tracking

Real-time burn-down charts
Velocity calculations
Completion percentages
Issue distribution by state

Cycle Planning

Drag issues from backlog
Capacity planning tools
Auto-move incomplete items
Cycle templates

Analytics

Distribution by assignee
Priority breakdown
Label analysis
Time tracking

Active Cycles View

Overview of all active cycles
Cross-project cycle tracking
Team workload visibility
Quick cycle switching

Use the Active Cycles page at [workspace]/(projects)/active-cycles to see all running cycles across your workspace.

Modules

Simplify complex projects by dividing them into smaller, manageable modules. Perfect for epics, features, or product releases.

Module Capabilities

// Module structure from @plane/types
interface IModule {
  id: string;
  name: string;
  description: string;
  start_date: string | null;
  target_date: string | null;
  status: "backlog" | "planned" | "in-progress" | "paused" | "completed" | "cancelled";
  lead_id: string | null;
  member_ids: string[];
  // Progress metrics
  total_issues: number;
  completed_issues: number;
  cancelled_issues: number;
}

Create Module

Define high-level features or releases with names, descriptions, and target dates.

Add Issues

Assign work items to modules for grouping and tracking.

Track Progress

Monitor completion rates, identify blockers, and adjust scope.

Close Module

Mark modules complete and archive for historical reference.

Use Cases

Feature Development - Group all issues for a major feature
Product Releases - Track work for a specific version
Epics - Long-term initiatives spanning multiple cycles
Client Projects - Organize deliverables by contract

Views

Customize your workflow by creating filters to display only the most relevant issues. Save and share these views with ease.

View Types

Project Views

Scoped to a single project:

Private or shared
Custom filters and sorting
Layout preferences
Quick access from sidebar

Workspace Views

Cross-project perspectives:

See issues across all projects
Team-wide visibility
Standardized workflows
Admin-managed templates

// Filter structure from @plane/types
interface IIssueFilterOptions {
  assignees?: string[];
  mentions?: string[];
  created_by?: string[];
  labels?: string[];
  priority?: ("urgent" | "high" | "medium" | "low" | "none")[];
  state?: string[];
  state_group?: ("backlog" | "unstarted" | "started" | "completed" | "cancelled")[];
  subscriber?: string[];
  start_date?: string[];
  target_date?: string[];
  cycle?: string[];
  module?: string[];
  // Additional filters...
}

Common View Examples

My Open Issues - assignee = me AND state != done
High Priority This Week - priority = urgent|high AND due_date = this_week
Blocked Items - blocked_by != empty
Ready for Review - state = review AND assignee = me
Overdue - due_date < today AND state != done

Views support complex boolean logic with AND/OR operators and nested conditions.

Pages

Capture and organize ideas using Plane Pages, complete with AI capabilities and a rich text editor. Format text, insert images, add hyperlinks, or convert notes into actionable items.

Page Features

Rich Content Editing

Full Tiptap editor with:

Markdown syntax support
Code blocks with syntax highlighting
Embedded images and media
Tables and lists
Text formatting toolbar
Slash commands for quick insertion

AI Assistance

Enhance productivity with AI:

Content generation
Grammar and style suggestions
Summary creation
Action item extraction

// AI integration from @plane/types
interface IAIResponse {
  response: string;
  response_html: string;
}

Convert to Issues

Transform documentation into work items:

Select text to create issue
Preserve formatting
Maintain context links
Auto-populate description

Organization

Keep knowledge structured:

Hierarchical page organization
Favorites and recent pages
Search within pages
Access controls (public/private)
Version history

Use Cases

Meeting Notes - Document discussions and decisions
Project Documentation - Technical specs and requirements
Knowledge Base - Team processes and guidelines
Brainstorming - Capture ideas before creating issues
Retrospectives - Sprint reviews and action items

Analytics

Access real-time insights across all your Plane data. Visualize trends, remove blockers, and keep your projects moving forward.

Analytics Views

// Analytics structure from @plane/types
interface IAnalyticsResponse {
  total: number;
  distribution: Record<string, number>;
  extras: Record<string, any>;
}

Scope
Metrics
Dimensions
Visualizations

Choose your analysis level:

Workspace Analytics - All projects combined
Project Analytics - Single project insights
Cycle Analytics - Sprint-specific metrics
Module Analytics - Feature-level tracking

Custom Reports

Create tailored analytics:

Select date range
Choose metrics to track
Apply filters
Select visualization type
Save and share reports

Use analytics to identify bottlenecks, balance workload, and improve team processes over time.

Additional Features

Inbox

Issue TriageCentral place for incoming issues:

Approve or decline submissions
Add context before acceptance
Filter spam and duplicates
Assign priority and owner

Draft Issues

Work in ProgressSave incomplete issues:

Return later to finish
Share drafts with team
Convert to full issues
Auto-save functionality

Notifications

Stay UpdatedReal-time alerts for:

Mentions and assignments
Issue updates
Comment replies
Cycle/module changes

Command Palette

Quick ActionsPress Cmd+K to:

Create issues instantly
Navigate to any page
Execute bulk actions
Search everything

Integrations

Connect ToolsExtend Plane with:

GitHub sync
Slack notifications
Webhooks
API access

API Access

Programmatic ControlFull REST API:

Authentication tokens
CRUD operations
Webhooks
Rate limiting

Search

Find AnythingPowerful search:

Full-text search
Filter by type
Recent items
Keyboard shortcuts

Favorites

Quick AccessBookmark important:

Projects
Issues
Views
Pages

God Mode

Instance AdminSelf-hosted management:

User administration
System configuration
Email settings
Authentication providers

Collaboration Features

Real-Time Collaboration

// Collaboration powered by Yjs from @plane/editor
import { HocuspocusProvider } from '@hocuspocus/provider';
import * as Y from 'yjs';

// Real-time features:
- Live cursors showing active users
- Simultaneous editing
- Conflict-free synchronization
- Offline support with sync on reconnect

Team Communication

Comments - Threaded discussions on issues
Mentions - @-notify team members
Reactions - Emoji reactions on comments
Activity Feed - Real-time updates

Access Control

// Role-based permissions from @plane/types
type TWorkspaceRole = 5 | 10 | 15 | 20; // Guest, Viewer, Member, Admin

interface IProjectMember {
  member: IUser;
  role: 5 | 10 | 15 | 20;
  view_props: IIssueFilterOptions;
}

Technical Architecture

Monorepo Structure

Plane uses a modern monorepo with pnpm workspaces:

plane/
├── apps/
│   ├── web/          # Main application (port 3000)
│   ├── admin/        # Instance admin (port 3001)
│   ├── space/        # Public spaces (port 3002)
│   ├── api/          # Django API server
│   └── live/         # Real-time services
├── packages/
│   ├── ui/           # Shared UI components
│   ├── editor/       # Tiptap editor
│   ├── types/        # TypeScript types
│   ├── constants/    # Shared constants
│   ├── hooks/        # React hooks
│   ├── services/     # API services
│   ├── shared-state/ # MobX stores
│   └── utils/        # Utility functions

State Management

MobX for reactive state:

// Example store from @plane/shared-state
import { makeObservable, observable, action } from 'mobx';

class IssueStore {
  issues: Map<string, IIssue> = new Map();
  
  constructor() {
    makeObservable(this, {
      issues: observable,
      addIssue: action,
    });
  }
  
  addIssue(issue: IIssue) {
    this.issues.set(issue.id, issue);
  }
}

Next Steps

API Reference

Explore the REST API documentation

Self-Hosting

Deploy Plane on your infrastructure

Development Setup

Set up Plane for local development

Contributing

Help build Plane’s future

Have questions about a specific feature?Join our community on GitHub Discussions or visit our Forum for detailed discussions.

Get Started

Core Features

Self-Hosting

Development

​Comprehensive Project Management

​Core Features

Work Items

Cycles

Modules

Views

Pages

Analytics

​Work Items

​Rich Text Editor

​Key Capabilities

​Multiple View Options

​Cycles

​Cycle Management

​Features

Progress Tracking

Cycle Planning

Analytics

Active Cycles View

​Modules

​Module Capabilities

​Use Cases

​Views

​View Types

Project Views

Workspace Views

​Filter Options

​Common View Examples

​Pages

​Page Features

​Use Cases

​Analytics

​Analytics Views

​Custom Reports

​Additional Features

Inbox

Draft Issues

Notifications

Command Palette

Integrations

API Access

Search

Favorites

God Mode

​Collaboration Features

​Real-Time Collaboration

​Team Communication

​Access Control

​Technical Architecture

​Monorepo Structure

​State Management

​Next Steps

API Reference

Self-Hosting

Development Setup

Contributing

Build docs developers (and LLMs) love

Comprehensive Project Management

Core Features

Work Items

Rich Text Editor

Key Capabilities

Multiple View Options

Cycles

Cycle Management

Features

Modules

Module Capabilities

Use Cases

Views

View Types

Filter Options

Common View Examples

Pages

Page Features

Use Cases

Analytics

Analytics Views

Custom Reports

Additional Features

Collaboration Features

Real-Time Collaboration

Team Communication

Access Control

Technical Architecture

Monorepo Structure

State Management

Next Steps