dotpm: Full Project Management in Obsidian as Plain-Text Markdown

What It Is

dotpm (Obsidian community plugin "project-manager") brings native project management into Obsidian using pure Markdown storage. Unlike simple to-do plugins, it delivers a complete toolset: arbitrarily nested tasks, dependency links, Gantt charts, time tracking, custom statuses and fields — features that in Notion require multiple linked databases. Its deliberate trade-off: no cloud, no subscription, no lock-in. Data remains ordinary files editable in any editor; uninstalling dotpm leaves your tasks intact as Markdown.

Vault as Database: Core Mechanism

The key insight: tasks and projects exist as plain-text files; three views are merely different renderings of the same data. A project is a folder (default Projects/) containing .md files. Each task file uses YAML frontmatter for structured fields:

--- pm-task: true title: "Release v1.0" status: in-progress priority: high due: "2026-04-01" progress: 60 assignees: ["alice", "bob"] dependencies: ["task-abc123"] ---

Task description follows in Markdown body. dotpm parses YAML into in-memory objects, renders the requested view (table/Gantt/Kanban), and writes changes back to files. The plugin has zero runtime dependencies — package.json dependencies is empty; rendering engine, Gantt SVG, and date calculations (using Temporal) are hand-written. This keeps the plugin light and supply-chain-risk-free, but increases engineering burden, a reason for its single maintainer.

Three Views, One Dataset

Table view : sortable, filterable grid with inline editing; save named filter+sort combos; bulk actions on selected rows.

Gantt view : draggable timeline; adjust scheduling by dragging bars, resize duration, dependency arrows, diamond milestones, "today" line; zoom from day to year.

Kanban view : cards grouped by status; drag cards across columns to update status; cards show priority, assignee, tags.

The Gantt view best demonstrates the plugin's depth: it implements real dependency-driven scheduling, not just bar drawing.

Dependencies & Smart Scheduling: Real Project Management

Many to-do plugins lack dependencies. dotpm implements:

Dependency links : tasks declare "blocked by" / "depends on"; visualized as arrows on Gantt.

Smart scheduling : when a predecessor's date changes, all downstream tasks auto-adjust — no manual cascade.

Cycle detection : adding a dependency that would create a loop (A→B→A) is rejected.

Early-completion pull (optional): if a predecessor finishes early, successors shift earlier by the same days while preserving their own buffers.

The scheduling engine ( src/store/Scheduler.ts) uses BFS traversal from a changed task to find all downstream dependents, then recomputes start and due per dependency. Cycle detection checks reachability before adding an edge. Cross-project dependencies are supported: a task can reference a task in another project as a predecessor, constraining dates without modifying the other project. Milestones (zero-duration), recurring tasks (daily/weekly/monthly/yearly), and effort estimation vs. actuals (with date-stamped logs) are also built in.

Customizable to Your Workflow

Custom fields : text, number, date, single/multi-select, people, checkbox, URL — per project.

Custom statuses & priorities : rename, recolor, re-icon; each project can override globals.

Team roster : global member list for cross-project assignment; per-project overrides.

Saved views : store frequent filter+sort combos for one-click switching.

Archive : move completed tasks to archive instead of deleting; auto-archive after N days.

Team Collaboration & Sync: Data Stays Yours

Because everything is files, syncing equals syncing your vault:

Git commit/push/pull; conflicts appear as standard Markdown conflicts.

Obsidian Sync, iCloud, Dropbox, Syncthing work out of the box.

Deadline reminders are local notifications — no server involved.

The author explicitly draws a line: no real-time multi-user editing . Simultaneous edits on the same task produce sync conflicts, just like any Markdown note. Sufficient for solo/small teams; unsuitable for concurrent editing needs.

Getting Started

Install via Obsidian → Community plugins → search "dotpm" (ID: project-manager). For bleeding edge, use BRAT with beta source. After enabling, open the dashboard icon or command "Open projects pane", click "New project", and start adding tasks. Useful commands: import existing notes as tasks (with field mapping), mark current file as project, undo/redo. Supports migration from TaskNotes plugin, preserving status, priority, dependencies, recurrences.

Limitations & Boundaries

Maintenance load : single hobbyist maintainer; strict contribution rules (discuss in Issue first, no bulk AI-generated PRs). Stable but slower feature velocity.

No real-time collaboration : teams needing simultaneous editing will be disappointed.

Markdown file storage : hundreds/thousands of tasks mean many files, relying on filesystem organization.

Learning curve : must grasp "task = file + YAML" mental model, steeper than click-to-use to-do lists.

How the Scheduling Algorithm Works

Inspecting src/store/Scheduler.ts reveals a full dependency-graph computation:

Graph traversal : BFS from a task to collect all direct/indirect downstream tasks.

