Get AI summaries of any video or article — Sign up free
How to Get Started with Logseq | Videos I wish I had (Part 1) thumbnail

How to Get Started with Logseq | Videos I wish I had (Part 1)

CombiningMinds·
5 min read

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

TL;DR

Logseq shifts from folder hierarchy to a bottom-up graph where pages are linked nodes, making resurfacing depend less on remembering file locations.

Briefing

Logseq’s core advantage for a complete beginner is that it replaces folder-based “top-down” storage with a bottom-up network of linked notes—so information can be found again through backlinks, search, and topic connections rather than through perfect file hierarchies. The practical payoff is immediate: when notes live in folders, working memory becomes the organizing system, and important material can vanish simply because the user can’t remember where it was filed. In Logseq, every entry becomes a node in a graph, and linking those nodes turns scattered thoughts into a navigable knowledge network.

The foundation starts with two building blocks. Blocks are the smallest functional unit—each line of text (entered in the journal) is a block. Pages are a different type of block that represent named nodes in the graph. Creating a page happens when text like “page one” or “page two” is entered; the moment a page is linked from another page (for example, typing “page two” inside “page one”), a connection appears in the graph. Hashtags can also create the same kind of linking, and the graph view visualizes relationships such as triangles formed by mutual links across pages. This linking mechanism is what turns raw entries into an interconnected knowledge graph.

Beyond the mechanics, the workflow design matters. The creator frames early struggles around advice to “just start writing,” saying that approach didn’t work until a more deliberate process was built. Instead of chasing one-size-fits-all habits, the system is guided by five design goals: easy searching and resurfacing of notes, a usable graph view that highlights important topics rather than becoming an unreadable cluster, decoupling inputs from outputs (while still keeping links so sources remain traceable), removing clutter, and keeping the process frictionless enough to actually sustain.

A major decision point is whether to enter information in the journal or on a page. The journal is treated as a high-frequency intake area for micro inputs—small items like tweets, short articles, YouTube videos, and podcasts—plus quick thoughts, to-dos, and notes from calls or irregular meetings. Pages are reserved for macro inputs: dense materials like books and long articles, recurring meetings that should be easy to access, and process/output content such as synthesized ideas for publishing. To make this choice consistent, four filters are used: how frequently something is entered, the weight or density of the information, how predictable the workflow is, and the coherence of the intended output.

Tags play a special role in this setup. Pages are used “at will” for tags to improve searchability without cluttering the journal or the graph lines directly, with the trade-off that many unlinked pages can form an “asteroid belt” around the graph. The creator has moved past that aesthetic annoyance, treating it as part of the process. The session ends by positioning this as theory-first groundwork, with a follow-up planned to focus more on practical implementation.

Cornell Notes

Logseq’s value comes from bottom-up knowledge building: notes become graph nodes (pages) connected by links, rather than being buried in folder hierarchies. Blocks are the basic unit of entry, while pages are named nodes that appear in the graph; linking one page from another creates visible connections. A usable workflow depends on design principles such as fast resurfacing, a graph that supports navigation, keeping inputs and outputs distinct (without losing traceability), reducing clutter, and maintaining low friction. The journal is optimized for frequent micro inputs and quick capture, while pages handle dense macro inputs, recurring meetings, and synthesized outputs. Filters—entry frequency, information weight, workflow predictability, and output coherence—help decide where each item belongs.

Why does folder-based note-taking tend to fail even when the system seems organized?

Folder systems require top-down categorization (work/personal, then projects, then documents). That structure creates silos and forces the user to remember where something was stored. The creator describes working memory as unreliable: once notes are filed, it’s easy to lose them later because the user can’t recall the exact folder path. Logseq’s network approach avoids that dependency by letting search and backlinks surface related material without requiring perfect recall of hierarchy.

What are blocks and pages in Logseq, and how do they relate to the graph?

Blocks are the core functional unit—each journal entry is a block, typically entered as text separated by line breaks. Pages are a different type of block that become nodes in the graph. When a page name like “page one” is typed, Logseq creates a page/node. When “page two” is typed inside “page one,” the system creates a link, and the graph shows a connection between those nodes.

How does linking actually build a knowledge graph in practice?

Linking happens when one page references another. Typing a page name inside a page creates a linked reference; the graph updates to show the relationship. The creator demonstrates building structures like triangles by linking multiple pages to each other. Hashtags can also create the same linking behavior, producing graph connections that support later navigation and resurfacing.

What design principles guide the choice between journal and pages?

The system aims for easy searching/resurfacing, a graph view that supports finding information, and decoupling inputs from outputs while preserving traceability through links. It also emphasizes removing clutter and keeping the workflow frictionless. Those goals translate into a practical rule: journal for frequent micro inputs and quick capture; pages for dense macro inputs, recurring meetings, and synthesized output.

What four filters decide whether information belongs in the journal or on a page?

First is frequency of entry: journal entries are frequent; pages are less frequent. Second is weight/density: journal holds bite-sized items, while pages hold chunky inputs like books, meetings, and process notes. Third is accessibility/workflow predictability: irregular workflows go to the journal, while predictable workflows are increasingly driven by pages. Fourth is coherence of output: stream-of-consciousness or fleeting thoughts go to the journal (tagged “fleeting”), while processed, durable ideas become “permanent” and are placed where they support coherent output.

What trade-off comes with using many pages for tags?

Using pages for tags improves searchability and avoids clutter within the journal lines and graph connections. The downside is visual/structural: many unlinked pages can create an “asteroid belt” around the knowledge graph. The creator says this used to annoy them but is now accepted as part of the process.

Review Questions

  1. How do blocks and pages differ, and what action creates a visible connection in Logseq’s graph?
  2. Give an example of an item that should go in the journal versus a page, using the four filters described.
  3. What does “decoupling inputs and outputs” mean in this workflow, and how do links preserve traceability?

Key Points

  1. 1

    Logseq shifts from folder hierarchy to a bottom-up graph where pages are linked nodes, making resurfacing depend less on remembering file locations.

  2. 2

    Blocks are the smallest entry unit; pages are named nodes that appear in the graph and become connected when referenced from one another.

  3. 3

    Linking (via page references or hashtags) is the mechanism that turns captured notes into navigable relationships.

  4. 4

    A usable workflow is guided by goals like fast searching, a graph that supports retrieval, clutter reduction, and low-friction capture.

  5. 5

    Use the journal for frequent micro inputs and quick capture; use pages for dense macro inputs, recurring meetings, and synthesized outputs.

  6. 6

    Choose journal vs page using filters: entry frequency, information weight, workflow predictability, and output coherence.

  7. 7

    Using pages for tags improves searchability but can create an “asteroid belt” of unlinked nodes around the graph.

Highlights

Folders force organization through hierarchy and working memory; Logseq’s backlink-driven graph reduces reliance on remembering where something was stored.
Typing a page name inside another page creates a graph connection—linking is the moment knowledge becomes relational.
The journal is optimized for high-frequency micro inputs, while pages handle dense macro inputs, recurring meetings, and synthesized outputs.
Four filters—frequency, weight, accessibility/workflow predictability, and output coherence—turn a messy “where should this go?” problem into a repeatable decision.
Many tag pages can form an “asteroid belt” around the graph, but the trade-off is improved searchability without journal clutter.

Topics

  • Top-Down vs Bottom-Up Notes
  • Logseq Blocks and Pages
  • Graph Linking
  • Journal vs Pages
  • Tag Pages and Searchability