Get AI summaries of any video or article — Sign up free
Rethinking MY PKM: How I Organize Everything In Obsidian thumbnail

Rethinking MY PKM: How I Organize Everything In Obsidian

5 min read

Based on Zsolt's Visual Personal Knowledge Management's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Apply latch (location, alphabet, time, category, hierarchy) as the design goal for findability, not as an afterthought.

Briefing

A disciplined Obsidian system built around “latch” is the core through-line: every note is placed so it can be found by location, alphabet, time, category, and hierarchy—while automation and strict linking prevent the vault from turning into a pile of disconnected files. The practical payoff is findability. Instead of relying on search alone, the workflow treats each piece of information as something that should connect to a graph, a timeline, or a namespace, so retrieval stays fast even as the vault grows.

The system starts with six principles. First, each of the 14 components has a clear, single purpose, keeping the workflow from becoming a tangle of overlapping tools. Second, friction is minimized through automation—primarily using Templater and Data View. Third, the “brownfield reality” is embraced: past PKM systems and imported content (including archives going back decades and materials from tools like Evernote and research workflows) are messy, so the approach focuses on managing the mess rather than pretending it can be cleaned instantly. Fourth, files are not moved around; relocating content breaks links in Obsidian, so items are placed once and left in place even when folder structure isn’t perfect.

Fifth, latch becomes the organizing engine. The workflow is designed so information can be retrieved by calendar/time (daily notes), by physical or memorable location (geotags and map view), by alphabetic anchors (people and other namespaces), by category (single-tag “type” per page), and by hierarchy (parent/child relationships via ontology). Sixth, linking is treated as non-negotiable. Orphan notes—files nobody points to—were found in the high hundreds (roughly 500–600). The fix: only keep files in the vault when they can be linked into the graph.

From there, the system’s components are implemented with concrete Obsidian mechanics. Folders are treated less like storage and more like namespaces. Ghost links let us create “people” entries (e.g., authors) without first creating the underlying folder, and folder naming supports synchronization control: large media folders can be excluded from Obsidian Sync while still living inside the vault. Attachments are kept under topic subfolders, and new-note placement follows a default-location rule unless a namespace path is used.

Tags are used sparingly—typically one tag per page—to define a document’s type and drive consistent styling in Excalidraw Brain (including color schemes and icons). Links are structured through an ontology defined with Data View fields, distinguishing parent/child and lateral “friend” relationships. Those relationships then shape how nodes appear on the graph and how connections are suggested during editing.

The workflow leans heavily on reuse: atomic notes and transclusion prevent duplication, while consistent section headings (like “summary”) make embedding predictable. File naming conventions reinforce retrieval: Map of Contents (MOCs) start with an underscore, image libraries use structured names that include type, keywords, and source, and dates follow a year-month-day format. Templates automate repetitive creation, including multi-file and folder setups for workflows like YouTube.

Finally, daily notes create the time hierarchy that latch depends on, while geotags and check-in/check-out events link trips (Rome, Sicily, Aetna, and more) to specific days. Tasks are surfaced in context using Data View queries and dynamic lists, so when someone’s page is opened, the relevant “waiting for / promised / discuss” actions appear immediately. A diagnostics and maintenance page tracks orphan notes and pasted images that need cleanup, keeping the system healthy as it scales.

Cornell Notes

The system is built to keep an Obsidian vault findable as it grows by enforcing six principles—especially “latch” (location, alphabet, time, category, hierarchy) plus deliberate linking. Automation (Templater and Data View) reduces friction, while a “brownfield reality” approach accepts messy imported history instead of trying to reset everything. Files are placed once and rarely moved to avoid broken links, and orphan notes are treated as a failure mode (hundreds existed before the linking rule). Folders act like namespaces, tags define a single document type and drive consistent graph styling, and an ontology (parent/child vs lateral links) structures the graph. Daily notes and geotags provide the time and location axes for latch, while Data View task queries bring action items into the context of people and projects.

How does “latch” translate into actual retrieval paths inside the vault?