Cycle detection : before adding edge A→B, check if B already reaches A via existing edges; if yes, reject.

Date propagation : when a predecessor's date changes, traverse downstream and recompute start / due per dependency.

Early-completion pull : saved days passed downstream; successors shift earlier but keep their own buffers.

Cross-project constraints : reference external project tasks as predecessors; only constrain local dates, never modify the other project.

Semantic handling of task state: completed/cancelled tasks are treated as history — their dates are frozen during scheduling, preventing annoying cascade from editing a finished task. Boundary conditions (e.g., cannot shift before predecessor's completion day) are handled. Engineering maturity far exceeds typical community plugins.

Comparison with Other Obsidian Task Plugins

Tasks plugin : best text-based to-do engine; aggregates - [ ] tasks across notes via query syntax. No Gantt, no dependencies, no project-level views — essentially a list enhancer.

Projects plugin (obsidian-projects) : official team's project view; table/card/board but leans content organization; lacks dependencies, scheduling, effort tracking.

Kanban plugin : dedicated Kanban; simple, but no Gantt, dependencies, field system.

dotpm : only one offering "complete project management" — Gantt + Kanban + table + dependencies + scheduling + custom fields + effort tracking in a single plugin.

In short: Tasks solves "to-dos"; dotpm solves "projects". If you only need checkboxes in notes, Tasks is lighter. For real projects with timelines, dependencies, milestones, dotpm is currently the most complete in the Obsidian ecosystem.

Hand-Written UI Trade-offs

dotpm's distinctive technical choice: zero runtime dependencies . package.json dependencies empty — Gantt is hand-written SVG, date math uses Temporal, all UI components (table, Kanban, dropdowns, modals) hand-coded.

Benefits:

Small bundle, fast load — no hundreds of npm packages.

No supply-chain risk — third-party library issues can't break it.

Predictable behavior — author controls every line.

Cost: massive engineering effort. Hence single maintainer, strict contribution gates (Issue-first, no AI bulk PRs) to keep codebase human-readable and maintainable. For users, this signals intentional sustainability over feature bloat.

Mobile & Cross-Platform

dotpm is not desktop-only; manifest sets isDesktopOnly: false. On mobile, Gantt, Kanban, drag-to-reschedule all work. Paired with Obsidian Sync or iCloud, projects planned on desktop are instantly viewable/editable on phone. Critical for "data follows you" philosophy: because data is plain files, mobile needs no special sync — sync the vault, sync the project.

Data Portability: Migration & Export

This is dotpm's most underestimated value. Since every task is a Markdown file:

Migrate to another tool? Tasks are text; export/convert is trivial.

Backup? One Git commit = full snapshot.

Ten years later, plugin unmaintained? Data remains — ordinary files openable in any editor.

Contrast with SaaS that offer "export PDF" as openness; once off their platform, data is often unusable. dotpm avoids the trap at the root — it never holds your data; it only reads files, renders, writes back.

Origins & Background

Author is an independent developer maintaining dotpm in spare time; website dotpm.pm is his. Created late March 2026, iterated to 2.3.1 in five months — very active (latest commit Sep 7), only 1 open Issue, indicating healthy maintenance. README repeatedly emphasizes "solo hobbyist maintenance", hence strict contribution rules: new features/architectural changes must be discussed in Issues first; no bulk AI-generated code; PRs must address a single issue. This "slow but steady" attitude preserves code quality — key to its foothold in the community plugin directory.

Positioning vs. Notion / Jira

dotpm does not aim to replace Notion/Jira. Clear positioning:

Notion/Jira : cloud collaboration, real-time multi-user, permission systems, complex workflows — fit formal projects needing deep team coordination.

dotpm : local-first, plain text, data ownership — fit heavy Obsidian users, indie developers, small teams unwilling to surrender project data to third parties.

If your core need is "data absolutely mine, Git-committable, lives alongside notes", dotpm is the most complete in its class. If you need real-time team co-editing, it's not for you.

Who Should Use It

Obsidian power users : already keep all notes/knowledge in vault; add projects to manage everything in one vault.

Indie devs / small teams : manage code and projects with Git; one commit backs up both.

Data-sovereignty advocates : tired of SaaS lock-in and painful exports.

Personal GTD / task management : want Gantt, dependencies, effort tracking without introducing a cloud service.

Design Philosophy Worth Remembering

Even if you don't adopt dotpm, its "vault as database" idea is worth studying: compress all application complexity into an open, portable plain-text format, reducing sync and backup to native filesystem capabilities .

This isn't new philosophy, but dotpm proves it in "project management" — a domain assumed to require heavy databases and cloud. It demonstrates that power and autonomy can coexist, provided you're willing to pay the engineering cost for "data freedom". And that is exactly what SaaS locking data on their servers least want you to realize.