How to Use Plane: The Beginner's Guide (First Workspace, the Project Lesson, First Work Item, and the Cycles Arc)
CodexFuse Team · 2026-11-02T04:29:06.564Z · 16 min read min read
What Is Plane, Exactly?
Plane is the open-source project management platform you use to track issues, run cycles, and manage product roadmaps — and to be precise from the first sentence, this guide is about Plane the software (plane.so), not airplanes, geometry, or control planes. This guide teaches you how to use Plane end to end: it is a plane project management tutorial for beginners — you will set up your first workspace, learn the project lesson, create your first work item, and run your first cycle. One mental model carries the whole product, said once because everything else hangs off it: in Plane, WORKSPACES hold PROJECTS; a project holds WORK ITEMS, CYCLES, MODULES, and PAGES. Work items are the tasks, cycles are time-boxed sprints, modules are feature groupings, and pages are built-in docs — all inside one project, and every project inside one workspace.
Plane's headline pitch is "Project management and knowledge management for teams and agents," and it positions itself as AI-native: Plane AI reads across projects, cycles, docs, and threads, and agents can take assignments. It is also one of the few modern PM tools you can run entirely on your own infrastructure — "Cloud, self-hosted and air-gapped ready" — which is why the cloud-vs-self-host choice gets its own section below, once. If your team goes the self-hosted route, our Docker beginner guide covers the container basics you will lean on.
Should You Start on Plane Cloud or Self-Host It?
Pick cloud unless you have a specific reason not to — the self-host decision deserves a deliberate yes, not a default. Plane Cloud starts on the Free plan: $0 per seat per month for up to 12 users with core features, then Pro at $6 per seat per month and Business at $13 per seat per month (the vendor lists yearly-discount percentages; pricing figures move, so treat the mechanism as the stable fact and re-check the pricing page before you budget). Self-hosted installs run the same plan structure — you start on Free for up to 12 seats per workspace without a license key, and a paid license key unlocks the Pro, Business, or Enterprise features on your own hardware.
Self-host only when the reason is concrete: data residency, compliance, air-gapped environments, or the simple preference to control every layer ("the only modern project management platform built for environments where you control every layer" is Plane's own positioning). The rest of this guide works identically on Cloud and self-hosted — the product is the same either way.
How Do You Create Your First Workspace and Project?
Your first project is a 60-minute exercise, and the vendor's own tutorial series publishes timeboxes you can plan against. Create the workspace first (about 5 minutes), then follow this arc — the vendor's create-project tutorial is an 8–10 minute walkthrough that goes: Projects sidebar, Browse all projects, Add Project (or press N then P), name it, set the Project ID, choose access, Create project, accept the feature defaults, then configure workflow states, add team members, and add labels.
The project lesson is three decisions you make once and live with:
- Name — up to 255 characters, unique in the workspace (including archived projects). Pick the product or launch, not a team name; you add more projects per workspace as the team grows.
- Project ID — required, auto-suggested from the name, letters and numbers only, max 10 characters. This prefix is glued to every work item (PROJ-123, DEV-456), so pick something short and permanent; it is unique in the workspace.
- Network (visibility) — Public or Private. Public is the default: all workspace members can discover and join (guests excluded unless invited). Private means only explicitly invited members see it; admins always see everything.
Two more project facts before you move on: the person who creates a project becomes its admin, and projects ship with Views and Pages on and other features off — you enable what you need from the post-creation modal, then "Open project." Archiving (admins only) removes a project from the sidebar and search but keeps all data and is reversible; deleting is permanent and makes you type the project name plus "delete my project" to confirm. The vendor's tutorial index stacks the plane for beginners path as Create workspace (5 min) → Invite members (3–5 min) → Create projects (8–10 min) → Create work items (8–10 min) → Collaborate on work items (10–12 min) → Organize and view your work (12–15 min) → Plan with Cycles → Write content with Pages (5 min) — follow it in that order.
What Are Work Items, and How Do You Create the First One?
A work item is the fundamental building block of Plane — the task, bug, or story everything else attaches to. Click "Add work item" (top-right), and give it the five properties that matter: State (where it sits in the workflow — Plane groups states into backlog, unstarted, started, completed, and cancelled, e.g. Planned → In Progress → Done), Priority (e.g. Medium), Assignees, Labels (e.g. frontend), and Dates. Every work item gets a unique ID from your Project ID prefix (ENG-1, PROJ-1) — that ID is how the team references it everywhere.
Two workflow details save beginners daily: unfinished work items auto-save to Drafts, so a half-written item is never lost; and every item opens in a peek view (side panel) with a full view for the deep work — all changes auto-save, so there is no save button to hunt. The List layout is the default and the fastest way to triage; flip to Board and drag cards between state columns when the team wants the visual. One habit to install early: labels are the team's shared vocabulary — define them in the create-project step, not per item, or your filters fall apart by week three.
How Do Cycles Work in Plane?
Cycles are time-boxed containers — Plane's name for sprints — and they are where planning turns into velocity you can measure. Create one via Cycles → Add cycle with a title, description, and start/end dates; the vendor recommends a 2-week first cycle (1–2 weeks is the typical range). Cycles live as Active, Upcoming, and Completed, and the cycle dashboard tracks completion percentage, a burn-down chart, the work-item breakdown, and team velocity automatically.
The beginner's scoping rule, from the vendor's own guidance: a new team takes 3–5 items, an experienced team 5–8, a solo developer 2–4 — do not pack the first cycle to look productive; the burn-down only teaches you if the scope was honest. When the cycle ends, incomplete items move to the next cycle or back to the backlog — that decision is the planning conversation, and it is the whole point of the cycle review.
Which Views Should a Beginner Learn First?
Learn three views in this order and ignore the rest for a month: List for fast triage and editing, Board for the visual state of work, and the Cycles dashboard for the burn-down. Calendar is useful once dates are real, Gantt once you manage dependencies across a roadmap, and Spreadsheet once the dataset is big enough to need bulk edits. Initiatives (epics) group cycles and modules under a bigger bet — create your first one only when a single cycle can no longer hold the story. Modules sit between: a feature area that spans several cycles, so the team sees "payments revamp" as one unit while the cycles inside it turn over.
How Do Members, Labels, and the Team Fit In?
Invite members second — right after the workspace exists, per the vendor's 3–5 minute tutorial. Admins invite to the workspace; project admins control who enters a private project. Labels are created at the project level and shared across its work items; treat them as a controlled vocabulary (area: frontend/backend/docs, type: bug/feature/chore) rather than freeform tags, because every filter, view, and automation you build later reads them. Pages are the built-in docs — write the cycle notes, the RFC, and the retro in the same project that holds the work items, so context never lives in a different tool. If pages-in-projects is a new idea for your team, the mental-model table below keeps the whole map on one screen.
| Concept | What it is | Beginner's rule |
|---|---|---|
| Workspace | The container for everything — your team's home | One per company; projects multiply inside it |
| Project | Work items + cycles + modules + pages for one product or launch | Name it for the product; guard the Project ID prefix |
| Work item | The fundamental building block: one task, bug, or story | Five properties filled in: state, priority, assignee, labels, dates |
| Cycle | A time-boxed sprint container | Start with 2 weeks; let velocity set the scope |
| Module | A feature grouping that spans cycles | Use when one cycle can't hold the story |
| Initiative | An epic across modules and cycles | Only when the roadmap needs it |
| Page | Built-in docs inside the project | Keep notes with the work, not in another tool |
How Do You Self-Host Plane With Docker?
Running Plane self-hosted starts with a single command — the plane docker install is the documented default — and there are two editions of that command. The Commercial Edition installs via the Prime CLI (curl -fsSL https://prime.plane.so/install/ | sh -); the Community Edition uses the release setup script (curl -fsSL -o setup.sh https://github.com/makeplane/plane/releases/latest/download/setup.sh then ./setup.sh). Community is the free open-source core; Commercial adds the paid-tier features unlocked by a license key.
curl -fsSL https://prime.plane.so/install/ | sh - # Commercial Edition curl -fsSL -o setup.sh https://github.com/makeplane/plane/releases/latest/download/setup.sh ./setup.sh # Community Edition
The hardware floor: the commercial install wants 2 CPU cores (x64 or ARM64) and 4 GB RAM (8 GB recommended) on Ubuntu, Debian, CentOS, Amazon Linux, macOS, or WSL2; Plane's overall self-hosting guidance states 4 CPU cores, 8 GB RAM, and 50 GB storage as the safe minimum, with images under 2 GB. Bring your own Postgres, Redis, and S3-compatible storage if you have opinions about your stack; Kubernetes installs go through the Helm chart, and a Coolify one-click path exists for the managed crowd. A God Mode admin panel manages the instance, and an air-gapped edition covers the disconnected. One honest caveat: installing it is the easy half — backups, updates, and uptime are yours now, which is why the VPS-hosting homework matters. Our what is VPS hosting guide explains the server shape you are renting before you put a production tracker on it.
One line for the advanced crowd, never the spine of this guide: Plane Compose is project-as-code — you define the project structure, schema (states, labels, workflows, work item types), and work items in YAML files, version them with Git, and sync with plane init, plane schema push, plane push, and plane pull (installs with pipx install plane-compose, Python 3.10+). If Git itself is still fuzzy, our Git beginner guide is the prerequisite.
Should You Switch: Plane vs Jira, Linear, and Asana?
Plane's whole market position is "get out of Jira, Linear, ClickUp, Asana, or Monday without leaving your data behind" — the vendor ships importers for Jira, Linear, Asana, ClickUp, CSV, Confluence, and Notion, publishes a savings calculator claiming teams "slash your bills by more than 70%" versus Jira + Confluence (its worked example shows $2,084.40/year down to $720 for 10 users — the vendor's own marketing figure, re-run it with your numbers), and notes that "two Fortune 10 companies chose Plane for their Jira migration." If your shortlist is plane vs linear, the honest split is ownership: Linear is the polished cloud SaaS; Plane is the open-source, self-hostable platform with a free tier. Here is the honest comparison a beginner needs:
| Plane | Jira | Linear | Asana | |
|---|---|---|---|---|
| Open source | Yes — AGPL-3.0 (copyleft: hosting a modified version as a service means releasing your changes) | No | No | No |
| Self-hostable | Yes — Docker Compose, Kubernetes, air-gapped | No (cloud/SaaS) | No (cloud/SaaS) | No (cloud/SaaS) |
| Sprint model | Cycles with velocity + burn-down | Sprints | Cycles | Sprints (via projects) |
| Entry price | $0 for 12 seats | Check the vendor's current page | Check the vendor's current page | Check the vendor's current page |
| Built-in docs | Pages, in-project | Confluence (separate product) | Separate product | Docs (in-product) |
| Git-native automation | GitHub/GitLab integrations, open API, webhooks, native MCP server | Yes, deep | Yes, deep | Yes |
One lane line, said once: Asana sits in the proprietary-SaaS lane (our queued Asana guide covers that world on its own terms) — Asana is the cloud product you rent, Plane is the open-source platform you can own; never treat them as the same decision. Linear is the same kind of proprietary issue tracker and a future candidate for its own beginner guide, not this page's subject. Choose Plane when self-hosting, data control, or the $0-for-12-seats start matters more than the incumbent's ecosystem; stay put when your team's muscle memory and integrations are already deep — migration importers move data, not habits.
What Are the 7 Mistakes Every Plane Beginner Makes?
Learn these from a table instead of from a quarter of bad habits:
| # | Mistake | What to do instead |
|---|---|---|
| 1 | Skipping the Project ID decision | Choose the short permanent prefix (≤10 chars) at creation — it brands every work item forever |
| 2 | Leaving projects Public by default | Public is the default — flip sensitive projects to Private at creation, not after |
| 3 | Freeform labels per work item | Define the label vocabulary at the project level first; filters depend on it |
| 4 | Packing the first cycle to look productive | New team: 3–5 items. Let the burn-down teach you the real velocity |
| 5 | Turning on every feature at setup | Start with Views + Pages on; enable modules, initiatives, and automations when a need appears |
| 6 | Running the self-host install without a backup plan | The install is one command; backups, updates, and uptime are a second project — plan them |
| 7 | Writing docs in another tool | Use Pages inside the project — cycle notes and RFCs next to the work items they describe |
Which Integrations Matter on Day One?
Connect two on the first day and ignore the catalog: the GitHub integration (branches and PRs link to work items, so the code trail attaches to the task) and Slack (notifications where the team already is). The rest — GitLab, Sentry, Draw.io, the open API and webhooks, and the native MCP server at mcp.plane.so for AI agents — earn their place once the workflow is real. If GitHub workflows are new to your team, our GitHub beginner guide covers repos, branches, and pull requests first.
Sources
- plane.so — homepage: "Project management and knowledge management for teams and agents," "Cloud, self-hosted and air-gapped ready," AI-native positioning, views (Board, Spreadsheet, List, Gantt), cycles with velocity and burndown, initiatives, built-in docs (Pages)
- plane.so/pricing — Free $0/seat/month (12 users, core features), Pro $6/seat/month, Business $13/seat/month, Enterprise Grid on request; self-hosted same plan structure; importers (Jira, Linear, Asana, ClickUp, CSV, Confluence, Notion); savings calculator ("slash your bills by more than 70%", $2,084.40/yr → $720 for 10 users example); integrations (GitHub, GitLab, Slack, Sentry, Draw.io), open API, webhooks, OAuth apps, native MCP server
- docs.plane.so/core-concepts/projects/overview — project = work items + cycles + modules + pages; create via Work → Projects → Add Project or N then P; name ≤255 chars unique in workspace; Project ID required, auto-suggested, letters+numbers, ≤10 chars, unique; Network Public (default) vs Private; creator becomes admin; Views + Pages on by default; archive vs delete (permanent, type name + "delete my project")
- docs.plane.so/introduction/tutorials/overview — tutorial timeboxes: Create workspace 5 min, Invite members 3–5 min, Create projects 8–10 min, Create work items 8–10 min, Collaborate on work items 10–12 min, Organize and view your work 12–15 min, Plan with Cycles, Write content with Pages 5 min
- docs.plane.so/introduction/tutorials/create-project — 8–10 minute walkthrough: Projects sidebar → Browse all projects → Add Project → name → Project ID → access → Create project → accept feature defaults → configure workflow states → add team members → add labels
- docs.plane.so/introduction/tutorials/create-work-items — work items are "the fundamental building blocks in Plane"; Add work item top-right; State (five groups: backlog, unstarted, started, completed, cancelled), Priority, Assignees, Labels, Dates; unique ID (ENG-1, PROJ-1); List default, Board drag-and-drop; unfinished items auto-save to Drafts; peek view and full view; auto-save
- docs.plane.so/introduction/tutorials/plan-and-create-cycles — cycles are "time-boxed containers"; Cycles → Add cycle with title, description, start/end dates; recommended 2-week first cycle; Active/Upcoming/Completed; completion %, burn-down chart, work-item breakdown, team velocity; scope: new team 3–5 items, experienced 5–8, solo 2–4; incomplete items move to next cycle or backlog
- developers.plane.so/dev-tools/plane-compose — Plane Compose: project-as-code CLI; YAML-defined project structure, schema, and work items; Git version control; plane init / plane schema push / plane push / plane pull; pipx install plane-compose, Python 3.10+
- developers.plane.so self-hosting docker-compose — Commercial: curl -fsSL https://prime.plane.so/install/ | sh -; prerequisites 2 CPU cores x64/ARM64, 4 GB RAM (8 GB recommended), Ubuntu/Debian/CentOS/Amazon Linux/macOS/WSL2; Community: setup.sh from latest GitHub release; Kubernetes via Helm; bring your own Postgres, Redis, S3-compatible storage; God Mode admin panel; air-gapped edition
- plane.so/self-hosted — overall minimum 4 CPU cores, 8 GB RAM, 50 GB storage; under 2 GB images; "the only modern project management platform built for environments where you control every layer"
- github.com/makeplane/plane — 61,830 stars, 6,272 forks (fetched 2026-11-02); license AGPL-3.0; tagline "open-source project management tool to track issues, run cycles, and manage product roadmaps"; created 2022-11-19; default branch preview; 67 releases; React Router + Django + Node.js stack
- elest.io/open-source/plane/resources/quickstart — hosting-provider quickstart (workspace, project, cycles); the only non-vendor guide found; deployment/login focused, not a usage walkthrough
- open-source-tools.com Plane page — latest release v1.4.2 (stats refreshed Oct 9, 2026); snaplyze.cc piece ~3 days old corroborates recency
Frequently Asked Questions
Is Plane really free, and what is the catch?
Yes — the Free plan is $0 per seat per month for up to 12 users with core features, on Cloud or self-hosted, with no license key. The catch is the seat cap and the feature ceiling: past 12 seats, or for Pro/Business/Enterprise features, you pay per seat ($6 Pro, $13 Business at list). Pricing figures move, so re-check the vendor's pricing page before you budget.
Is Plane open source? What does the AGPL-3.0 license mean for my team?
Plane is genuinely open source under the GNU Affero General Public License v3.0 — not MIT or Apache. The AGPL's copyleft clause matters if you modify Plane and run it as a service for others: you must release your changes. Using it unmodified for your own team, or self-hosting it as-is, has no such obligation. Read the license itself before building a business on a fork.
How do Plane cycles compare to Jira or Linear sprints?
The mechanics are the same idea under a different name: a time-boxed container (the vendor recommends 2 weeks) with a burn-down chart, completion percentage, and velocity tracking. The differentiator is not the cycle itself but the platform around it: open source, self-hostable, $0 for 12 seats, and built-in Pages docs in the same project.
Can I self-host Plane on my own VPS?
Yes — one command via the Prime CLI (Commercial) or setup.sh (Community), on a server with at least 4 CPU cores, 8 GB RAM, and 50 GB storage per the vendor's guidance. You bring Postgres, Redis, and S3-compatible storage if you want; Kubernetes/Helm and air-gapped editions exist too. Remember the install is the easy half — backups and updates are yours.
How long does it take a beginner to get productive in Plane?
The vendor's own tutorial timeboxes add up to roughly an hour of guided setup: 5 minutes for the workspace, 3–5 for members, 8–10 each for the first project and first work items, 10–12 for collaboration, 12–15 for views, then cycles and pages. A team can declare its first cycle the same afternoon — the learning curve is the discipline (labels, scoping, reviews), not the interface.
