Get AI summaries of any video or article — Sign up free
Creating a powerful zettelkasten setup for learning using Obsidian (Full setup + download) thumbnail

Creating a powerful zettelkasten setup for learning using Obsidian (Full setup + download)

John Mavrick Ch.·
5 min read

Based on John Mavrick Ch.'s video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Separate fleeting notes from log notes to keep navigation clear as the vault grows.

Briefing

A linked-note workflow in Obsidian can become genuinely powerful only when the system is grounded in transparent sourcing, structured metadata, and views that help a learner manage growth over time—not just when notes are “atomized” and tagged. The core critique driving the setup redesign is that a popular Zettelkasten-style template is too simplified and, in practice, underuses Obsidian’s strengths: properties, plugins, and Data View queries that turn a vault into a searchable, self-auditing knowledge system.

The transcript first challenges credibility and completeness. It argues that learning advice shared online can be hard to verify when sources are cherry-picked and the underlying reasoning isn’t shown. It then pivots to integrity: instead of only pointing readers to “how to take smart notes,” the system should also name the Obsidian-specific resources and mechanisms that make the method work inside a real vault. The proposed remedy is “learning in public” by publishing notes online so others can inspect structure, citations, and the evolution of ideas.

From there, the redesign focuses on practical vault architecture. The original folder scheme uses six categories (rough notes, source material, tags/indexes, templates, and main notes). The critique is that “rough notes” mixes fleeting notes (temporary thoughts) with log-style entries (e.g., writing word counts), which can become hard to navigate at scale. The improvement: split fleeting notes into a dedicated folder and keep logs separate.

The biggest technical change targets note templates. Instead of storing status, timestamps, and link-like metadata inside the note body, the transcript recommends using Obsidian “properties” (frontmatter-style file properties) so the vault can power custom views. It also replaces a reserved “tags” field with a “links” property type (list), enabling better compatibility with Obsidian features like suggestions and filtering. The template is further streamlined by removing redundant elements (like duplicated titles) and relying on plugins for references.

The transcript then argues that logs should support higher-order tracking, not just journaling. Rather than leaving progress as raw numbers in daily notes, it suggests habit tracking via the Tracker plugin and storing structured values in daily-note properties.

For source notes, the critique is that copying highlights into multiple places bloats the vault and makes citations harder to trace. The solution is block-level references and footnote workflows using community plugins (e.g., Copy Block Link and Footnotes Shortcuts), plus an additional plugin (“Strange New Worlds”) to surface reference badges so readers can quickly see where a quote is used.

Finally, the transcript emphasizes index notes and “maps of content” style linking, but adds a missing ingredient: context. Index pages should include short explanations of why a link matters, not just a table of contents. To manage the resulting complexity, it introduces Data View queries as the automation layer—custom tables for tags, indexes ranked by total incoming/outgoing links, and “not included yet” link checklists that help a writer avoid missing citations.

The overall message is less about adopting a fixed Zettelkasten template and more about building a vault that can grow, be audited, and be personalized—using Obsidian’s metadata and querying capabilities to keep hundreds of notes from turning into an unmaintainable archive.

Cornell Notes

The transcript argues that a Zettelkasten-style Obsidian setup only becomes truly useful when it’s built for transparency, scalable organization, and automated navigation. It criticizes an oversimplified template for mixing note types, relying on body text instead of Obsidian properties, and treating logs and citations as manual chores. The proposed upgrades separate fleeting notes from logs, move key fields into properties (including a “links” list), and improve sourcing with block-level references and footnotes so quotes can be traced without duplication. It also recommends adding context to index notes and using Data View queries to create custom tables—like ranking index notes by total links and generating “missing links” checklists—so the vault stays manageable as it grows.

Why does separating “fleeting notes” from “log notes” matter in a large Obsidian vault?

When rough notes include both temporary thoughts and structured log entries (like daily writing metrics), navigation becomes ambiguous as volume grows. The transcript’s fix is to create a dedicated folder for fleeting notes (temporary ideas) and a separate folder for logs, so it’s always clear what kind of note each entry is and where it belongs.

What’s the practical advantage of using Obsidian properties instead of putting metadata in the note body?

Properties let Obsidian treat fields like created date, status, and link-like relationships as structured data. The transcript demonstrates adding a date-time property (using Obsidian’s ISO date behavior), a text “status” property, and a “links” property typed as a list. This enables features like property-based filtering and custom Data View tables, which isn’t reliably possible when metadata is buried in free text.

How does the transcript improve citation handling for source notes without duplicating quotes?

Instead of copying the same highlight into multiple notes (which creates duplicates and makes citations tedious), it recommends referencing specific blocks from source notes. It uses community plugins such as Copy Block Link to copy block-level references and Footnotes Shortcuts to generate footnotes quickly. An additional plugin (“Strange New Worlds”) is used to show reference badges so the reader can see where a quote is used.

What’s missing from index notes if they function only as a table of contents?

A table of contents lists links, but it doesn’t capture why those links matter. The transcript argues that index notes should include brief context explaining the relationship—e.g., why “Learning” is valuable in that specific index (learning something new by connecting it to something already known). That context preserves the meaning behind the link, not just the existence of it.

How do Data View queries keep a growing vault from becoming unmanageable?

Data View turns vault structure into queryable dashboards. The transcript describes creating custom views for note types (tags and indexes), sorting by properties like created date, and building tables that compute link metrics (outgoing vs incoming) to rank index notes by “total links.” It also uses queries to list candidate links that aren’t yet included in a note, then suggests embedding a template so those “missing links” disappear once added.

Why does the transcript prefer an Evergreen-notes metaphor over a “baby/child/adult” status system?

It claims Evergreen stages (seedlings → sprouts → trees) are more intuitive for managing note growth over time. The system helps a learner decide what to do next with hundreds of notes—e.g., which seedlings should be developed into trees. It also supports process-oriented statuses for inputs (not started, reading, taking notes, processing, finished), which the transcript treats as essential for maintaining a large vault.

Review Questions

  1. How would moving status and link relationships into Obsidian properties change what you can automate with Data View?
  2. What problems arise when highlights are copied into multiple notes, and how do block references and footnotes address them?
  3. Design a Data View query: what fields and filters would you use to rank your index notes by importance using link counts?

Key Points

  1. 1

    Separate fleeting notes from log notes to keep navigation clear as the vault grows.

  2. 2

    Store key metadata in Obsidian properties (e.g., created date, status, links list) so it can power filtering and Data View tables.

  3. 3

    Use block-level citation workflows (Copy Block Link + Footnotes Shortcuts) to reference source highlights without duplicating quotes.

  4. 4

    Add short context to index notes so links carry meaning, not just structure.

  5. 5

    Use Data View queries to create custom dashboards—such as ranking index notes by total incoming/outgoing links and generating “missing links” checklists.

  6. 6

    Treat logs as trackable progress signals (via Tracker-style habit tracking) rather than only as raw journaling entries.

  7. 7

    Personalize note lifecycle stages (e.g., Evergreen) so the system tells you what to do next with each note type.

Highlights

The transcript’s most concrete upgrade is moving from template fields written in note text to Obsidian properties, enabling real automation with Data View.
Citation quality improves when highlights stay in source notes and other notes reference specific blocks with footnotes—reducing duplication and making traceability faster.
Data View is positioned as the vault’s “control panel”: tables can compute link metrics and even surface missing citations before writing is finished.

Mentioned