Get AI summaries of any video or article — Sign up free
노트 앱에 폴더가 왜 필요해? | Logseq의 폴더구조가 없는 이유 thumbnail

노트 앱에 폴더가 왜 필요해? | Logseq의 폴더구조가 없는 이유

코리안키·
4 min read

Based on 코리안키's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

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?

Folders typically exist to express upper–lower relationships when notes are independent files that can’t contain other files. In many systems, depth is hard to represent because notes don’t naturally nest. Logseq instead uses blocks as the core unit; blocks can contain other content, so hierarchy is expressed through nesting rather than directory trees.

How do blocks replace the “folder” concept in Logseq?

Blocks can be nested so that content placed inside a deeper block behaves like it’s stored within a folder. The transcript’s example (imagining blocks like “2-1” and “2-2”) illustrates that when a block is nested, everything inside it gains the same containment effect as placing pages inside a folder.

What’s the advantage of pages that can also behave like folders?

In Logseq, a page can be both a container and a writable note. The example creates a page like “CTA” and then adds “회계학 1부” under it; “회계학 1부” is simultaneously a folder-like parent for sub-pages and a page where content can be written. This avoids the common limitation where folders can’t hold meaningful text content.

How can queries act like “virtual folders” in Logseq?

Queries search across pages and blocks using properties. For instance, a query can retrieve all items whose “public” property equals “true.” The returned set behaves like a folder containing those items, but it’s generated dynamically from metadata rather than fixed in a directory structure.

What does the transcript suggest users should do instead of relying on folders?

It recommends using Logseq’s native structure mechanisms—blocks, pages, and query/property tools—rather than forcing a folder mindset. For workflows like flash cards, it also emphasizes learning the card creation syntax and using it directly.

Review Questions

  1. What two Logseq features are presented as primary replacements for folder-based hierarchy, and how does each one work?
  2. Why does the transcript claim that adding folders on top of blocks would increase complexity without improving expression?
  3. 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. 1

    Logseq avoids traditional folders because blocks already provide a reliable way to express hierarchy through nesting.

  2. 2

    Folders are treated as a workaround for apps where notes can’t contain other notes; Logseq’s block model removes that need.

  3. 3

    Pages in Logseq can act as both containers and writable notes, enabling sub-pages and direct content in the same structure.

  4. 4

    Query-based retrieval can create dynamic “collections” that function like virtual folders based on properties.

  5. 5

    Using Logseq’s native syntax (blocks/pages/queries) is positioned as more strategic than trying to replicate a folder tree.

  6. 6

    The session connects these structural ideas to practical flash-card workflows, encouraging hands-on use of card creation syntax.

Highlights

Blocks in Logseq act like containers, so nesting blocks produces the same practical effect as placing items inside folders.
Pages can simultaneously serve as folder-like parents and as writable notes, eliminating the “folders can’t hold content” problem.
Property-driven queries can replace static folder organization by generating dynamic sets of matching pages/blocks (e.g., public items).

Topics

  • Logseq Folderless Structure
  • Blocks as Containers
  • Pages as Hierarchy
  • Query-Based Organization
  • Flash Card Syntax