📝 Lesson 7.1: Task & Project Management in Obsidian

Tasks Where Your Thinking Lives

Most people keep to-dos in one app and knowledge in another. It feels tidy, but it quietly costs you. The task "email Dr. Chen about the grant" has no idea it belongs to your Grant Application note. The task "test the login bug fix" is divorced from your Auth Refactor project. Every time you want context you jump apps, lose your place, and the two systems drift out of sync.

Obsidian's pitch is simple and powerful: write the task exactly where the thought happened — in your meeting note, your project note, your daily note — and let the software gather it back up for you. The checkbox stays anchored to its context forever, but you still get a single, always-current list of what's due. Think of it as the difference between a shoebox of loose receipts and a ledger that reads every receipt automatically.

Native Markdown Checkboxes

Before any plugins, Obsidian speaks checkboxes out of the box. A checkbox is just a list item whose bullet is followed by square brackets:

- [ ] Book the dentist
- [x] Pay the electricity bill
- [ ] Draft the project brief
    - [ ] Outline goals
    - [x] Gather last year's numbers

Here's what each part does:

• - starts a normal Markdown list item (a * or + works too).
• [ ] — a space between the brackets — renders as an empty checkbox.
• [x] — an x between the brackets — renders as a checked box, usually with the text struck through.
• Indent with a tab or spaces to make subtasks, exactly like a nested list.

In Reading view (and in Live Preview) those brackets become real, clickable boxes. Click one and Obsidian edits the underlying text for you — it literally changes [ ] to [x] in the file. That's the whole trick: the checkbox is plain text, and the tick is just a character. Your tasks are as portable and future-proof as every other note in your vault.

⚠️ Important Note: A checkbox needs the space inside the brackets to be empty: - [ ], not -[ ] or - []. If your boxes aren't rendering, 95% of the time it's a missing space after the dash or missing space inside the brackets.

The Tasks Plugin & Its Emoji Metadata

Native checkboxes are great for a single note. But you can't ask them questions like "show me everything due before Friday." That's what the Tasks community plugin adds. Install it from Settings → Community plugins → Browse → "Tasks", then enable it.

Tasks works by letting you decorate an ordinary checkbox with emoji metadata. Each emoji is a signpost that says "the thing after me is a date / a priority / a recurrence rule." You never have to memorise them cold — the plugin ships a "Create or edit task" command (open the Command palette with Ctrl/Cmd+P) that gives you a friendly form and writes the emoji for you. But it helps to read them:

Put together, a fully specified task looks like this — still just one line of Markdown:

- [ ] Submit quarterly report 🔼 🛫 2026-09-15 ⏳ 2026-09-16 📅 2026-09-18 🔁 every 3 months

