Get AI summaries of any video or article — Sign up free
Should you use blocks or pages in LogSeq? thumbnail

Should you use blocks or pages in LogSeq?

Tools on Tech·
5 min read

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

TL;DR

Use pages for long-lived topics (projects, people, books, movies, software) because pages are easier to search and are the basis of the knowledge graph.

Briefing

LogSeq users deciding between pages and blocks should default to pages for anything that will grow over time—topics, references, and “things” worth revisiting—because pages are faster to find, easier to navigate, and form the backbone of LogSeq’s knowledge graph. Blocks still matter, but they’re best reserved for the connective tissue: notes, metadata, and journal entries that point back to those pages.

Pages in LogSeq are top-level blocks stored in their own file. That structure gives them practical advantages. They’re easier to search and add while typing, largely because there are fewer pages than blocks. They also tend to appear quicker in search results. Pages can include multiple top-level blocks in a single page, with the first block commonly used to hold page properties. For quick access, pages can be marked as favorites. Most importantly, the knowledge graph is built from pages, so the network of relationships LogSeq can visualize and traverse is fundamentally page-centered.

Blocks, by contrast, are the “lines of text” that can nest into sub-blocks. They’re ideal when the goal is to keep writing without breaking flow. Adding information to a block is frictionless: link to a page, add details, and return without needing extra navigation steps. The workflow difference becomes especially noticeable when capturing time-sensitive or high-volume notes—like a daily journal—where constant context switching would slow down capture.

In one personal system, the split is intentionally fuzzy but follows a consistent rule of thumb. Anything expected to accumulate and expand becomes a page: projects, people, books, movies, and software applications. Blocks then serve as references to those pages. That shows up strongly in the journal. When a gift is relevant to a person, a block tagged “gift” gets linked to that person’s page, enabling later retrieval by opening the person’s page and filtering on the gift tag. Meeting notes work the same way: a block created during the day includes tags such as “meeting,” plus metadata like the relevant project and attendees, and links back to the relevant pages. The same pattern applies to emails or chat messages saved to the journal with appropriate tags.

The payoff is a project page that acts like a timeline: opening a project page typically surfaces a clear sequence of related activities, because blocks in the journal link back to the project page. Over time, this builds a database of small notes—articles saved for later, quotes extracted from books, observations captured in context—each linking back to a stable page.

When deciding whether to start with a page or a block, the guidance is pragmatic: pick a page by default because it can always be merged with other pages later, and blocks can be redirected to new pages if needed. If a page has no references yet, it may be worth reconsidering whether it should have stayed a block—but changing structure later can be harder than choosing the safer option upfront. The overall strategy is simple: pages anchor the system; blocks feed it with structured, linkable detail.

Cornell Notes

Pages in LogSeq are top-level blocks stored in their own file, which makes them easier to search, faster to surface, and central to the knowledge graph. Blocks are nested lines of text that work best for capturing information without interrupting writing flow and for structuring related notes with tags and metadata. A practical system uses pages for long-lived topics—projects, people, books, movies, and software—while blocks live in the journal and link back to those pages. This creates project pages that function like timelines of related activities. When uncertain, starting with a page is favored because pages can be merged later, and existing blocks can be repointed to new pages to keep links intact.

Why are pages treated as the “foundation” in LogSeq workflows?

Pages are top-level blocks saved in their own file, which makes them easier to search and quicker to appear in results because there are typically fewer pages than blocks. They can also be favorited for fast access, and the first top-level block can store page properties. Crucially, LogSeq’s knowledge graph is built from pages, so relationships and navigation patterns naturally center on page nodes.

What makes blocks better for capturing information while staying in writing mode?

Blocks support continuous typing and outlining without extra navigation steps. In the described workflow, adding details to a block keeps momentum—linking to a page, inserting information, and returning avoids workflow breaks that come with more mouse-dependent hover options. Blocks also fit naturally for nested structure (sub-blocks) when shaping notes like meeting details or journal entries.

How does the system decide what becomes a page versus what stays a block?

The split is intentionally flexible, but the guiding idea is longevity and growth. Topics expected to accumulate over time become pages: projects, people, books, movies, and software applications. Blocks then act as references to those pages, especially in the journal, where entries include tags and metadata and link back to the relevant page.

How do journal blocks turn into a useful “timeline” on a project page?

Journal blocks are tagged and linked to topic pages. For example, a gift block tagged “gift” links to a specific person’s page, enabling later filtering from that person page. Meeting-note blocks tagged “meeting” include metadata like the relevant project and attendees and link to the project page. When the project page is opened, linked blocks surface as a time-ordered stream of related activities.

What practical advice is given when unsure whether to create a page or a block?

Default to pages when uncertain because they can be merged later to consolidate topics. If something starts as a block, it can later be updated to point to a new or revised page, helping preserve the linked network. The tradeoff is that demoting a page back into a block can be harder, especially once references exist.

Review Questions

  1. In what ways do pages outperform blocks for search and navigation, and how does that connect to the knowledge graph?
  2. Give two examples of information that should be stored as blocks in this system, and explain what page each block should link back to.
  3. What is the recommended default choice when deciding between pages and blocks, and what flexibility does that choice preserve later?

Key Points

  1. 1

    Use pages for long-lived topics (projects, people, books, movies, software) because pages are easier to search and are the basis of the knowledge graph.

  2. 2

    Use blocks for capture-heavy notes (journal entries, meeting notes, messages) where uninterrupted typing and nested structure matter.

  3. 3

    Link journal blocks back to the relevant topic pages so opening a page (like a project) surfaces a timeline of related activity.

  4. 4

    Store page properties in the first top-level block when you need structured metadata at the page level.

  5. 5

    When uncertain, start with a page; merge pages later if needed, and repoint blocks to new pages to avoid link breakage.

  6. 6

    Treat demoting a page back into a block as a higher-friction change, especially once references accumulate.

Highlights

Pages are top-level blocks in their own file, making them faster to find and central to the knowledge graph.
Blocks shine for frictionless capture—especially in a journal—because they support continuous typing and nested outlining.
Linking tagged journal blocks back to project pages turns those pages into practical timelines of activity.
Defaulting to pages reduces future restructuring risk because pages can be merged and blocks can be repointed.

Topics