Obsidian as Your Second Brain: Knowledge Base, Projects, Kanban, Tasks & Meeting Notes

Introduction

One Obsidian vault, eight community plugins and one theme can replace a wiki, a project tool, a Kanban app, a to-do app and a meeting notebook. Everything lives in plain Markdown files you own, synced to a private GitHub repository.

The idea that makes it work: every to-do anywhere in the vault is a task. A line starting with - [ ] in a daily note, a meeting note, a project note or a Kanban card is picked up by the Tasks plugin. You write tasks where they come up, then let query blocks collect them into dashboards.

By the end of this tutorial you will have:

• A daily note template with sections for notes, personal to-dos, delegated to-dos, questions and knowledge base links
• Task dashboards that filter by due date, project, person and status
• Kanban boards that look like GitHub Projects, whose cards also show up in your task queries
• Project and meeting note templates that feed the same task system
• A knowledge base with tables and exportable diagrams
• Automatic backup to a private GitHub repo

Why this setup

Syncing the vault to a private GitHub repository gives you a full project management system and knowledge base that works across platforms. Obsidian runs on Linux, Windows and macOS, so the same vault, plugins, theme and settings follow you from machine to machine.

It is also free to run and fully configurable to your own requirements. Your data stays secure and private: plain Markdown files in a repository you own and manage, not locked into a vendor's cloud or proprietary format.

The plugin stack

Eight community plugins do the heavy lifting; two core plugins (Daily notes and Templates) tie them together. Install community plugins from Settings → Community plugins → Browse, then enable each one.

Plugin	Author	Version used	Job in this setup
Tasks	Clare Macrae, Ilyas Landikov (created by Martin Schenck)	7.21.0	Turns every - [ ] line into a trackable task; query blocks build to-do lists and dashboards
Kanban	mgmeyers	2.0.51	Markdown-backed boards for projects; cards are tasks too
Calendar	Liam Cain	1.5.10	Sidebar calendar to jump to (or create) any day's note
Advanced Tables	Tony Grosinger	0.22.2	Auto-formatting, Tab navigation and formulas in Markdown tables
Git	Vinzent	2.35.0	Version control and automatic sync to a private GitHub repo
Hearth	ondreu	1.15.0	Home screen: search, dashboard and launcher in one
Mermaid Exporter	Addo Zhang	1.1.0	Exports rendered Mermaid diagrams as PNG at a chosen resolution
Style Settings	mgmeyers	1.0.9	Exposes theme and plugin CSS variables as settings

Core plugins to switch on under Settings → Core plugins: Daily notes and Templates.

Theme: the community GitHub theme in dark mode (Settings → Appearance → Themes → Manage). Its colours and card style make Kanban boards look much like GitHub Projects boards.

How the pieces connect:

1. You capture tasks in daily notes, meeting notes, project notes and Kanban cards.
2. Tasks indexes every - [ ] line in the vault.
3. Query blocks in dashboards (and on your Hearth home screen) filter those tasks by date, tag, folder or status.
4. Git commits and pushes the whole vault to GitHub on a timer.

Vault structure

A small, predictable folder layout keeps Tasks queries simple, because most filters use path includes. Numbered prefixes keep folders in a fixed order in the file explorer.

Vault/
├── 00 Home/            Home dashboard, task dashboards
├── 01 Daily/           Daily notes (YYYY-MM-DD.md)
├── 02 Projects/        One folder per project: project note + Kanban board
├── 03 Meetings/        Meeting notes
├── 04 Knowledge Base/  Reference articles, how-tos, runbooks
├── 05 People/          One note per colleague or client (optional)
├── 99 Templates/       Daily, project, meeting and KB templates
└── Attachments/        Images, exported diagrams, PDFs

Two settings to change now:

1. Settings → Files and links → Default location for new attachments: choose In the folder specified below and enter Attachments.
2. Settings → Templates → Template folder location: 99 Templates.

Tip: exclude the templates folder from task queries with path does not include 99 Templates, otherwise the empty - [ ] lines in your templates show up as open tasks.

The daily note template

The daily note is the inbox for your day: everything starts here and gets linked or queried out later. Set it up once and Calendar creates a fresh one for any day you click.

Configure Daily notes

In Settings → Daily notes:

