노트 앱에 폴더가 왜 필요해? | Logseq의 폴더구조가 없는 이유
Based on 코리안키's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
Logseq avoids traditional folders because blocks already provide a reliable way to express hierarchy through nesting.
Briefing
Logseq doesn’t use a traditional folder tree because its core building blocks already model hierarchy more directly—and more flexibly—than folders ever could. Instead of forcing notes into parent-child directories, Logseq relies on blocks and page structure so that “containment” and “depth” are expressed through the writing syntax itself. In practice, creating a new page doesn’t require choosing a folder; it’s created directly, and hierarchy emerges from how blocks and pages nest inside one another.
The first reason is structural: folders exist mainly to represent upper–lower relationships when files can’t contain other files. Many note apps treat each note as an independent file, so folders become the workaround for organizing depth. Logseq flips that assumption. Its fundamental unit is the block, which behaves like a container. When a block is nested—such as imagining “2-1” and “2-2” blocks—everything placed inside the nested block effectively lives “inside a folder” with the same organizational effect. Because blocks already preserve hierarchy faithfully, adding a separate folder concept would add complexity without adding real expressive power.
A second reason is that Logseq’s pages can also act like folders. A page can contain content and also contain sub-pages, meaning the same entity can serve both roles at once. The transcript gives an example where a page like “CTA” can be expanded by creating another page such as “회계학 1부” under it. That “회계학 1부” page is simultaneously a container (like a folder) and a writable page (unlike a folder in many systems). This removes the common limitation where “folders can’t hold content,” and it enables a more continuous workflow: create a page, nest pages under it, and write directly where needed.
Logseq also reduces the need for folders through query-based retrieval. Queries search across blocks and pages using properties, producing results that function like dynamic collections. For example, searching for cards where a property like “public” equals “true” effectively creates a “virtual folder” containing all matching items. Since these collections are generated on demand from metadata, organization can be expressed as filters rather than fixed directory paths.
Taken together, the approach is strategic: folders are optional because Logseq’s hierarchy is built into blocks and pages, and its organization can be recomputed through queries. The practical takeaway is to lean into Logseq’s native syntax—especially for card workflows—rather than trying to force a folder mindset onto a system designed around nesting and property-driven retrieval. The session ends by emphasizing hands-on learning of Logseq’s card creation syntax and previewing a next step that uses card tags and shift-based commands to build cards more effectively.
Cornell Notes
Logseq avoids traditional folder structures because hierarchy is already represented by blocks and pages. Blocks act like containers, so nesting blocks creates the same “inside a folder” effect without needing directories. Pages can also function as both containers and writable notes, letting users store content and sub-pages in the same place. Queries further reduce reliance on folders by generating dynamic collections from properties (e.g., finding all items where a property like “public” is true). The result is a more flexible organization model: structure comes from nesting syntax, and organization can be retrieved through metadata-driven searches.
Why do folders exist in many note apps, and why does Logseq treat that differently?
How do blocks replace the “folder” concept in Logseq?
What’s the advantage of pages that can also behave like folders?
How can queries act like “virtual folders” in Logseq?
What does the transcript suggest users should do instead of relying on folders?
Review Questions
- What two Logseq features are presented as primary replacements for folder-based hierarchy, and how does each one work?
- Why does the transcript claim that adding folders on top of blocks would increase complexity without improving expression?
- Give an example of how a query with a property (like “public = true”) can substitute for a folder. What changes about the organization model when it’s dynamic?
Key Points
- 1
Logseq avoids traditional folders because blocks already provide a reliable way to express hierarchy through nesting.
- 2
Folders are treated as a workaround for apps where notes can’t contain other notes; Logseq’s block model removes that need.
- 3
Pages in Logseq can act as both containers and writable notes, enabling sub-pages and direct content in the same structure.
- 4
Query-based retrieval can create dynamic “collections” that function like virtual folders based on properties.
- 5
Using Logseq’s native syntax (blocks/pages/queries) is positioned as more strategic than trying to replicate a folder tree.
- 6
The session connects these structural ideas to practical flash-card workflows, encouraging hands-on use of card creation syntax.