GTD in O3PM – Managing actionable contexts through smart task queries in Obsidian

Intro

The Pain Point – A Hydra of Tasks

As a project manager, you learn quickly: tasks are like the heads of a hydra.
Finish one, and two more take its place.

Worse still, you’re not dealing with a single many-headed beast—you’re facing dozens, sometimes hundreds, at once. And these action items rarely have the decency to appear in clean lists or polished project plans. They ambush you in passing conversations, spill out of bloated meetings, crawl from the depths of grueling workshops or surprise you in your own throughts.

Many have tried to slay this beast. Paper piles, digital notebooks, Excel sheets, Jira tickets, Wrike dashboards, entire methodologies—looking at you, GTD—and more improvised systems tell the tales of battles past.

And while some are better than others—again, looking at you, GTD—none of them quite managed the all-too-necessary cauterization of the wound to keep the beasts at bay. At best, they help log what’s visible. At worst, they let half-formed tasks escape into the wild—only to return later, stronger and more chaotic than before.

Here the monster shows its other side, not through the number of tasks, but how disconnected and evasive they become as they seemingly develop a life of their own.

Even modern task management software falls short. You’re often left with bloated interfaces, duplicated entries, or suboptimal workflows that leave tasks disconnected from their context.

This clutter and fragmentation lead to a familiar pain: you know a task exists—but not where. You know someone is responsible—but you can’t see what else they’re holding. You know there’s a process—but it’s lost in the tools, not the work itself.

ORM – The Iolaus of Task Management

What I needed wasn’t just another task app or better habits—I needed an Iolaus: something that worked alongside me, automatically sealing the chaos before it spread.

A system that doesn’t rely on manual labor to keep things connected. One that automatically surfaces the right task at the right time, in the right place—no matter where I had written it down.

That idea becomes reality in Object-Oriented Project Management in Obsidian (O3PM).
In O3PM I can see every open, active or waiting task that is related to the object of interest.
What open tasks does Peter have? Is there something I need to get in the store or on the way to the office? What was Karen complaining about again? When does the car have to go into the shop? And what was it I wanted to pick up for Elene again?
These and many more questions O3PM answers with the press of a button through the Object Responsibility Module (ORM).

It turns every object within O3PM into a task-aware, responsibility-tracking dashboard that is fast, contextual, and always within reach. And all that without maintenance overhead.

It’s the Iolaus to your Heracles, quietly running in the background, keeping your project beast in check.

The Object Responsibility Module (ORM)

Setup

The Core Idea: Status Tags and Linked Context

The ORM uses the following three key building blocks:

Tasks – embedded in meeting notes, logs, or other object records.
Links – pointing to the objects that are resources or references to fulfill the task
Dataview – collecting the data based on linked objects and visualizing it

Tasks & Links – The Foundation

Tasks are written in natural language anywhere in the vault (project logs, meeting minutes, or scratch notes) and contain links to relevant objects. For example:

- [ ] [[Anna]] needs to check the air quality in [[Server Room]]

Thanks to backlinks the line becomes visible both in Anna’s and the Server Room’s digital twins, effectively tying objects to actionable responsibilities.

Task Status – The Marks

To track task status, we use simple, readable task states:

[/]: This is the current actionable task.
[<]: A delegated or paused task awaiting response.

How they look like in Obsidian:

These symbols are custom checkboxes rendered via markdown syntax and theme support.

In most instances, only one task per object is set to a the active or waiting status. As tasks are completed, the status of active or waiting is moved to the next line, creating a task chain—a lightweight, flowing queue of actions.

Dataview – The Engine Engine that powers it all

The Query

Here’s the Dataview query I use in object files (person, location or other entities) to surface all related, active tasks:

```dataview
TABLE WITHOUT ID 
    file.link + " | " + "[[" + file.name + "#" + meta(T.section).subpath + "|" + meta(T.section).subpath + "]]" AS "File & Heading",
    T.text AS Text 

FROM [[]]

FLATTEN file.tasks as T

WHERE (contains(T.status, "<") OR contains(T.status, "/")) AND !T.completed AND contains(T.text, this.file.name)
```

