Get AI summaries of any video or article — Sign up free
Logseq vs Notion | Understanding your 'Building a Second Brain' database thumbnail

Logseq vs Notion | Understanding your 'Building a Second Brain' database

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

Treat a second brain as a storage-and-retrieval system: capture choices determine how fast and accurate later retrieval will be.

Briefing

Personal knowledge management works best when notes behave like a database—because retrieval is only as fast as the way information is stored. The core insight here is that “querying your mind” is expensive: if notes aren’t captured with a usable structure, finding them later becomes slow and frustrating. Understanding database principles—storage, retrieval, and how relationships are represented—turns a second brain from a dumping ground into a system that can be searched, filtered, and traversed.

The discussion starts with a practical definition: a database is an organized collection of data stored and accessed electronically. Everyday examples mirror the idea—folder hierarchies for shared files, spreadsheets for task tracking, and e-commerce order histories that connect customers to products. In that framing, a second brain is a storage-and-retrieval engine: input determines how well information can be retrieved later. Storage is about how entries are created (journal pages, indentation, block placement), while retrieval is about queries, filtering, and search.

From there, the comparison shifts to database models. Relational databases use tables and typically enforce a schema: each record lives in a defined place, and relationships are represented through links between tables. The transcript walks through the evolution from Excel-style spreadsheets (with laborious lookups like VLOOKUP/XLOOKUP-style thinking) to Airtable, where projects and tasks sit in separate tables and tasks relate to their parent projects. Notion is positioned as a hybrid: it supports relational behavior (tables and linked records) but also allows pages to hold extra content outside the table, and it can display multiple related tables on one page—something Airtable doesn’t do in the same way.

Graph databases are presented as the next step for personal knowledge management. Instead of forcing everything into tables, graph systems treat the smallest unit of meaning—Logseq blocks—as nodes that can be tagged and linked anywhere. Each block gets a unique address, and links (via square brackets and hashtags) connect blocks to pages and to other blocks. Pages are described as a higher-level node type that helps organize relationships. Crucially, relationships are “first-class”: in graph database terms, relationships can have their own properties (like a start date for a “has CEO” relationship), not just the nodes.

Logseq is used as the concrete example of how this plays out. Projects can be created as pages, while tasks can be entered in journals and linked back to those project pages. The transcript also warns that nesting can affect what appears in views—tasks nested under a block may not show up the same way as tasks surfaced through queries/filters.

The payoff is why graph databases are argued to be better for PKM: they reduce the need for upfront structure (supporting stream-of-consciousness capture), make retrieval easier through tags/backlinks and powerful search, and enable knowledge traversal—clicking through relationships to see connected ideas, including implicit links. Finally, information can be replicated across multiple contexts and hierarchies without breaking, unlike rigid folder structures where moving or renaming can cause “path does not exist” problems. The overall message: treat notes as interconnected data, and the system becomes faster, more flexible, and more navigable over time.

Cornell Notes

The transcript frames a second brain as a database: effective storage enables efficient retrieval. It argues that mind-based “querying” is costly, so notes must be captured in a way that supports later search and filtering. Relational tools like Airtable rely on tables and schemas (e.g., separate Projects and Tasks tables linked together), while Notion blends relational tables with page-based flexibility. Graph databases—illustrated through Logseq blocks and links—treat blocks as nodes with unique addresses, where tags and backlinks connect information anywhere. This model supports stream-of-consciousness input, powerful retrieval, and knowledge traversal across relationships, making PKM more flexible than folder hierarchies.

Why does the transcript treat “understanding the database model” as the starting point for using a second brain tool effectively?

It ties tool value to retrieval cost: if notes aren’t stored in a retrievable structure, later searching becomes difficult. Storage choices (how entries are input—pages, indentation, blocks, tags) determine how well queries and filtering will work later. The practical claim is that investing time in first principles—storage and retrieval—reduces friction and increases long-term usefulness, especially in Logseq where block linking and tagging drive retrieval.

