How I use Obsidian for work as a software developer advocate

TL;DR

A Personal Knowledge Management system helps tech workers retain learning despite fast-changing trends.

Briefing Cornell Notes

Briefing

Software trends swing fast enough to make even basic planning feel unstable—monoliths, microservices, and back again. The practical countermeasure offered here is to build a Personal Knowledge Management (PKM) system so learning and work don’t evaporate when the next framework or architecture cycle hits. For a software developer advocate, that PKM becomes the backbone for capturing information, turning it into usable understanding, and publishing outputs that others can benefit from.

Obsidian is presented as the PKM tool of choice: a free app that many label “note-taking,” but that functions more like a “second brain.” Notes are stored locally, with optional cloud backup, and saved in plain text—an approach aimed at long-term accessibility even if the app itself ever disappears. Extensibility is another pillar. Obsidian supports a plugin ecosystem built with JavaScript, and while the core app is not open source, it remains free; paid add-ons can add convenience such as one-click publishing.

What differentiates Obsidian from other tools (Roam Research, Notion, Evernote) comes down to philosophy and execution. The philosophy favors a loose structure of tightly interconnected ideas over rigid folder hierarchies. The execution leans on linking mechanics: typing two brackets creates backlinks to other notes, whether or not the target note already exists. A graph view visualizes these relationships, and opening a note reveals where it’s referenced—explicitly linked and also “unlinked mentions” that still surface as connections. The result is a system that nudges users toward serendipitous discovery. A concrete example comes from board-game notes on Viticulture, where the word “worker” triggered an unexpected connection to computer performance discussions about parallelism.

To support rediscovery, Obsidian also uses tags and front matter metadata. Together, backlinks, linked/unlinked mentions, tags, and metadata help re-surface prior work in new contexts.

The workflow is organized into three stages: input, processing, and output. Input gathers material from videos, articles, blog posts, books, and podcasts, with Readwise highlighting insights and automatically sending them into Obsidian. Meeting notes can be captured directly in Obsidian as well. Internal and external documentation stored as Markdown in a GitHub repository can be opened as an Obsidian vault, effectively turning the tool into an interface for documentation work. Feedback from product and service discussions is tagged so it can be routed to the relevant parts of the organization.

Processing happens daily—around 9:00 PM—by reviewing what Readwise delivered, summarizing in one’s own words, and building interconnected pages that act like a personal search engine. Output is treated as proof of learning: Obsidian’s built-in slides (via revealJS) turn notes into presentations, and it also powers a content calendar using the Kanban board plugin. Tasks become notes, then get scheduled and color-coded by channel. For publishing, Obsidian Publish is an optional paid service that pushes notes to a custom domain (notes.nicolevanderhoeven.com). Collaboration is handled through GitHub-style pull requests or by sharing a vault via Dropbox when real-time editing is needed.

In a field where change is constant, the central claim is that tools built for knowledge retention—especially those that make connections easy to find—reduce the cost of keeping up and increase the value of what gets learned.

Cornell Notes

Obsidian is used as a Personal Knowledge Management system to keep learning and work from getting lost as tech trends change. Its value comes from plain-text local storage, an extensible plugin ecosystem, and a linking-first approach that favors interconnected ideas over rigid folders. The workflow runs in three stages: capture information (including Readwise highlights and meeting notes), process it daily by summarizing and building linked pages that function like a personal search engine, and output it through presentations, content planning, and published notes. Tags, front matter metadata, backlinks, and “unlinked mentions” help rediscover knowledge in new contexts. The result is a durable, reusable system for developer advocacy work—turning raw inputs into shareable artifacts.

Why does plain-text, local storage matter in a PKM system like Obsidian?

Notes are stored locally and saved in plain text, with optional cloud backup. That design is meant to preserve access over time: even if Obsidian stops being maintained, the underlying notes remain readable because they aren’t locked into a proprietary format.

How does Obsidian’s linking model encourage “bigger picture” thinking?

Instead of relying on folders, it uses backlinks and lightweight linking. Typing two brackets creates links to other notes, even if the target note doesn’t exist yet. A graph view visualizes connections, and opening a note reveals where it’s referenced—both explicitly linked and “unlinked mentions.” This can surface unexpected relationships, like the word “worker” connecting board-game strategy notes (Viticulture) to computer performance discussions about parallel workers.

What does the daily processing step look like, and what is its purpose?

Each day around 9:00 PM, the user reviews what Readwise has delivered into Obsidian. They summarize insights in their own words and create notes in their own structure, then connect them into larger pages (e.g., a growing chaos engineering page). The process effectively builds a personal search engine for later recall and teaching.

How is Obsidian used for input beyond reading articles and watching videos?

Input includes meeting notes captured directly in Obsidian, plus documentation workflows. Markdown documentation stored in a GitHub repository can be opened as an Obsidian vault, letting the tool act like an IDE for interacting with that documentation. Product feedback is also tracked by tagging notes so it can be routed to relevant areas of the organization.

What counts as “output” in this system, and why is it treated as proof of learning?

Output is creating something new from the knowledge. Obsidian’s built-in slides (using revealJS) can turn notes into presentations quickly via a simple dash-based format. It also supports a content calendar using the Kanban board plugin, where tasks are notes and get scheduled and color-coded by channel. Publishing is streamlined with Obsidian Publish to a custom domain.

How does collaboration work when Obsidian lacks built-in team features?

Collaboration can be handled through GitHub workflows: if the team already collaborates via pull requests, Obsidian can fit into that process because the vault is stored as files. Another option tried is syncing a vault to a Dropbox folder and sharing it, enabling more real-time editing for collaborators.

Review Questions

What specific Obsidian features (linking, backlinks, unlinked mentions, tags, metadata) help rediscover knowledge, and how does that differ from folder-based systems?
Walk through the three-stage workflow (input, processing, output). What tools or integrations support each stage?
How do plain-text storage and optional publishing (Obsidian Publish) affect long-term usability and sharing of knowledge artifacts?

Key Points

1
A Personal Knowledge Management system helps tech workers retain learning despite fast-changing trends.
2
Obsidian’s plain-text, local-first storage is designed for long-term access and portability.
3
Backlinks, graph views, and “unlinked mentions” create a connection-driven workflow that can reveal unexpected relationships.
4
Tags and front matter metadata add structure for rediscovery without relying on rigid folder hierarchies.
5
A practical workflow runs from input (Readwise highlights, meeting notes, documentation) to daily processing (summaries and linked pages) to output (slides, content planning, publishing).
6
Obsidian can function as an interface for Markdown documentation stored in GitHub repositories by opening the folder as a vault.
7
Collaboration can be achieved via GitHub pull requests or by sharing a vault through Dropbox when more synchronous editing is needed.

Highlights

Obsidian’s linking system can surface “unlinked mentions,” turning a stray word like “worker” into a cross-domain connection between board-game strategy and computer performance concepts.

The workflow treats output—presentations, scheduled content, and published notes—as the moment learning becomes real and shareable.

Plain-text local storage is positioned as a longevity safeguard, reducing dependence on any single app’s continued maintenance.

Readwise integration feeds daily insights into Obsidian, where they’re summarized and woven into interconnected pages that act like a personal search engine.

Topics

Mentioned

Nicole van der Hoeven
PKM