Setting	Value
Date format	YYYY-MM-DD
New file location	01 Daily
Template file location	99 Templates/Daily Note
Open daily note on startup	On (or off if Hearth is your start page)

The YYYY-MM-DD format sorts correctly in the file explorer and lets Tasks use the file name as a date.

The template

Create 99 Templates/Daily Note.md:

# {{date:dddd, D MMMM YYYY}}

## Notes
- 

## Personal to-do
- [ ] 

## Delegated to-do
- [ ] [[Person]] task #delegated

## Questions
- [ ] #question 

## Knowledge base links
- [[]]

## Carried over
```tasks
not done
due before {{query.file.filenameWithoutExtension}}
path does not include 99 Templates
sort by due
short mode
```

How each section is used:

• Notes: free-form log of what happened. Link liberally with [[double brackets]].
• Personal to-do: your own tasks. Add a due date when it matters, e.g. - [ ] Patch web01 📅 2026-10-24.
• Delegated to-do: tasks someone else owns. Start with a link to the person and tag #delegated so you can filter by person or by tag later.
• Questions: things to ask or find out. Making them tasks (#question) means unanswered questions never get lost.
• Knowledge base links: links to articles you read, wrote or updated today. These create backlinks, so each KB article shows which days it was used.
• Carried over: a live list of anything overdue relative to this note's date. {{query.file.filenameWithoutExtension}} is a Tasks placeholder that reads the note's file name, so old daily notes show what was overdue on that day.

Tip: delete unused empty - [ ] lines before you close the day, so they don't show up as blank open tasks.

Tasks: one to-do list for the whole vault

Tasks reads every checkbox line in the vault and lets you query them like a database. You write tasks anywhere; query blocks decide where they appear.

Task syntax

Use the Tasks: Create or edit task command (assign it a hotkey such as Ctrl+T) to add dates and priority from a form instead of typing emoji.

Field	Emoji	Example
Due date	📅	📅 2026-10-24
Scheduled (when you plan to do it)	⏳	⏳ 2026-10-22
Start (hidden before this date)	🛫	🛫 2026-11-01
Recurrence	🔁	🔁 every week on Monday
Priority: highest / high / medium / low / lowest	🔺 ⏫ 🔼 🔽 ⏬	⏫
Done date (added on completion)	✅	✅ 2026-10-21

A full example: - [ ] Renew SSL certificate on web01 #client/acme ⏫ 📅 2026-10-31 🔁 every year

Tick a recurring task and Tasks writes the next occurrence on a new line automatically.

Statuses

Beyond [ ] (to do) and [x] (done), Tasks supports custom statuses under Settings → Tasks → Task Statuses. Add the bundled Core statuses plus [/] In progress and [-] Cancelled. The [/] status pairs nicely with an In progress Kanban lane.

Query blocks

A query is a fenced code block with the language tasks. Each line is a filter, sort, group or layout instruction, and all filter lines must match.

Today's work:

```tasks
not done
(due on or before today) OR (scheduled on or before today)
path does not include 99 Templates
sort by priority
sort by due
group by filename
```

Everything I've delegated, grouped by person:

```tasks
not done
tags include #delegated
group by function task.outlinks.map(l => l.originalMarkdown).join(', ') || 'Unassigned'
sort by due
```

If you prefer something simpler, heading includes Delegated finds everything under the Delegated to-do heading, no tag needed.

Open questions:

```tasks
not done
tags include #question
group by filename
```

The next 7 days:

```tasks
not done
due after today
due before in 8 days
group by due
```

Completed this week (useful for status reports):

```tasks
done this week
group by done
```

Useful layout lines: short mode (compact), hide backlink, hide edit button, limit 20, and explain (prints how Tasks read your query, which is great for debugging).

Tip: if the grouping-by-person query above doesn't render in your version, fall back to group by tags and tag people as #person/sipho instead of linking them.

Kanban boards that double as task lists

A Kanban board is just a Markdown file: lanes are ## headings and cards are - [ ] list items. That is why the Tasks plugin sees every card, so board cards appear in your dashboards next to tasks from daily notes.

Create a board

1. Right-click the project folder (e.g. 02 Projects/Website Rebuild) and choose New board.
2. Name it, e.g. Website Rebuild Board.
3. Add lanes that mirror GitHub Projects: Backlog, To do, In progress, Review, Done.

Open the file in source mode and you'll see something like this:

---
kanban-plugin: board
---

## Backlog
- [ ] Audit plugins on staging #project/website

## In progress
- [ ] Migrate DNS to Cloudflare #project/website ⏫ 📅 2026-10-28

## Done
**Complete**
- [x] Take full backup ✅ 2026-10-20

Settings that matter

• Mark cards in this lane as complete: open the Done lane's menu and switch this on. Dragging a card into Done then ticks it, and Tasks treats it as completed.
• Dates: Kanban has its own @{date} syntax. To keep one system, put Tasks-style dates (📅 2026-10-28) in the card text instead; Tasks reads them, and the card shows them as text.
• Archive: use Archive completed cards from the board menu to keep Done short. Archived cards stay in the file under an Archive section.
• Lane width and card colours: tune these with Style Settings (see the theme section).

Pull board cards into queries

Tag every card on a board with one project tag, e.g. #project/website, or filter by the board's path:

```tasks
not done
path includes 02 Projects/Website Rebuild
group by heading
```

group by heading groups cards by their lane, so the query output reads like a text version of the board.

Tip: a card can link to a full note for detail. Type [[ in a card and link to a project or KB note, keeping the card itself short.

Project planning and tracking

Each project gets a folder with two files: a project note for the plan and a Kanban board for the work. The project note's live queries make it the tracker, so you never update a status report by hand.

Project note template

Create 99 Templates/Project.md:

---
status: active
start: {{date}}
target:
owner:
tags: [project]
---

# {{title}}

## Goal
What does done look like, in one or two sentences?

## Scope
| In scope | Out of scope |
| -------- | ------------ |
|          |              |

## Milestones
- [ ] Milestone 1 #project/slug #milestone 📅 
- [ ] Milestone 2 #project/slug #milestone 📅 

## Plan
```mermaid
flowchart LR
  A[Discover] --> B[Build] --> C[Test] --> D[Go live]
```

## Board
[[{{title}} Board]]

## Open tasks
```tasks
not done
tags include #project/slug
sort by due
group by status.name
```

## Done recently
```tasks
done after 14 days ago
tags include #project/slug
```

## Meetings and decisions
<!-- Backlinks from meeting notes appear in the backlinks pane -->

## Risks
| Risk | Impact | Mitigation |
| ---- | ------ | ---------- |
|      |        |            |

After inserting the template, replace slug with a short project tag (e.g. website) everywhere with Ctrl+H.

Planning a project, step by step

1. Create the folder 02 Projects/<Project name>.
2. Create a note inside it and run Templates: Insert template → Project.
3. Write the goal, scope and milestones with due dates.
4. Sketch the phases in the Mermaid block (see the knowledge base section for exporting it).
5. Create the board, add lanes, and break each milestone into cards tagged #project/<slug>.
6. During the week, add tasks wherever they come up (daily notes, meetings) with the same tag. They all appear in Open tasks.

A portfolio dashboard

Create 00 Home/Projects Dashboard.md to see every project's open work in one place:

```tasks
not done
path includes 02 Projects
group by folder
sort by priority
sort by due
```

And a list of overdue milestones across all projects:

```tasks
not done
tags include #milestone
due before today
```

Meeting notes

Meeting notes use the same task syntax, so action items agreed in a meeting land on your dashboards the moment you type them. Name meeting files YYYY-MM-DD Topic so they sort by date.

Meeting template

Create 99 Templates/Meeting.md:

---
date: {{date}}
type: meeting
project: "[[ ]]"
attendees: []
---

# {{title}}

**Date:** [[{{date}}]]  **Time:** {{time}}

## Agenda
1. 

## Notes
- 

## Decisions
- 

## My actions
- [ ] 

## Actions for others
- [ ] [[Person]] #delegated 📅 

## Questions raised
- [ ] #question 

The [[{{date}}]] link connects the meeting to that day's daily note, so the meeting appears in the daily note's backlinks.

During and after the meeting

1. Create the note in 03 Meetings and insert the Meeting template.
2. Fill in the project link and attendees, and add the meeting to your daily note under Notes: - Met with ACME, see [[2026-10-21 ACME infra review]].
3. Capture decisions as plain bullets and actions as tasks. Add the project tag (e.g. #project/website) to actions that belong to a project.
4. After the meeting, add due dates with the Tasks: Create or edit task command.

Your action items now appear in today's work, the project note and the delegated list, without being copied anywhere.

A meetings index

In 00 Home, a query for open actions from all meetings is handy before a follow-up call:

```tasks
not done
path includes 03 Meetings
group by filename
```

The knowledge base

The knowledge base is a folder of small, linked notes: one topic per note, linked from daily notes, meetings and projects. Links and backlinks do the organising, so you rarely need deep folders.

KB article template

Create 99 Templates/KB Article.md:

---
tags: [kb]
created: {{date}}
updated: {{date}}
---

# {{title}}

## Summary
One paragraph: what this is and when you need it.

## Details / Steps
1. 

## Gotchas
- 

## Related
- [[ ]]

Organising with links

• Link while you write: in a daily note, type [[ and start typing to link an existing article, or name a new one to create it later.
• Maps of content (MOCs): for big areas, create an index note such as Linux MOC that simply lists links to related articles. Link MOCs from your Hearth home screen.
• Backlinks pane: open it on any KB article to see every daily note, meeting and project that referenced it. That's your usage history for free.
• Tags for cross-cutting themes, e.g. #kb/networking, #kb/client/acme.

Tables with Advanced Tables

Advanced Tables formats Markdown tables as you type. Start a table with | Name | Value | and press Tab.

Key	Action
Tab	Format the table and move to the next cell (adds a column at the end of a row)
Shift+Tab	Previous cell
Enter	Next row (adds a row at the end of the table)
Ctrl+Shift+D	Advanced Tables control bar: sort, move, insert and delete rows and columns

Formulas go in a comment directly under the table. This one multiplies column 2 by column 3 into column 4 on every row:

| Item    | Qty | Unit price | Total |
| ------- | --- | ---------- | ----- |
| SSD 1TB | 2   | 1200       |       |
| RAM 16G | 4   | 650        |       |
<!-- TBLFM: $4=$2*$3 -->

Run Advanced Tables: Evaluate table formulas to fill in the results.

Diagrams with Mermaid and Mermaid Exporter

Obsidian renders Mermaid code blocks natively, which is perfect for network layouts, process flows and timelines that live alongside your notes:

```mermaid
flowchart TD
  User --> FW[Firewall]
  FW --> LB[Load balancer]
  LB --> W1[web01]
  LB --> W2[web02]
  W1 & W2 --> DB[(Database)]
```

Mermaid also handles sequenceDiagram, gantt (handy for project timelines), stateDiagram-v2, erDiagram and mindmap.

To use a diagram outside Obsidian (a slide, an email, a client report), use Mermaid Exporter to save it as a PNG. Set the export resolution in the plugin's settings (a higher scale gives sharper images for slides), then run its export command from the command palette (Ctrl+P, type Mermaid). Save exports to Attachments so they sync with the rest of the vault.

Navigation: Calendar and the Hearth home screen

Calendar gets you to any day in one click; Hearth gives you one start page for everything else.

Calendar

Calendar uses your Daily notes settings, so there is nothing extra to configure for daily notes.

• Open it: run Calendar: Open view and drag the panel to the right sidebar.
• Jump to a day: click a date. If the note doesn't exist, Calendar creates it from your daily template (turn on Confirm before creating new note if you click by accident a lot).
• Dots under a date show that a note exists; more dots mean more words written that day.
• Week start: set Monday under Calendar's settings if you prefer.
• Weekly notes (optional): enable them in Calendar's settings for a weekly review note with its own template. A done this week query works well there.

Combined with the Carried over query in each daily note, Calendar makes looking back easy: click last Tuesday and see what was overdue that day.

Hearth home screen

Hearth replaces the empty new tab with a customisable home screen that combines search, a dashboard and a launcher. Set it to open on startup in its settings, then turn off Open daily note on startup in Daily notes so the two don't compete.

Set Hearth up around your own dashboard requirements; there is no single right layout. Pick the views you actually check every day. As a starting point, consider:

• Launcher links: today's daily note, the Projects Dashboard, your main Kanban boards and your KB MOCs
• Today's tasks: the Today's work query from the Tasks section
• Waiting on others: the delegated query
• Open questions: the #question query

If a widget can't render Tasks queries directly, put the queries in 00 Home/Home.md and point Hearth at that note. Explore Hearth's settings for layout and widget options, as these change between versions.

Sync and backup with Git and a private GitHub repo

The Git plugin commits your vault and pushes it to a private GitHub repository on a timer. You get off-site backup, full version history and sync between machines at no cost.

One-time setup

1. Install Git on your computer (git --version in a terminal should print a version).
2. On GitHub, create a new private repository, e.g. obsidian-vault, with no README.
3. Set up authentication: an SSH key added to your GitHub account, or HTTPS with a personal access token stored by your Git credential manager.
4. In a terminal, from the vault folder:

git init
git branch -M main
git remote add origin git@github.com:<your-user>/obsidian-vault.git

5. Add a .gitignore in the vault root (below), then run Git: Commit all changes and Git: Push from the command palette for the first push.

.gitignore

# Per-device layout, changes constantly
.obsidian/workspace.json
.obsidian/workspace-mobile.json

# Obsidian's trash
.trash/

# OS clutter
.DS_Store
Thumbs.db

Keep the rest of .obsidian/ in the repo so plugins, settings and the theme travel with the vault.

Plugin settings

Setting	Suggested value	Why
Auto commit-and-sync interval	10 minutes	Regular backups without noise
Auto commit-and-sync after stopping file edits	On	Commits when you pause, not mid-sentence
Pull on startup	On	Always start with the latest version from other machines
Commit message	vault backup: {{date}}	Easy-to-read history

Day-to-day

• Source control view (Git: Open source control view) shows changed files and lets you commit with a custom message.
• History: Git: Open history view, or the file's history on GitHub, lets you recover an older version of any note.
• Conflicts: if you edit the same note on two machines between syncs, Git marks the conflict in the file. Fix it by hand, then commit. Pulling on startup avoids most conflicts.
• Mobile: the plugin works on mobile but is slower with large vaults. Keep big attachments out of the vault or test before relying on it.

Security note: keep the repository private, and don't store passwords or API keys in notes even so. Use a password manager for secrets.

The look: GitHub dark theme and Style Settings

The GitHub theme in dark mode is easy on the eyes for long sessions, and its muted cards and borders make Kanban boards look like GitHub Projects.

1. Settings → Appearance → Themes → Manage, search for GitHub, install and click Use.
2. Under Appearance → Base color scheme, choose Dark.
3. Open Settings → Style Settings. Style Settings lists every variable the theme and your plugins expose, grouped by name.

Tweaks worth trying in Style Settings:

• Kanban: lane width (around 300 px feels like GitHub Projects columns) and card background or border colours.
• Theme: accent colour, heading sizes and line width for readable notes.
• Tables and code blocks: border and background contrast, which helps Advanced Tables output stand out.

Style Settings only shows options a theme or plugin supports, so the list will differ from other setups. If you want something it doesn't offer, add a CSS snippet in .obsidian/snippets/ and enable it under Appearance → CSS snippets.

A day with this system

The routine takes about five minutes at each end of the day; the rest is just writing tasks where they come up.

Morning

1. Obsidian opens on Hearth (Git pulls the latest changes automatically).
2. Check Today's work, Waiting on others and Open questions.
3. Click today in Calendar to create the daily note; check its Carried over list.
4. Glance at the Kanban boards for active projects and drag cards that are starting into In progress.

During the day

• Jot notes, links and to-dos into the daily note as they happen.
• Meetings get their own note from the Meeting template; actions are tasks with project tags.
• When you solve something worth keeping, write or update a KB article and link it under Knowledge base links.

End of day

1. Tick off finished tasks; reschedule anything slipping with Tasks: Create or edit task.
2. Delete empty - [ ] lines from the template.
3. Move finished Kanban cards to Done.
4. Let Git auto-sync, or run Git: Commit-and-sync before closing.

Tips and troubleshooting

• A task isn't showing up: add explain to the query to see how Tasks reads each filter, and check the task isn't in 99 Templates or written with a typo in the date.
• Template dates in the wrong format: set Settings → Templates → Date format to YYYY-MM-DD so [[{{date}}]] links match daily note names.
• Kanban card dates not filtering: use Tasks emoji dates (📅) in cards, not Kanban's @{date} syntax.
• Slow vault: narrow queries with path includes and limit, and archive old Kanban cards.
• Weekly review: a weekly note with done this week and tags include #milestone queries turns into a ready-made status report.