Back to Obsidian: Power User Mode with Canvas, Dataview, and DataviewJS
Hi everyone!
A while ago I wrote about switching from Obsidian to Anytype. I tried it, I used it daily, and I built tools around it. But after months of real use, I came back to Obsidian.
Why? Because at the end of the day, nothing beats a folder of plain Markdown files plus a plugin ecosystem that lets you bend the tool to your brain — not the other way around.
This post is about what brought me back, and how I’m using Canvas, Dataview, and DataviewJS to turn Obsidian into a real second brain rather than just a notes app.
Why I came back
A few honest reasons:
- Markdown is forever. My notes are just
.mdfiles in a folder. No proprietary format, no sync server I don’t control, no migration anxiety. Git, Syncthing, iCloud — pick your poison. - The plugin ecosystem is unmatched. Anytype is beautiful and well-designed, but Obsidian’s community has had years to build the exact tool you didn’t know you needed.
- Local-first, really. Files on disk. Open them with any editor. Grep them. Script them. Pipe them into an LLM.
- It bends to you. Object structures and databases are great until you want to do something the schema doesn’t allow. Obsidian’s “everything is a Markdown file with frontmatter” model is dumber, and that’s the point.
The switch back wasn’t a rejection of Anytype — it’s a good product. It’s that Obsidian rewards investment, and once you go deep with Canvas and Dataview, leaving feels like leaving a workshop you spent years setting up.
The three pillars of power use
1. Canvas — thinking in 2D
Canvas is Obsidian’s infinite whiteboard. Drag notes onto it, draw arrows, group ideas, embed images and web pages. It’s the closest thing to thinking on a real desk.
Where I use it:
- Project planning. One canvas per project. Notes for tasks, decisions, references, all spatially arranged. Architecture diagrams next to the notes that explain them.
- Literature maps. When researching a topic I drop every relevant note onto a canvas and physically arrange them by theme. Connections you’d never see in a linear list jump out.
- Daily review. A canvas of “open loops” — half-finished thoughts, things to follow up on — that I rearrange weekly.
The key insight: Canvas isn’t a separate app, it’s a .canvas file that references your existing notes. Move a note in the file tree and it stays linked.
2. Dataview — your vault is a database
Dataview is the plugin that flips Obsidian from “notes app” to “personal database.” Every note has frontmatter. Dataview lets you query that frontmatter like SQL.
A trivial example — list every post tagged obsidian sorted by date:
```dataview
TABLE file.ctime AS "Created", tags
FROM "_posts"
WHERE contains(tags, "Obsidian")
SORT file.ctime DESC
```
A more useful one — a reading list dashboard where each book is a note with status:, rating:, and finished: in its frontmatter:
```dataview
TABLE rating, finished
FROM "Books"
WHERE status = "read"
SORT finished DESC
```
Suddenly your vault has dashboards. Habit trackers. Project status boards. Meeting note indexes. All generated from the notes themselves — no duplicate state, no manual updates.
3. DataviewJS — when SQL isn’t enough
DataviewJS is Dataview’s escape hatch: write JavaScript directly in a code block and render whatever you want.
This is where it stops being a notes app and starts being a programmable thinking environment. A few real examples from my vault:
A weekly review block that pulls every note touched in the last 7 days, grouped by folder:
```dataviewjs
const pages = dv.pages().where(p => p.file.mtime >= dv.date("today") - dv.duration("7 days"));
const byFolder = {};
for (const p of pages) {
const folder = p.file.folder || "root";
(byFolder[folder] ??= []).push(p);
}
for (const [folder, notes] of Object.entries(byFolder)) {
dv.header(3, folder);
dv.list(notes.map(n => n.file.link));
}
```
A project status dashboard that counts tasks per project file and shows progress bars. An automatic “orphan notes” report — notes with no incoming links. A reading streak counter that walks daily notes and finds consecutive days with a read: field.
The point isn’t the scripts themselves — it’s that your second brain becomes something you can program. Every weird question you have about your own knowledge (“what did I write about X last quarter?”, “which projects are stale?”) becomes a query, not a manual hunt.
Putting it together
The real magic is the loop:
- Write notes as plain Markdown with sensible frontmatter.
- Map them spatially in Canvas when you need to think visually.
- Query them with Dataview when you need a list, table, or dashboard.
- Script them with DataviewJS when the query language runs out.
That’s the workflow. Markdown in, structured insight out. No vendor lock-in, no monthly fee for someone else’s database, and the whole thing lives in a folder you can git push anywhere.
Closing thoughts
I don’t think there’s one “right” tool for thought. Anytype is great. Notion is great. Logseq is great. But for me, the combination of plain files + Canvas + Dataview + DataviewJS is the sweet spot between freedom and structure.
If you bounced off Obsidian because it felt like “just another Markdown editor,” try going deeper with these three. The moment your vault starts answering questions you didn’t pre-plan to ask, you’ll know what I mean.
See you next time!
