I run an agency and with 18 clients and 27 open projects, knowing what to work on can be overwhelming.

I've been investing deeply in automation, building up my agency, and one of the problems I keep running into is of all the things I'm building, what needs work right now?

None of them had a backlog. Not a real one. A few had TODOs buried in code comments. One had a detailed feature list in a markdown file. The rest had nothing — just git histories and vibes.

I use Notion for my agency. It collaborates all of the work that's systematized throughout the team. That's not my problem. The problem is answering “what should I work on next?” I'm the implementer, the automator, the guy who figures out what is the thing that we're going to do ten times faster next week. That is very high leverage, but it also means I need to know what to work on next.

The Obvious Fix Doesn’t Work

A single central backlog breaks down fast. At three projects, it’s fine. At twenty-seven, I ended up scrolling through a wall of all these tasks, wondering what the heck they were for. So now context lives in each directory.

https://preview.redd.it/s6uq6zafonmg1.png?width=1919&format=png&auto=webp&s=8388ad1a5ba2e7245f59bf78679bbd4a0962ce91

Per-project backlogs are better — the tasks live next to the code. But then you lose the cross-project view. You can’t ask “which projects have unfinished API work?” without opening every folder.

Per-Project Kanban Boards + Semantic Search

https://preview.redd.it/7rkscf4ionmg1.png?width=1919&format=png&auto=webp&s=dca5001547ad4765b284c42e7683bbba539d0d86

So, what I've built out now is a Kanban board for every project to give every project its own trackability, then I pointed a search engine at all of them. Tobias Lütke from Shopify rolled out QMD Search, which is a custom vector search database that works really nicely with Obsidian Markdown files.

Each project gets a BACKLOG.md that’s an Obsidian Kanban board:

---
kanban-plugin: basic
---
## Next
- [ ] Complete initial build beyond scaffold [added::2026-02-26]

## In Progress

## In Review

## Backlog
- [ ] Twilio integration [added::2026-02-26]
- [ ] SMS notification system [added::2026-02-26]

## Done

## Cancelled

Drag cards around in Obsidian. It’s markdown underneath — any tool can read it.

The boards live in each project directory. You see them in the side bar here in Obsidian, but that's a lie. They're actually Symlinks from the development folder to the Obsidian vault so I can see and edit all 24 boards without leaving the app.

For the cross-project view, I use two tools:

QMD indexes every markdown file across all 27 projects — backlogs, READMEs, design docs, everything. It runs BM25 keyword search, vector similarity search, and LLM reranking, all locally. No API calls, no cloud.

$ qmd query "which projects need video processing work" -c dev
video-pipeline/docs/plans/2026-02-24-video-translation-pipeline.md  Score: 38%

Dataview gives me a dashboard inside Obsidian — task lists filtered by column, a project health table, and a live bar chart showing how many tasks sit in each stage across all 24 projects.

The chart is a DataviewJS block that queries every backlog, counts tasks per column, and feeds the numbers to the Obsidian Charts plugin:

const pages = dv.pages('"work/dev-projects"')
  .where(p => p.file.name !== "Dashboard");
const columns = ["Next", "In Progress", "In Review", "Backlog", "Done", "Cancelled"];

const counts = columns.map(col =>
  pages.flatMap(p => p.file.tasks)
    .where(t => t.section?.subpath === col && !t.completed).length
);

window.renderChart({
  type: "bar",
  data: { labels: columns, datasets: [{ data: counts }] }
}, this.container);

Fifteen lines. Updates live when you drag a card. No build step, no database, no API.

This gives you all the power of crazy Jira roll-up boards locally on your computer, basically with no overhead at all.

The Setup

Five pieces, about an hour to wire up:

1. Template — an empty Kanban board with six columns (Next, In Progress, In Review, Backlog, Done, Cancelled)
2. Per-project boards — copy the template into each project, seed with known tasks
3. Symlinks — a shell script links each BACKLOG.md into the Obsidian vault
4. QMD collection — qmd collection add ~/dev --name dev --mask "**/*.md" && qmd embed indexes 163 files across all projects
5. Daily automation — two launchd plists: auto-cancel stale items at 6am, reindex at 6:05am

Total new code: one Python script (50 lines), two shell scripts, two launchd plists. If you're on Windows, use Cron instead of launchd.

Same Pattern, Different Problem

I've written about this before (on other channels, this is my first time posting here in Reddit. :P ) We use the same Kanban-board-plus-watcher pattern to route our LLM agents to different models and to dispatch tasks to AI agents. Obsidian boards as the interface, small scripts as the glue, markdown as the source of truth.

The backlog system doesn’t even need a watcher. QMD indexes on a schedule. Dataview queries live. The Kanban boards are the state.

This gives me instant visibility and control of what's happening in all of the AI projects I'm building. Helps me find out what I need to be working on and feed all the exact right context to my AI agents at the moment that they're working on something

Hope you find it useful.