Get AI summaries of any video or article — Sign up free
Making notes actually useful in Obsidian thumbnail

Making notes actually useful in Obsidian

Nicole van der Hoeven·
5 min read

Based on Nicole van der Hoeven's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Treat note-taking as two phases: capture raw understanding quickly, then process it into reusable knowledge inside the Obsidian vault.

Briefing

Notes only matter if they get used—and in Obsidian, that usefulness depends on a two-stage workflow: capture first, then process. The capture phase is intentionally messy: initial notes are written as stream-of-consciousness bullets with minimal concern for grammar, because the goal is to preserve understanding while learning from sources like YouTube, podcasts, books, and tweets. To make that capture scalable, highlights are imported into the Obsidian vault via Readwise, including browser-based highlighting through the Readwise Reader extension. The workflow also leans on Obsidian’s own linking syntax so ideas can later connect inside the vault, even when the importing tools don’t recognize those links yet.

Once the raw material sits in the vault, the second stage—processing—turns fragments into reusable knowledge. Processing means paraphrasing and abstracting ideas into clearer summaries, creating new notes, and updating existing ones on the same topics. A key tactic is adding “summary metadata” (often a one-sentence summary) using Data View queries, plus callouts that visually separate distilled takeaways from the rest of the note. For dense or visual concepts, the workflow uses Excalidraw to consolidate comparisons and terminology mapping that don’t translate cleanly into plain text. When content needs to function like both a note and a slide deck, Advanced Slides is used to embed Excalidraw images and text so the same material can be previewed and presented without rewriting.

Processing also includes structural maintenance. The Outline core plug-in helps reveal whether a note has become unwieldy, making it easier to decide what to move out. For merging related pages, Note Composer can merge entire files so overlapping content becomes a single coherent note. For splitting long sections into focused sub-notes, Note Refactor extracts selected text into a new note and replaces the original section with a link—keeping the parent note navigable while preserving detail elsewhere.

Finally, usefulness depends on relationships, not just content. Backlinks (core) shows linked and unlinked mentions so newly learned information can be propagated to other relevant notes. Strange New Worlds (community) adds a more flexible view: link counts appear next to references, hover windows show how many notes point to each page, and the display stays anchored to the note being examined even when navigating elsewhere. Those numbers help identify gaps—why one topic has fewer connections than another—and guide what to research or write next. Excalibrain is then used to define explicit and implicit relationships between notes, turning a collection of pages into a connected knowledge system.

The overall message is pragmatic rather than dogmatic: not every note needs every plug-in or step. The workflow is treated as a toolkit—choose what fits the situation, then publish, test, and iterate through formats like Obsidian Publish, microblogging on Mastodon and Twitter, and repackaging ideas into blogs, videos, or conference presentations. Fixating on rigid methodologies without doing the work is framed as a dead end; the real goal is making notes usable over time.

Cornell Notes

Useful Obsidian notes come from separating capture from processing. Raw capture is fast and imperfect: bullet highlights and stream-of-consciousness notes are imported into the vault using Readwise and Readwise Reader, preserving understanding without worrying about polish. Processing then turns fragments into reusable knowledge through paraphrasing, one-sentence summary metadata, callouts, and visual consolidation with Excalidraw or slide-like notes via Advanced Slides. Structural tools like Outline, Note Composer (merge), and Note Refactor (extract) keep notes navigable as they grow. Finally, relationship tools—Backlinks, Strange New Worlds link counts, and Excalibrain for explicit/implicit links—help update related pages and reveal gaps in coverage.

Why does the workflow start with “messy” notes instead of polished writing?

Initial notes are treated as a comprehension record, not a final artifact. Notes are often bullet points or stream-of-consciousness fragments with spelling and grammar ignored, because the immediate job is to capture what was learned from sources like videos, podcasts, books, and tweets. This raw stage provides something to start processing later, and it’s made scalable by importing highlights via Readwise (including Readwise Reader in Chrome).

How do Readwise and Readwise Reader connect learning highlights to Obsidian notes?

Readwise Reader lets highlights and notes be taken directly while working through lessons in a browser. Then, through the Readwise official Obsidian plug-in, those highlights and notes automatically sync into the Obsidian vault. Even when external tools don’t understand Obsidian’s internal link syntax, the workflow still uses that syntax so the notes can become properly connected once they land in Obsidian.

What does “processing notes” mean in practice?

Processing is paraphrasing and abstracting ideas into clearer summaries, creating new notes, and updating existing ones on the same topic. Concrete tactics include adding summary metadata (often a one-sentence summary via Data View queries) and using callouts to make distilled takeaways stand out. Visual or comparative thinking is handled with Excalidraw, while Advanced Slides can blend embedded visuals and text into a slide-previewable note for self-testing and presentations.

How does the system keep long notes from becoming unusable?

It uses structural inspection and refactoring. Outline (core) shows the note’s flow so sections can be identified for removal. Note Composer can merge entire files when two notes overlap. Note Refactor can extract a selected section into a new note (using the first line as the filename) and replace the original section with a link, keeping the parent note lean and easier to navigate.

How do backlinks and link-count tools help decide what to update or write next?

Backlinks (core) reveals linked and unlinked mentions of the currently open page, helping identify other notes that may need updates after new learning. Strange New Worlds (community) goes further by showing how many notes point to each linked page, including counts in hover windows and a tab that stays tied to the note being examined. Those numbers can expose imbalances—like why one topic has far fewer connections than another—guiding what to research or expand.

What role does Excalibrain play beyond basic linking?

Excalibrain is used to define explicit and implicit relationships between notes. It supports a more deliberate relationship layer than simple linking alone, and the workflow keeps Excalibrain open in a side pane so relationships can be added as new notes are processed.

Review Questions

  1. What are the main differences between the capture stage and the processing stage in this Obsidian workflow?
  2. Which plug-ins are used for (a) merging notes, (b) extracting sections into new notes, and (c) visual consolidation—and what problem does each solve?
  3. How can link counts from Strange New Worlds change what you choose to research or write next?

Key Points

  1. 1

    Treat note-taking as two phases: capture raw understanding quickly, then process it into reusable knowledge inside the Obsidian vault.

  2. 2

    Use Readwise and Readwise Reader to import highlights from books, podcasts, tweets, and browser lessons so the vault starts with real learning artifacts.

  3. 3

    Turn raw notes into usable material with paraphrasing, one-sentence summary metadata (e.g., via Data View), and callouts that visually separate key takeaways.

  4. 4

    Keep notes navigable as they grow by using Outline to inspect structure, Note Composer to merge overlapping pages, and Note Refactor to extract long sections into linked sub-notes.

  5. 5

    Build usefulness through relationships: use Backlinks to find linked/unlinked mentions, Strange New Worlds to spot connection gaps via link counts, and Excalibrain to encode explicit/implicit relationships.

  6. 6

    Don’t force every note through every step; pick the smallest set of tools that makes that specific note useful.

  7. 7

    Validate and iterate by publishing notes and testing ideas in other formats (microblogging, blog posts, videos, conference presentations).

Highlights

The workflow’s core distinction is separating raw capture from later processing—polish and structure come after understanding is captured.
Readwise Reader + the Readwise Obsidian plug-in creates an automatic bridge from browser highlights to Obsidian vault notes, enabling faster capture at scale.
Note Refactor can extract a selected section into a new note and replace the original text with a link, keeping long notes readable.
Strange New Worlds uses link counts (and hover windows) to reveal which topics are under-connected, guiding what to expand next.
The system treats relationships as first-class knowledge by combining Backlinks with Excalibrain’s explicit and implicit relationship mapping.