Latch is applied as five complementary ways to find information: (1) Location via geotags and map view, including check-in/check-out events for trips; (2) Alphabet via namespaces like people/author entries that can be created as ghost links; (3) Time via daily notes that form a chain of days (tomorrow links) and connect events to specific dates; (4) Category via a single tag per page that defines document type; and (5) Hierarchy via ontology relationships (parent/child and lateral “friend” links) that determine how nodes connect on the graph.

Why does the workflow avoid moving files around, and what problem does it prevent?

Moving files is treated as risky because links can break in Obsidian when paths change. Instead of following a project-based “move in, move out” pattern, the system places content in a stable location and keeps it there, even if it means some items don’t perfectly match folder expectations.

What does “linking only” mean in practice, and how is orphan-note risk managed?

Orphan notes are files nobody points to in the graph. The vault had roughly 500–600 orphans at one point, largely because folders were used as topic containers without explicit linking. The rule becomes: keep a file in the vault only if it can be linked into the graph (so it has at least one meaningful connection). A diagnostics/maintenance page then monitors orphan counts and other hygiene issues like pasted images that need naming.

How do tags function beyond search—what do they control?

Tags are used mainly to define a document’s type, typically with one tag per page. That type then drives consistent rendering in Excalidraw Brain (colors, icons, and node appearance). For example, map-of-content pages share a specific tag that gives them a “map” icon and red styling, while people pages show a person icon and distinct colors; ontology and graph readability benefit from this visual consistency.

What role does ontology play in building the graph structure?

Ontology defines relationships between notes using Data View fields. It distinguishes parent/child connections from lateral “friend” relationships, and those relationship types control how nodes appear and connect on the graph. An ontology suggestor can be triggered (via a triple-colon prompt) to quickly choose relationship types, and some ontologies can be excluded or left unregistered temporarily as the system evolves.

How are tasks made context-sensitive for people and projects?

Tasks are displayed on the relevant person/project/topic page using Data View queries and dynamic lists. When a page like “Bob the Builder” is opened, the task section shows actions tied to that person—such as meetings to discuss items with specific collaborators or follow-ups for promised/waiting items. Templates ensure the task section exists on most pages, so the context automatically pulls the right task list.

Review Questions

  1. Which five retrieval axes does latch provide, and what Obsidian features support each one in this system?
  2. What mechanisms prevent orphan notes from accumulating, and how does the system detect them?
  3. How do ontology relationships (parent/child vs lateral) and tags work together to shape graph structure and readability?

Key Points

  1. 1

    Apply latch (location, alphabet, time, category, hierarchy) as the design goal for findability, not as an afterthought.

  2. 2

    Use automation (Templater and Data View) to reduce repetitive setup and keep workflows consistent.

  3. 3

    Accept brownfield history by managing imported and archived content rather than trying to fully reorganize it immediately.

  4. 4

    Place files once and avoid moving them to prevent broken links; treat stable paths as part of the system.

  5. 5

    Enforce linking discipline: keep files only when they connect into the graph, and monitor orphan notes via a diagnostics page.

  6. 6

    Use folders as namespaces and ghost links to create typed entities (like authors) without requiring physical folder creation first.

  7. 7

    Make tasks context-sensitive by embedding Data View task queries into person/project/topic pages via templates.

Highlights

Orphan notes were found in the high hundreds (about 500–600), which triggered a rule to keep files only when they can be linked into the graph.
Latch is implemented through daily notes (time), geotags and check-in/check-out events (location), single-tag types (category), namespaces like people/author (alphabet), and ontology-driven parent/child plus lateral links (hierarchy).
The system avoids moving files because link breakage is treated as a structural threat to the vault.
Tags are not just metadata here—they drive consistent visual styling in Excalidraw Brain (icons and color schemes) so the graph is easier to interpret.
Atomic notes and transclusion reuse content through consistent section headings like “summary,” reducing duplication while keeping embeddings predictable.

Topics

  • LATCH Organization
  • Obsidian Namespaces
  • Ontology Graph Links
  • Daily Notes Time Hierarchy
  • Data View Task Queries

Mentioned

  • PKM