How do relational databases represent information and relationships, and what does that look like in the Airtable example?

Relational databases organize data into tables with a defined schema. The transcript’s example uses two tables: Projects and Tasks. Tasks are related to their parent project, so opening a project view shows the tasks linked to it. The schema matters because creating a new project automatically brings in the expected fields (even if empty), and lookups (the Excel-era pain) become easier because relationships are handled directly rather than through manual formulas.

What does “graph database” change compared with tables, and how does Logseq implement that idea?

Graph databases treat information as nodes and relationships rather than forcing everything into tables. In Logseq, the smallest unit (a block) is the core building unit and can be tagged and linked. Each block/paragraph/bullet gets a unique address, enabling references via square brackets and hashtags. Pages are described as a higher-level block type that appears as nodes in the graph, letting blocks relate upward and across contexts.

What does it mean that relationships can have properties in graph databases, and why is that useful?

The transcript uses a neo4j-style sketch: a node like “Bob” has key-value properties (type, date of birth, gender), a node like “ExampleCo” has its own properties (type, founded date), and the relationship “ExampleCo has CEO” can also carry properties such as a start date and end date. That matters because the relationship itself can carry time-bound or contextual data, not just the entities at either end.

Why does the transcript say graph-style PKM can be better for retrieval and navigation than folder structures?

It emphasizes three advantages: (1) easier input because structure isn’t required upfront—information can be added anywhere and later retrieved via tags/backlinks; (2) easier retrieval because search can work from multiple angles; and (3) knowledge traversal because clicking through linked nodes reveals related and even “implicit” connections. It also highlights flexibility: the same idea can coexist in multiple hierarchies without breaking paths, unlike rigid folder systems where moving files can lead to missing-path errors.

What practical caution does the transcript raise about how tasks appear in Logseq views?

It notes that nesting can affect visibility. For example, tasks nested under a project block might not show up as nicely when surfaced through certain searches or queries. The transcript contrasts “searching” with “querying/filtering,” implying that how content is nested and how views are generated can change what appears.

Review Questions

  1. Relational databases and graph databases both support relationships—what structural difference (tables vs nodes/links) does the transcript claim affects how easily PKM can be navigated?
  2. In the Logseq approach described, how do tags, backlinks, and unique block addresses work together to make retrieval possible without knowing where information was originally entered?
  3. What trade-off does the transcript suggest when entering information “at the nodes” in a graph-style system, and how might that influence how someone designs their workflow?

Key Points

  1. 1

    Treat a second brain as a storage-and-retrieval system: capture choices determine how fast and accurate later retrieval will be.

  2. 2

    Relational tools rely on tables and schemas; relationships are handled by linking records across tables (e.g., Projects ↔ Tasks in Airtable).

  3. 3

    Notion blends relational tables with page-based flexibility, including the ability to show multiple related tables on one page and add content outside table fields.

  4. 4

    Graph databases model information as nodes and links; in Logseq, blocks act as nodes with unique addresses that can be referenced via square brackets and hashtags.

  5. 5

    Graph-style PKM reduces the need for upfront structure, supports stream-of-consciousness capture, and improves navigation through knowledge traversal (linked and implicit connections).

  6. 6

    Nesting and view mechanics matter in Logseq: tasks nested under blocks may not surface the same way as tasks returned through queries/filters.

  7. 7

    Graph systems can replicate information across multiple contexts and hierarchies without breaking references the way rigid folder paths can.

Highlights

The transcript’s central warning is practical: if notes aren’t stored in a retrievable structure, later “querying your mind” becomes expensive in time and effort.
Airtable is used as a clean relational example: separate Projects and Tasks tables connected so a project view automatically surfaces its tasks.
Logseq’s graph model hinges on block-level nodes with unique addresses, enabling links that make knowledge traversal feel like moving through a network.
Graph databases can attach properties to relationships themselves (like start/end dates on “has CEO”), not just to the entities involved.

Topics

Mentioned