Get AI summaries of any video or article — Sign up free
How to Organize Notes in Obsidian (Folders vs MOCs vs Tags ) thumbnail

How to Organize Notes in Obsidian (Folders vs MOCs vs Tags )

Shuvangkar Das, PhD·
5 min read

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

TL;DR

Start with MOCs (mock/map-of-content) as topic entry points to reduce repeated decisions about where notes should go.

Briefing

The clearest takeaway is that Obsidian organization should start with low-friction navigation—using MOCs (map of content) as index nodes—while treating folders and tags as secondary tools. Folder-heavy systems often trigger decision paralysis and break “single source of truth,” whereas MOCs reduce the need to guess where a note belongs by making each topic’s entry point the starting location for related notes.

Folder organization feels familiar, but it creates recurring dilemmas as knowledge grows. A common example is splitting Python notes across two folders—“Python basic” and “Python project one.” When a new note (like “how to read files in Python”) belongs to both learning and a specific project, the system forces a choice: place it under one folder and then later realize the other folder also needs it. Over time, nested folders can become a “rabbit hole,” where months later the user forgets what exists where, turning note retrieval into a treasure hunt.

Folders also complicate single source of truth. If one note is meant to serve as the canonical reference for a concept (e.g., a single “file reading in Python” note), folder rules make it hard to keep that one note as the shared reference across multiple contexts. The result is duplication—copies of the same idea living in different folders—so the system drifts away from maintaining one authoritative note per concept.

That said, folders aren’t dismissed entirely. They work when life domains truly don’t need connections—like separating a “journal” folder from “template,” or “home” from “study.” The practical guardrail offered is to avoid deep nesting: never go more than two levels deep. Even then, navigation shouldn’t rely on folder drilling. Instead, quick switching (e.g., Control+O) is positioned as the faster way to reach notes.

The alternative is folderless organization built around MOCs. In this approach, “mock” nodes (MOCs) act as topic indexes—such as “mock investment” or “mock Python.” Related notes link outward from the index, so learning stock starts by opening “mock investment,” then selecting or creating a “stock” note from there. This reduces decision fatigue because the user doesn’t repeatedly ask where a note should live; the topic index becomes the default entry point.

MOCs do introduce clutter risk when attachments (images, videos) appear alongside notes. The fix is to set an attachment default location in Obsidian so new files automatically go into an “attachment” directory (creating an attachment subfolder), keeping the main note area clean.

Tags come last and serve a different purpose. Tags are framed as signals, not structure—use them to answer quick discovery questions like “show me all course notes” or “show me all stories.” The system encourages adding tags for future connections, not building the entire architecture around them.

Finally, the most flexible recommendation is hybrid: use folders for top-level separation and searchability, then add MOCs inside those folders, and use tags for discoverability. The goal is a scalable system that minimizes repeated decisions while keeping notes easy to find and link over time.

Cornell Notes

Obsidian organization works best when it minimizes repeated “where should this go?” decisions. Folder-based systems can cause decision paralysis, create rabbit-hole navigation, and undermine single source of truth by encouraging duplicated notes across multiple folders. A folderless approach using MOCs (mock/map-of-content index nodes) makes topic entry points the default starting location, so related notes are linked from the index rather than sorted into deep folder trees. Tags should function as signals for quick filtering (e.g., stories, code, course), not as the primary structure. A hybrid setup—folders for top-level separation plus MOCs for connections—offers a scalable path as comfort grows.

Why do folders often create confusion as a knowledge base grows in Obsidian?

Folders force a choice when one note fits multiple contexts. The transcript’s Python example shows a note like “how to read file” that could belong under both “Python basic” and “Python project one.” Once it’s placed in one folder, the other context still needs it, leading to either moving it later or duplicating it. Over time, nested folders also become a “rabbit hole,” where months later the user forgets what exists where and retrieval turns into a treasure hunt.

How does folder organization conflict with the idea of single source of truth?

Single source of truth means one concept should have one canonical note. In a folder system, the same note can’t naturally “coexist” in two different folder locations, so users often copy the same content into multiple places. The transcript describes duplicating a “file reading in Python” note so it appears in both the general learning area and the project area, creating multiple versions of what should be one reference.

What practical rules are suggested to make folder use less painful?

Folders are acceptable when domains don’t need connections (e.g., journal vs templates, home vs study). If folders are used, the rule is to avoid deep nesting: never go more than two levels deep. Navigation should also rely on shortcuts/quick switcher (e.g., Control+O) rather than drilling through folders.

How do MOCs (mock/map-of-content) reduce decision fatigue?

MOCs act as topic indexes. Instead of asking where a note belongs, the user starts at the relevant index node (e.g., “mock investment” for stock learning or “mock Python” for programming learning). From that index, related notes are opened or created as linked children, so organization happens through linking from a stable entry point rather than through repeated folder placement decisions.

What’s the main downside of MOCs mentioned, and how is it handled?

MOCs can clutter the note area when attachments like images and video links appear at the same level as notes. The workaround is to set a default attachment location in Obsidian (via the files and links property), so new attachments automatically go into a dedicated attachment directory/subfolder, keeping the main index and notes cleaner.

What’s the recommended role of tags in this system?

Tags are described as signals, not structure. They’re used to answer quick filtering questions—such as finding all course notes, stories, or tasks—by searching for a tag. The transcript also encourages using multiple tags to improve future discoverability and enable connections across topics, but not to replace the core organization method.

Review Questions

  1. If a single note fits two different contexts (like “Python basic” and “Python project one”), what problems can folder organization create, and what alternatives are suggested?
  2. How do MOCs change the workflow for creating and finding notes compared with folder drilling?
  3. Why are tags treated as signals rather than the primary organizing structure in this approach?

Key Points

  1. 1

    Start with MOCs (mock/map-of-content) as topic entry points to reduce repeated decisions about where notes should go.

  2. 2

    Folder systems can trigger decision paralysis when one note belongs to multiple contexts, leading to moving notes or duplicating them.

  3. 3

    Nested folders often become a “rabbit hole,” making retrieval harder months later and turning searching into a treasure hunt.

  4. 4

    Folders undermine single source of truth because one canonical note is difficult to share across multiple folder locations without duplication.

  5. 5

    If using folders, keep nesting shallow (no more than two levels deep) and navigate with quick switcher/shortcuts like Control+O.

  6. 6

    Use attachments default location settings to prevent MOC clutter by routing images/videos into an attachment directory.

  7. 7

    Treat tags as signals for fast filtering and discovery (stories, code, course), not as the system’s structural backbone.

Highlights

Folders can force constant “placement” decisions; the Python example shows how one note can belong to both learning and project contexts, creating either duplication or churn.
Deep folder trees become hard to remember, turning note retrieval into a treasure hunt months later.
MOCs work like stable index nodes: open the topic index first, then create or link related notes from there.
Tags are for filtering and future connections—not for building the entire organization structure.
A hybrid approach is practical: use folders for top-level separation, MOCs for connections, and tags for discoverability.

Topics

  • Obsidian Note Organization
  • Folders vs MOCs
  • Map of Content
  • Tags as Signals
  • Single Source of Truth

Mentioned