Get AI summaries of any video or article — Sign up free
Taking notes for work with Obsidian thumbnail

Taking notes for work with 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

Traditional notes often fail because they’re siloed, frozen after a short goal, and never revisited as knowledge grows.

Briefing

Taking notes isn’t just a way to remember facts—it’s a career tool for building an evolving, interconnected knowledge system. The core claim is that traditional school-style notes fail because they’re siloed by topic, frozen after the semester, and written for a short-term goal (passing an exam). That approach leaves people with lots of effort and little long-term usefulness. A better system treats notes like living software: continuously updated, linked to related ideas, and refined as understanding grows.

The proposed “new way” starts with four principles. First, notes should be interconnected, mirroring how the brain organizes knowledge through relationships—similar concepts, contrasts, and even opposing ideas. Second, notes should constantly evolve rather than act like a snapshot; as careers progress, the notes should be revised to reflect new context and corrections. Third, notes should operate at multiple levels of abstraction: keep them grounded in immediate context, but also distill patterns and models that can transfer to new situations. Fourth, the system should be future-proof—digital enough to search, back up, and share, but not so dependent on a fleeting format that the notes become unusable later.

To make that workflow concrete, the talk borrows a software engineering loop: continuous integration and continuous delivery (CI/CD). In that model, work cycles through planning, building, testing, deploying, collecting feedback, and incorporating it into the next iteration. Applied to note-taking, “continuous note taking” means capturing what’s learned from reading, conversations, or experiments; processing it into notes with both context and abstraction; publishing or sharing it; and then using feedback—what was misunderstood or what held up—to guide the next round of learning and writing.

Obsidian is presented as the practical environment for this approach. It’s positioned as a “second brain” and a personal knowledge base: local-first, not SaaS, with notes stored as plain Markdown files in a vault folder. That design choice matters because it preserves ownership and makes the notes portable—any text editor can open them, and the vault can be backed up elsewhere. Links are central: typing bracketed text creates explicit links, while Obsidian also surfaces “implicit” links by recognizing note names across the vault. Graph view then visualizes how ideas connect, turning a collection of notes into a navigable network.

The talk then shows how this supports real work. Notes can function as test logs (tracking runs, metrics, and links to tools like k6 and Grafana dashboards), as learning distillations (turning messy exploration into step-by-step instructions), and as curated reference shorthands (topic notes that complement—rather than replace—official documentation). Obsidian also supports publishing and collaboration: presentations can be authored in Markdown via plugins, and documentation can be edited directly inside GitHub repositories because the vault is just files. Finally, publishing notes—such as through Obsidian Publish—creates “learning exhaust,” a lightweight record of what’s been worked on and refined.

The closing argument ties the system to employability. For a remote, internet-based career, notes become proof of capability: each note is an idea connected to others, tested against competing concepts, and written in the author’s own words for a future reader. The result is faster learning, cumulative knowledge over thousands of notes, and a portfolio-like graph of what someone can do—something that can help land roles even when skills aren’t immediately visible on paper.

Cornell Notes

The talk argues that effective note-taking should work like a continuous improvement loop: capture new information, process it into linked notes with both context and abstraction, publish or share it, and then revise based on feedback. Traditional notes fail because they’re siloed, static, and written for short-term goals like passing an exam. Obsidian is presented as a practical tool for this approach because it stores notes as local Markdown files, supports rich linking (explicit and implicit), and visualizes relationships with graph view. Over time, thousands of interconnected notes create a searchable knowledge base that helps people learn faster and demonstrate capability to future employers.

Why do conventional “school-style” notes stop being useful after the semester ends?

They tend to be separated by topic (different notebooks/sections per subject), which prevents cross-linking even when ideas overlap. They’re also static—once written, they aren’t revisited or updated as understanding improves. The notes are contextual in a narrow way: chosen mainly to achieve a passing grade, not to build durable understanding. Finally, they become temporary; after the exam, the author stops adding to them and later advanced work never pulls those basics back into active use.

What does “continuous note taking” borrow from software engineering, and how does that translate to knowledge work?

It adapts the CI/CD loop: plan, build, test, deploy, listen for feedback, and incorporate that feedback into the next iteration. In note-taking terms, learning inputs (reading, colleagues, experiments) become notes; those notes are processed into multiple abstraction levels (context plus distilled models); then they’re shared or published. Feedback—what was misunderstood or what held up—feeds the next round of learning and rewriting.

What makes Obsidian’s note system “future proof” in practical terms?

Notes live as plain Markdown files inside a vault folder on the local file system. That means the content is portable: the vault can be opened in any text editor, renamed, and backed up to other cloud syncing services. Obsidian is local-only (not SaaS), and because the underlying storage is inspectable, the notes don’t depend on a proprietary database to remain accessible.

How do links work in Obsidian, and why does that matter for building an interconnected knowledge base?

Typing bracketed text like “Eurostar 2023” creates an explicit link and generates a new note if needed. Even without explicit linking, Obsidian can surface “implicit links” by recognizing note names across the vault—so mentioning “Eurostar 2023” can still connect to the corresponding note. Graph view then visualizes these relationships, letting users navigate from one idea to related ones and see the structure of their knowledge network.

How can Obsidian support both experimentation and long-term learning?

For experimentation, notes can act as dev/test logs: Markdown tables track multiple test runs with metrics, and notes can link to tools like k6 and Grafana dashboards. For long-term learning, the system supports distillation: after figuring out the correct approach (e.g., installing Grafana on Kubernetes), a parent note can capture the clean, step-by-step procedure while leaving the messy exploration in the log. This reduces future friction because the next attempt starts from the distilled result, not from scratch.

In what way do published notes become “learning exhaust,” and why is that valuable?

Learning exhaust refers to the byproducts of learning in public—publishing notes, change logs, and incremental updates without requiring a fully polished blog post. It quantifies ongoing work and creates a record of what’s been tried, corrected, and refined. That record also helps others (and future employers) see what someone has been working on and how their understanding evolves.

Review Questions

  1. How do siloed, static notes differ from a continuous note-taking system in terms of usefulness over time?
  2. Describe how CI/CD maps onto the steps of capturing, processing, sharing, and revising notes.
  3. What specific Obsidian features (linking, implicit mentions, graph view, local Markdown storage) support building an interconnected knowledge base?

Key Points

  1. 1

    Traditional notes often fail because they’re siloed, frozen after a short goal, and never revisited as knowledge grows.

  2. 2

    A robust note system should be interconnected, continuously evolving, multi-level (context plus abstraction), and future-proof.

  3. 3

    Continuous note taking adapts CI/CD: capture learning, distill it, share it, collect feedback, and iterate.

  4. 4

    Obsidian supports this with local-first Markdown storage, portable vault folders, and strong linking (explicit and implicit).

  5. 5

    Graph view helps users see how ideas connect, turning scattered notes into a navigable knowledge network.

  6. 6

    Notes can serve multiple roles at once: test logs for experimentation, distilled guides for repeatable tasks, and curated shorthands for recurring topics.

  7. 7

    Publishing notes and maintaining change logs create “learning exhaust,” which builds a visible record of growth and capability.

Highlights

The talk reframes note-taking as a continuous improvement loop—capture, process, publish, get feedback, and revise—rather than a one-time record.
Obsidian’s local-first design (vault folder of plain Markdown files) is presented as the foundation for portability and long-term ownership.
Linking is treated as essential: explicit links via brackets and implicit links via note-name recognition keep ideas connected without extra manual work.
Graph view turns a personal archive into a knowledge map, making relationships between concepts visible.
“Learning exhaust” reframes publishing as a low-pressure way to document progress and corrections over time.

Topics