Every few months, a new “ultimate Obsidian workflow” pops up on Reddit or YouTube. It usually involves a dozen plugins, complex folder hierarchies, elaborate templates with frontmatter fields you’ll never remember to fill in, and a Zettelkasten philosophy that requires a PhD in library science to follow. You spend a weekend setting it all up, feel productive for three days, then quietly abandon it because maintaining the system takes more effort than it gives back.
I’ve been there. I tried PARA, I tried Zettelkasten, I tried building my own Frankenstein hybrid. Every system eventually collapsed under its own weight. Then one day, frustrated and behind on a monthly business review, I stripped everything back to the bare minimum: daily notes, bullet points, and tags. Nothing else. That was over a year ago, and I haven’t looked back since.
What I’m about to describe is not clever. It won’t impress anyone on the Obsidian Discord. But it works every single day, it takes zero willpower to maintain, and it gives me exactly the information I need when review time comes around. If you’ve been struggling to find a note-taking system that sticks, this might be the permission you need to stop overengineering and start actually writing things down.
One file per day, one line per thought
I still create dedicated notes for topics that have real structure, things with their own identity that deserve a proper page. A project, a process I need to document. If something has enough ontological consistency to stand on its own, it gets its own note.
But I noticed that a huge number of the notes I was creating were just small fragments. A fact I picked up in a meeting, a number I’d need later. Each one got its own file, and my vault was filling up with tiny notes that existed in isolation and were hard to find. So I started dumping those fragments into Obsidian’s Daily Notes instead. Every morning, a new note is created automatically. The filename is the date. The content starts empty.
Throughout the day, whenever something worth remembering doesn’t warrant a full note, I write a single bullet point. Just one line. The only rule is that every line gets a tag, because that tag is what makes the whole system work later. And if I notice that several tagged lines across different days are converging into a real topic, I pull them together into a proper structured note. The daily notes are basically a staging area: capture it now, organize it later, and only if it earns it.
Here’s what a real daily note looks like in my vault:
- Discussed Q2 priorities with Sarah, agreed on three focus areas #mbr
- Platform latency dropped below 200ms after the CDN migration #achievements
- New compliance regulation kicks in on March 15, need to update onboarding flow #info
- Team velocity increased 15% this sprint compared to last #wbr
- The marketing API rate limit is 500 req/min, not 1000 as documented #infoFive lines. Maybe two minutes total across the entire day. I didn’t have to think about where to file anything or whether a piece of information “deserves” its own note.
The tags I use are few and intentional. #mbr is for anything relevant to my Monthly Business Review. #wbr tags what matters for the Weekly Business Review. #info captures atomic pieces of information, the kind of small facts that don’t justify a standalone note but that you know you’ll want to find again. #achievements tracks wins, both personal and team-level, because when performance review season hits, you never remember the good stuff.
You could add your own tags to fit your context. Maybe #idea for things you want to explore later, or #blocker for recurring obstacles. The point isn’t the specific tags. The point is that a tag is the lightest possible metadata you can attach to a line, and it costs you almost nothing to type.
Why tags on lines instead of notes
Most Obsidian workflows apply tags or metadata at the note level. You tag an entire note as #project/alpha or set a frontmatter property like type: meeting-notes. This works fine when your notes are neatly categorized, one topic per note, filed in the right folder.
But daily notes are messy by nature. A single day’s note might contain a business review insight, a random technical fact, a personal win, and a reminder about a deadline. If you tag the note itself, you either end up with a note tagged #mbr #info #achievements #wbr (which tells you nothing useful) or you start splitting things into separate notes (which reintroduces all the friction you were trying to avoid).
Tagging individual lines solves this. Each bullet point carries its own context through the tag. And because the line lives inside a daily note, it already has a date attached to it via the filename. You get what, when, and what category without any extra effort.
The trade-off is that Obsidian’s built-in search and tag features work at the note level, not the line level. You can search for #info and find all the daily notes that contain it, but you’ll still have to scroll through each note to find the relevant lines. This is where the second piece comes in.
Dataview turns tags into dashboards
Obsidian’s Dataview plugin is what makes the whole thing work beyond just “I wrote it down somewhere.” Dataview lets you write queries that pull information from across your vault and display it as tables, lists, or custom views, all rendered live inside a note.
I have a handful of dedicated notes in my vault, one for each tag. My “Info Dashboard” note contains a single Dataview script that scans every daily note from the last three months, finds every line tagged with #info, and displays them in a table organized by month.
Here’s the actual code, e.g. for #info tag:
const months = ["January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December"];
for (let i = 0; i < 3; i++) {
const ref = DateTime.now().minus({ months: i });
const start = ref.startOf("month");
const end = ref.endOf("month");
const rows = [];
for (const page of dv.pages()) {
const cday = page.file.cday;
if (!cday || cday < start || cday > end) continue;
const content = await dv.io.load(page.file.path);
if (!content) continue;
for (const line of content.split("n")) {
if (line.includes("#info") && !line.includes('.includes("#info")')) {
rows.push([dv.fileLink(page.file.path), line.trim().replace(/^[-*+]s+/, "")]);
}
}
}
dv.header(3, `${months[ref.month - 1]} ${ref.year}`);
dv.table(["Note", "Line"], rows);
}It loops through the last three months. For each month, it scans every page in the vault, checks if the page was created within that month’s date range, loads the content, and extracts every line containing #info. The result is a two-column table: a link to the source note and the content of the line.
When I open this note, I see three months of atomic information, grouped by month, with links back to the original daily note for context. I didn’t curate any of it. I didn’t copy anything into a separate document. It just assembled itself.
I duplicate this pattern for my other tags. The MBR dashboard filters for #mbr and shows the last three months. The WBR dashboard filters for #wbr and shows the last four weeks. The Achievements dashboard filters for #achievements and covers the last six months, because when annual review time comes, I want the full picture.
Creating a new dashboard for a new tag takes about thirty seconds: duplicate the note, change the tag string in the filter condition, adjust the time window if needed.
What review time actually looks like
This whole setup pays for itself when I sit down for a business review. Instead of scrambling through meeting notes, Slack messages, and half-forgotten memories, I open the relevant dashboard and everything is already there, organized chronologically, with links to the original context.
For a monthly business review, I open the MBR dashboard. Three months of tagged observations are laid out in front of me. I can see patterns forming across weeks, spot recurring themes, pull specific data points into my review document without hunting for them.
For a weekly review, I open the WBR dashboard. Same thing, but scoped to weeks. The information is already filtered and sorted.
The organizing happens at retrieval time, not at capture time. When I’m writing a bullet point in my daily note, the effort is near zero: write the thought, tag it, move on. All the work lives in the Dataview queries, which run automatically every time I open a dashboard.
This inverts how most people take notes. Usually you invest effort upfront to categorize, file, and link, hoping your future self will benefit. In my system, my present self does almost no work. My future self gets exactly what they need through a query that past me wrote once and forgot about.
Why this system survives
I’ve thought about why this system has stuck when others didn’t.
The capture friction is almost zero, and I’ve gone out of my way to keep it that way. The real enemy of any note-taking system is the gap between thinking “I should write this down” and actually doing it. If you have to cmd-tab to Obsidian, find the right note, scroll to the bottom, and then start typing, half the time you just won’t bother. The thought passes, and it’s gone.
I use a plugin called Global Hotkeys that closes that gap. No matter what application I’m in, a keyboard shortcut drops me straight into today’s daily note. I write the line, add the tag, and go back to whatever I was doing. The whole thing takes a few seconds, and I never have to navigate anywhere or decide where to put the information. When friction is this low, you actually do it. Consistently.
The system also degrades gracefully. If I forget to tag a line, it just doesn’t show up in the dashboard. The daily note still has it. I can still find it with a regular search. Nothing breaks. If I skip a day entirely, nothing breaks either. The dashboards just show less data for that period.
And the value showed up immediately. The first time I sat down for a monthly review and had everything I needed in one screen, the system justified itself. It wasn’t a theoretical benefit that might pay off in five years when my vault reaches critical mass. It was useful in the first month.
Conclusions
This is a minimal Obsidian system built on daily notes, inline tags, and Dataview queries. It eliminates capture friction while still giving you structured, filterable information when review time comes.
Tag lines, not notes. Daily notes are inherently multi-topic. Putting tags on individual bullet points lets you slice information across days without adding organizational overhead.
Let queries do the organizing. Write a Dataview query once, and let it pull the right information together whenever you need it. Don’t waste time filing and categorizing at capture time.
A system you use every day at 80% is infinitely more valuable than a perfect system you abandon in two weeks. Optimize for consistency.
If you want to try this, start today. Enable Daily Notes in Obsidian, install the Dataview plugin, pick two or three tags that match your workflow, and just start writing bullet points. In a month, build your first dashboard. That’s when the system clicks.