Best Boilerplates for PM Tools in 2026

Project management is one of the most competitive SaaS categories — Notion, Linear, Jira, Asana, Monday, Basecamp, ClickUp — yet new PM tools keep shipping. The reason is specialization: general-purpose PM tools serve everyone adequately but nobody exceptionally well. The successful new entrants are domain-specific: Linear for software teams, Harvest for time tracking, Airtable for data-heavy workflows.

The right question before choosing a boilerplate is not "how do I build the next Jira?" but "what specific problem does my target market solve with duct tape today that I can replace with a proper PM tool?"

Build vs Use an Existing Tool

Build a PM tool when:

• Your product is purpose-built for a specific industry (construction PM, film production PM, event planning PM)
• PM features are deeply integrated with domain-specific logic (a software tool where tasks link to code commits, deploys, and monitoring alerts)
• You're building a white-label PM platform that other businesses will resell
• Existing tools charge per-seat pricing that doesn't match your customer's economics

Don't build when:

• You just need a PM tool for your own team — use Linear, Notion, or Asana
• The PM features are secondary to the core product (add a task list UI to a CRM, don't build a full PM platform)

Best Foundation Starters

Plane — Best Open Source PM Platform

Price: Free (AGPL) | Creator: Plane team | Stack: Django + Next.js + PostgreSQL + Redis

The most complete open source project management platform available. Plane is a full Linear/Jira alternative with issues, cycles (sprints), modules, pages, inbox, and analytics. The UI is Linear-inspired — fast, keyboard-navigable, and opinionated in the right ways.

Tech stack: Django REST Framework backend, Next.js frontend, PostgreSQL for data, Redis for caching and real-time. The architecture is well-documented and the codebase is readable.

Use Plane for:

• Self-hosted PM tools where you need a working reference implementation
• Forking to build a domain-specific PM tool with Plane's architecture as the base
• Studying how a production-grade PM tool handles real-time updates, permissions, and notifications

Not ideal as a boilerplate starting point if: You're building a Next.js full-stack app — Plane's Django backend means you're running two separate stacks.

Focalboard — Best Notion Boards Clone

Price: Free (MIT) | Creator: Mattermost | Stack: Go + React + PostgreSQL

Focalboard is Mattermost's open source project board product, now available standalone. It focuses on the Notion-style blocks model: cards, tables, calendars, and galleries as different views of the same dataset.

The Go backend compiles to a single binary — simple to deploy, low memory usage. The React frontend handles complex board UIs well. Good reference for board-style views.

Use Focalboard for: Board/card UI reference and the Notion-style blocks architecture.

Custom Next.js Stack — Best for Integrated PM

Price: Free (dev cost) | Stack: Next.js, Prisma/Drizzle, Pusher/Supabase

For PM tools that need to be deeply integrated into another product (a CRM with a built-in task system, a helpdesk with project boards, a CMS with content pipeline management), building directly on Next.js provides the tightest integration.

Core PM Data Model

The foundation for any PM tool:

// Prisma schema for PM application:
model Project {
  id          String    @id @default(cuid())
  name        String
  description String?
  slug        String    @unique
  boards      Board[]
  members     ProjectMember[]
  owner       User      @relation(fields: [ownerId], references: [id])
  ownerId     String
  createdAt   DateTime  @default(now())
}

model ProjectMember {
  id        String  @id @default(cuid())
  project   Project @relation(fields: [projectId], references: [id])
  projectId String
  user      User    @relation(fields: [userId], references: [id])
  userId    String
  role      String  @default("member")  // owner, admin, member, viewer
  @@unique([projectId, userId])
}

model Board {
  id        String  @id @default(cuid())
  name      String  // "To Do", "In Progress", "In Review", "Done"
  color     String? // Column color in UI
  order     Int
  tasks     Task[]
  projectId String
  project   Project @relation(fields: [projectId], references: [id])
}

model Task {
  id          String    @id @default(cuid())
  title       String
  description String?
  order       Float     // Float for fractional indexing (easy reordering)
  priority    String    @default("medium")  // urgent, high, medium, low
  status      String    @default("todo")    // todo, in_progress, done
  assigneeId  String?
  dueDate     DateTime?
  labels      TaskLabel[]
  comments    TaskComment[]
  boardId     String
  board       Board     @relation(fields: [boardId], references: [id])
  createdAt   DateTime  @default(now())
  @@index([boardId, order])  // Essential for kanban column queries
}

Kanban Board: Drag and Drop

The heart of any kanban PM tool — smooth drag-and-drop task reordering:

// Fractional indexing for efficient reordering:
// No need to update order values for all other tasks
function getNewOrder(above: number | null, below: number | null): number {
  if (above === null && below === null) return 1000;
  if (above === null) return below! / 2;
  if (below === null) return above + 1000;
  return (above + below) / 2;
}

// Move task to new board + position:
const moveTask = api.tasks.move.useMutation({
  onSuccess: () => utils.boards.byProject.invalidate({ projectId }),
});

function handleDragEnd(result: DropResult) {
  if (!result.destination) return;

  const sourceBoard = boards.find(b => b.id === result.source.droppableId);
  const destBoard = boards.find(b => b.id === result.destination!.droppableId);
  const destTasks = destBoard.tasks;

  const taskAbove = destTasks[result.destination.index - 1];
  const taskBelow = destTasks[result.destination.index];

  moveTask.mutate({
    taskId: result.draggableId,
    newBoardId: result.destination.droppableId,
    newOrder: getNewOrder(taskAbove?.order ?? null, taskBelow?.order ?? null),
  });
}

The fractional indexing approach (using Float for order) means moving a task between two other tasks only requires updating the moved task's order — not recalculating every task's position in the column.

Real-Time Collaboration

PM tools need real-time updates when teammates move tasks, add comments, or create issues. Two approaches work well in 2026:

Supabase Realtime (if using Supabase):

// Subscribe to board changes:
const channel = supabase
  .channel(`project-${projectId}`)
  .on('postgres_changes', {
    event: '*',
    schema: 'public',
    table: 'tasks',
    filter: `project_id=eq.${projectId}`,
  }, (payload) => {
    if (payload.eventType === 'UPDATE') {
      utils.boards.byProject.invalidate({ projectId });
    }
  })
  .subscribe();

Pusher (for Node.js stacks):

// Server: broadcast board change:
await pusherServer.trigger(
  `project-${projectId}`,
  'task:moved',
  { taskId, newBoardId, newOrder, movedBy: userId }
);

// Client: receive update:
const channel = pusher.subscribe(`project-${projectId}`);
channel.bind('task:moved', () => {
  utils.boards.byProject.invalidate({ projectId });
});

Timeline and Gantt Views

For PM tools targeting teams with deadline-driven workflows (agencies, construction, events), timeline and Gantt views are expected features:

// Task with timeline fields:
model Task {
  // ... existing fields
  startDate   DateTime?
  endDate     DateTime?
  milestone   Boolean   @default(false)
  dependencies Task[]   @relation("dependencies")
  dependedOnBy Task[]   @relation("dependencies")
}

// Gantt data API — fetch tasks with date ranges for a project:
export const ganttRouter = router({
  byProject: protectedProcedure
    .input(z.object({
      projectId: z.string(),
      startDate: z.date(),
      endDate: z.date(),
    }))
    .query(async ({ input, ctx }) => {
      return ctx.db.task.findMany({
        where: {
          board: { projectId: input.projectId },
          OR: [
            { startDate: { gte: input.startDate, lte: input.endDate } },
            { endDate: { gte: input.startDate, lte: input.endDate } },
          ],
        },
        include: { assignee: { select: { name: true, avatar: true } } },
        orderBy: { startDate: 'asc' },
      });
    }),
});

For the Gantt UI rendering, react-gantt-chart or a custom SVG implementation works well in Next.js.

Notifications for PM Tools

PM tools need granular notifications: you're assigned a task, a task you're watching changes status, a comment is added to your issue, a task is nearing its deadline.

// Notification schema:
model Notification {
  id          String   @id @default(cuid())
  recipient   User     @relation(fields: [recipientId], references: [id])
  recipientId String
  type        String   // assigned, mentioned, status_change, due_soon, comment
  entityType  String   // task, project, comment
  entityId    String
  message     String
  read        Boolean  @default(false)
  createdAt   DateTime @default(now())
  @@index([recipientId, read, createdAt])
}

Notification preferences should be configurable per-project and per-notification type. Over-notifying kills adoption — give users control.

Feature Comparison with Leading PM Tools

When building a PM tool that competes in a category, know what the leaders offer that you need to match or deliberately omit:

Feature	Plane (OSS)	Linear	Notion PM	Your PM Tool
Kanban boards	✅	✅	✅	Build
Issue priorities	✅	✅	❌	Build
Sprints/cycles	✅	✅	❌	Optional
Git integration	❌	✅	❌	Optional
Timeline/Gantt	✅	✅	❌	Optional
Time tracking	❌	❌	❌	Opportunity
Custom fields	✅	✅	✅	Complex
API	✅	✅	✅	Important
Keyboard shortcuts	✅	✅	✅	Differentiator

Related Resources

For PM tools that need real-time collaboration features, see the best boilerplates for real-time collaboration. For community apps that integrate social features alongside project management, see best boilerplates for community apps.

Browse PM app and SaaS boilerplates at StarterPick — filter by real-time support, team features, and pricing model.

The Business Model Problem With Building a PM Tool

Before selecting a boilerplate, it is worth confronting the hardest challenge in the project management category: the competitive landscape. Linear, Asana, ClickUp, Notion, Jira, Monday.com, Plane, and Basecamp all have substantial engineering teams and established user bases. A generic PM tool that competes head-to-head with any of them will lose on features and on distribution.

The successful PM products built by indie developers and small teams in 2026 share a common pattern: they are deeply specialized. A PM tool for video production companies tracks shot lists, edit review rounds, and client approvals — workflows that ClickUp's generic task system handles awkwardly. A PM tool for architecture firms integrates with BIM software and tracks submission deadlines per municipality — something no horizontal PM tool does well. A PM tool for software agencies handles retainer tracking, client approvals, and invoice milestones as first-class features.

The implication for boilerplate selection: choose a foundation that does the core task management right, then invest your differentiation budget in the vertical-specific features. Plane's open-source codebase gives you a battle-tested Kanban + issue tracker foundation for free. Your differentiation comes from the features that Plane does not have and cannot have because they do not apply to general-purpose users.

This pattern also simplifies your go-to-market. Instead of convincing a marketing team to switch from ClickUp to your tool, you're selling to video production companies who are currently managing productions in spreadsheets because ClickUp is too generic. The specificity of the pitch — "PM for video production, not for everyone" — is both your positioning and your defense against larger competitors.

For the broader SaaS context around building tools in competitive categories, the best SaaS boilerplates guide covers how successful boilerplate-built products have found their niches.

Real-Time Collaboration Architecture for PM Tools

PM tools surface the real-time collaboration challenge more acutely than most SaaS categories. When two users move the same task card simultaneously, or when a comment appears on a task someone is currently editing, the system must resolve the conflict or at minimum ensure both users see a consistent state quickly.

The minimal real-time implementation for a PM tool is optimistic UI updates with Supabase Realtime or Pusher. When a user moves a card, the UI updates immediately and a database write is queued. A Supabase Realtime subscription on the board broadcasts the change to all connected clients within 100-200ms. This pattern handles the 95% case — concurrent edits to the same item are rare, and showing a brief inconsistency while the state resolves is acceptable for most PM workflows.

The more robust implementation uses operational transforms or CRDTs (Conflict-free Replicated Data Types) to merge concurrent edits without conflicts. This is the architecture behind Notion and Linear's real-time editing. It is significantly more complex to implement correctly and is rarely justified for PM tools where the primary collaboration pattern is sequential rather than simultaneous (user A assigns a task, user B picks it up — not user A and B editing the same text field at the same millisecond).

For teams building PM tools where real-time is a core selling point — shared dashboards, live sprint boards — the best boilerplates for real-time collaboration covers the specific infrastructure patterns in detail. For the majority of PM tools where real-time is a nice-to-have rather than a core feature, Supabase Realtime's broadcast channel provides a satisfactory real-time board refresh without CRDT complexity.

---

Browse PM app and SaaS boilerplates at StarterPick — filter by real-time support, team features, and pricing model.

See the best SaaS boilerplates guide for the full comparison including multi-tenant and team collaboration features.

Read the best free open-source SaaS boilerplates guide — Plane is listed as a free PM foundation.