How to Organize Notes in Obsidian (Folders vs MOCs vs Tags )
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.
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?
How does folder organization conflict with the idea of single source of truth?
What practical rules are suggested to make folder use less painful?
How do MOCs (mock/map-of-content) reduce decision fatigue?
What’s the main downside of MOCs mentioned, and how is it handled?
What’s the recommended role of tags in this system?
Review Questions
- 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?
- How do MOCs change the workflow for creating and finding notes compared with folder drilling?
- Why are tags treated as signals rather than the primary organizing structure in this approach?
Key Points
- 1
Start with MOCs (mock/map-of-content) as topic entry points to reduce repeated decisions about where notes should go.
- 2
Folder systems can trigger decision paralysis when one note belongs to multiple contexts, leading to moving notes or duplicating them.
- 3
Nested folders often become a “rabbit hole,” making retrieval harder months later and turning searching into a treasure hunt.
- 4
Folders undermine single source of truth because one canonical note is difficult to share across multiple folder locations without duplication.
- 5
If using folders, keep nesting shallow (no more than two levels deep) and navigate with quick switcher/shortcuts like Control+O.
- 6
Use attachments default location settings to prevent MOC clutter by routing images/videos into an attachment directory.
- 7
Treat tags as signals for fast filtering and discovery (stories, code, course), not as the system’s structural backbone.