Read it left to right: a medium-priority task you shouldn't start before the 15th, plan to work on the 16th, that's due the 18th, and recurs quarterly. When you tick a recurring task, Tasks marks this one done (stamping ✅ with today's date) and automatically writes the next occurrence right above it with the dates rolled forward. That alone is worth the install.

Now the payoff. A task's life moves through a small set of states, and the Tasks metadata is what lets your queries know where each one sits:

Querying Tasks Across Your Vault

Here's where it stops being a checklist and becomes a system. Anywhere in any note you can drop a tasks query block — a fenced code block whose language is tasks. Each line inside is a filter, sort, or grouping instruction written in near-plain English. Tasks scans your entire vault, finds every checkbox that matches, and renders a live, clickable list right there in the note.

Example 1 — everything still open, due on or before today, most urgent first:

```tasks
not done
due before tomorrow
sort by priority
sort by due
```

Example 2 — this note as a mini project view: open tasks that live in this same file, grouped by their due date:

```tasks
not done
path includes {{query.file.path}}
group by due
sort by due
```

Example 3 — a "waiting / high priority" board: open, high-or-higher priority tasks tagged #task, hiding the little metadata icons for a cleaner look:

```tasks
not done
priority is above medium
tags include #task
hide priority
hide task count
```

The filter vocabulary is large but learnable. A few of the most useful lines:

• not done / done — completion state.
• due before tomorrow, due after 2026-09-01, due this week, no due date — date filters (also scheduled, starts, happens).
• path includes Projects/ — only tasks in files under a folder.
• heading includes Follow-up — only tasks under a matching heading.
• tags include #work — only tasks carrying a tag.
• sort by (priority, due, scheduled, path…) and group by (due, priority, folder, heading, happens…).
• limit 20, hide edit button, short mode — presentation tweaks.

Dataview TASK & Project Notes

You met Dataview back in Lesson 6.2 as the plugin that queries your notes like a database. Dataview can query tasks too, with its TASK query type. So which do you use?

A Dataview TASK query reads like its other queries — it just returns checkboxes:

```dataview
TASK
FROM "Projects"
WHERE !completed AND due <= date(today) + dur(7 days)
SORT due ASC
```

This gathers incomplete tasks from notes in your Projects folder that are due within a week. Dataview's checkboxes are clickable too, and it groups them under the note they came from. Use whichever plugin's mental model fits the question you're asking — many people keep both installed and reach for Tasks day-to-day, Dataview when metadata is doing the driving.

Project notes that aggregate their own tasks

A project note is one of the most satisfying patterns in Obsidian. You make a single note per project — Kitchen Renovation, Q4 Launch, Master's Thesis — and inside it you write the tasks as you think of them, then let a query pull them into a live status list. Skeleton:

---
type: project
status: active
---
# Q4 Launch

## Notes
Kickoff was great. Design owns the hero image; eng owns the API.

## Tasks
- [ ] Finalise hero image #task 📅 2026-09-18
- [ ] Ship staging API #task 🔼 📅 2026-09-20
- [ ] Draft launch email #task ⏳ 2026-09-22

## 📌 Open items (auto)
```tasks
not done
path includes {{query.file.path}}
sort by due
```

Everything is in one place: the narrative, the raw tasks, and a self-updating rollup. Because the query filters on this file's path, the same block works unchanged in every project note you create — copy it once, paste it forever.

Kanban & a Simple GTD Setup

Some projects think in lists; others think in columns. Back in Lesson 6.4 (and again in the Visual Thinking lesson you just finished) you met the Kanban community plugin, which turns a note into a drag-and-drop board of "To Do → Doing → Done" columns. It stores the board as plain Markdown checkboxes under headings, so a Kanban board and a task query can read the very same file. Reach for Kanban when you want to see flow — what's stuck, what's moving — and for lists when you want to see deadlines. They're two windows onto the same notes.

A lightweight GTD-style setup

GTD (David Allen's Getting Things Done) boils to five moves: capture, clarify, organise, reflect, engage. You can run a perfectly good GTD system in Obsidian with almost no ceremony:

• Capture — throw every task into your daily note the instant it appears, as - [ ] … #task. Don't sort yet; just get it out of your head.
• Clarify — once a day, add a due date (📅), a priority, or a project tag to each new task. Two-minute jobs? Just do them and tick.
• Organise — move project-bound tasks into their project note; leave standalone ones where they are. The tag is what matters, not the location.
• Reflect — a weekly review note with a ```tasks block for due this week and another for no due date (your someday/maybe pile).
• Engage — every morning, open your Task Dashboard (the project below) and work the top of the list.

🎯 Project: Your Task Dashboard

Time to build the note you'll open every morning: a single dashboard that surfaces everything open and due this week, pulled live from across your whole vault. When it works, you'll wonder how you tracked tasks any other way.

# 📋 Task Dashboard

## 🔴 Overdue
```tasks
not done
due before today
sort by due
```

## 📅 Due this week
```tasks
not done
due after yesterday
due before in 7 days
sort by priority
sort by due
group by due
```

## 🌫️ No date yet (triage these)
```tasks
not done
no due date
sort by priority
limit 15
```

Best Practices for Task Management

✅ Do's

• Capture in context. Write the task in the note that spawned it, not in a far-off list.
• Give dashboard tasks a due date. Undated tasks vanish from date-based queries — schedule them or triage them.
• Reuse one path includes {{query.file.path}} block across all project notes for instant rollups.
• Let recurring tasks recur. 🔁 turns chores into a self-refilling list you never rebuild.

❌ Don'ts

• Don't over-tag. If a global filter of #task feels heavy, leave it blank and let every checkbox count.
• Don't mix ten date types on one task. Most tasks need only a due date; add start/scheduled only when they genuinely differ.
• Don't build queries you won't read. One dashboard beats twelve clever views nobody opens.

📓 Learning Journal

📝 Lesson Summary

🎉 What You've Accomplished

You've turned your vault into a real task manager — one where a to-do lives beside the thinking that created it, yet still rolls up into a single morning dashboard. You can write, decorate, and query tasks, and you have a lightweight GTD loop to keep them flowing. That's a genuinely capable productivity system, built entirely from plain text you own.

❓ Common Questions at This Stage

🔭 Looking Ahead

Your task system now lives inside your vault — which means it's only as safe as your vault is. In the next lesson we make sure your notes exist in more than one place and can survive a mistake or a dead drive: the crucial difference between sync and backup, and how to set up both for free or cheaply.

✅ Before the Next Lesson

• Use your Task Dashboard for at least one real morning
• Convert one recurring chore into a 🔁 recurring task and tick it once to see it regenerate
• Write your Learning Journal entry for this lesson

📚 Additional Resources

• Tasks plugin — official documentation
• Obsidian Help — formatting notes (checklists)
• Dataview — query types, including TASK