What This Query Does

TABLE WITHOUT ID 
	file.link + " | " + "[[" + file.name + "#" + meta(T.section).subpath + "|" + meta(T.section).subpath + "]]" AS "File & Heading",
	T.text AS Text

Creates a table with the following colums:
1. The link to the file and the link to the heading above the task.
2. the text of the task.
This way I have an overview over the object and the next task that must be completed to finalize it.
Possible parameters that can be added for additional information (more on these in future articles):
- status AS Status – the status of the object.
- urg + ” ” + prio AS “Imp.” – the urgency and priority in line with the Eisenhower-Matrix

FROM [[]]

Limits the query to object that link to the current file. This limit severely reduces the querie’s loading time.

FLATTEN file.tasks as T

Flattens the array in every row, yielding one result row per entry in the array. That way every task is shown in a seperate row, even if they belong to the same object.

WHERE (contains(T.status, "<") OR contains(T.status, "/")) AND !T.completed AND contains(T.text, this.file.name)

Filters to show only active ([/]) or waiting ([<]) tasks that mention the current file.

The result: a dynamic task dashboard per object, ready in milliseconds.

Why not Tasks Plugin

I specifically chose Dataview over the Tasks plugin for several reasons:

The Tasks plugin significantly slows my vault startup—critical when I need to jot down notes on the go or during client conversations.
I’m already more familiar with Dataview, which allows me to write complex queries quickly.
I want to future-proof my system for Datacore, an upcoming plugin by Dataview’s developer that promises native, high-performance data handling.

Why This Feels Like GTD

David Allen’s Getting Things Done (GTD) system encourages grouping tasks by contexts—@phone, @office, @waiting. O3PM elevates this idea: your object notes are your contexts.

A person-object gathers delegated responsibilities.
A location-object shows what needs doing there.
A system-object presents upcoming maintenance or updates.

You don’t manage lists—you manage responsibilities, where they belong.

This is GTD for the object age: contextual, relational, and resilient.

Task Chain Example

Following is an example of a task chain and the corresponding visualization of the relevant dataview query.

Starting position:

- [ ] [[Person 1]] has to do task at [[Location 2]]
- [ ] Inform [[Person 3]] about object progress.
- [ ] Receive response from [[Person 3]]

Activating the task chain

- [<] [[Person 1]] has to do task at [[Location 2]]
- [ ] Inform [[Person 3]] about object progress.
- [ ] Receive response from [[Person 3]]

First step – Completing task 1

- [x] [[Person 1]] has to do task at [[Location 2]]
- [/] Inform [[Person 3]] about object progress.
- [ ] Receive response from [[Person 3]]

Second step – Delegation and wait status

- [x] [[Person 1]] has to do task at [[Location 2]]
- [x] Inform [[Person 3]] about object progress.
    - [[MAIL - Inform Person 3 about Object status]]
- [<] Receive response from [[Person 3]]

This structure lets you track workflow in an object-bound way across all the vault’s files, without cluttering or losing context.

All active tasks

With a little tinkering, the query can be modified to visualize all active tasks accross the whole vault.

```dataview
TABLE WITHOUT ID
file.link + " | " + "[[" + file.name + "#" + meta(T.section).subpath + "|" + meta(T.section).subpath + "]]" AS "File & Heading",
T.text AS Text

FROM ""

FLATTEN file.tasks as T

WHERE (contains(T.status, "<") OR contains(T.status, "/")) AND !T.completed AND contains(T.text, this.file.name)

SORT
urg DESC,
prio DESC
```

❗Caution: Be aware that the query might take up a long time to complete for larger vaults.

Outro: Final Thoughts

If you’re managing projects where people, locations, systems, and responsibilities intertwine, this approach brings clarity without overhead. Your graph becomes your dashboard—and every object knows what it owes you.

With just a few backlinks and lightweight tags, Obsidian becomes more than a note-taking tool. It becomes your operating system for responsibility.