Get AI summaries of any video or article — Sign up free
Notion vs Obsidian // Databases vs Dataview thumbnail

Notion vs Obsidian // Databases vs Dataview

5 min read

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

TL;DR

Notion’s folder hierarchy forces an up-front placement decision that can distort how notes are later understood or reused.

Briefing

Notion and Obsidian diverge at the moment a user creates a note: Notion pushes a top-down hierarchy where every page must be placed in the “right” folder up front, while Obsidian supports a bottom-up network where notes can be linked and tagged first, organized later. That difference matters because it determines whether a knowledge system stays rigidly categorized—or evolves as interests shift and new connections emerge.

In Notion, the workflow starts with a placement decision. Notes live inside folders, and the structure encourages users to begin from broad categories and drill down. The transcript describes how this quickly becomes messy as the number of pages grows: a “YouTube” page might belong under “Content Consumed,” but if the user later starts a YouTube channel, the same topic also fits under “Personal,” and potentially “Work” when content overlaps. The key constraint is that a single page can’t sit in multiple folders at once, forcing users to choose where it “belongs” before they’ve fully understood how they’ll use it.

Obsidian takes the opposite approach. A note can be created immediately without committing to a folder taxonomy. Instead, the system relies on links and tags so one note can be discoverable through multiple paths—by topic, by project, or by any other label that becomes relevant later. The transcript illustrates this with a new note about “this video,” which can be linked to a “YouTube” page and also to “Personal Knowledge Management” without moving it between categories. Tags add another layer: a tag pane can list all notes carrying a tag like “myvideo,” and tags can be stored either in the note body or as front matter.

That same structural contrast shows up in databases. Notion’s databases require upfront decisions: create separate databases for “People,” “Books,” and “TV Shows,” then populate items into the chosen containers. The problem appears when access patterns change. If someone later wants a unified list of “Things I did in 2021” across movies, books, and travel, Notion struggles because items can’t easily be moved into a new table without removing them from the original database. The transcript frames this as a planning trap: the system demands that users predict future queries before they create the database structure.

Obsidian’s equivalent is not a traditional database at all. With the community plugin Obsidian Dataview, the vault’s notes are treated as the underlying dataset, and “databases” are effectively built as queries. Metadata is added to individual notes as needed—fields like type (person, country, etc.) and date (such as 2021). Then Dataview queries generate tables that filter the same underlying notes into different views, such as a “People” table or a “Things I did in 2021” table. Because these views are queries, they can change over time as metadata gets added.

The takeaway is a fit-for-purpose recommendation. Notion suits users who already know the structure they want—work documentation, small wikis, or straightforward task/content lists. Obsidian suits users seeking an open-ended system that can accommodate “chaotic complexity,” supporting serendipitous connections as interests evolve. Dataview is positioned as the bridge that turns Obsidian’s freeform network into something database-like without locking users into categories too early.

Cornell Notes

Notion and Obsidian differ most at creation time: Notion requires deciding where a note belongs in a folder hierarchy, which can force early categorization. Obsidian encourages creating notes first and using links and tags to connect them later, so one note can be found through multiple topics. Notion’s database model depends on upfront structure (separate databases and items assigned to them), which becomes awkward when new cross-cutting views are needed, like “everything from 2021.” Obsidian Dataview treats the vault as the dataset and builds “database-like” tables through queries over metadata fields such as type and date, letting views change as needs evolve.

Why does folder-first organization in Notion become a problem as interests overlap?

Notion’s hierarchy requires choosing a folder before writing the note, and a page can’t exist in multiple folders. The transcript’s example: a “YouTube” page might start under “Content Consumed,” but later also fits a “YouTube channel” under “Personal,” and possibly “Work” when content overlaps. Moving it means losing the original categorization, so the system pushes users to guess how they’ll use the note later.

How does Obsidian let one note serve multiple purposes without moving it?

Obsidian supports bottom-up organization using links and tags. A new note can be linked to multiple pages (e.g., “YouTube” and “Personal Knowledge Management”) without relocating it. Tags add another discovery path: a tag pane can list all notes with a tag like “myvideo,” and tags can be stored in the note body or as front matter.

What is the core limitation of Notion databases when access patterns change?

Notion’s databases require deciding categories up front and then placing items into the chosen containers. The transcript describes separate databases for People, Books, and TV Shows, but then asks for a cross-category list like “Things I did in 2021.” In Notion, adding an item to the 2021 view would require moving it between databases, which removes it from the original place—so the system demands planning for future queries.

How does Obsidian Dataview replace the need for separate databases?

Obsidian Dataview doesn’t create a database in the Notion sense. It scans all notes in the vault and turns them into a queryable dataset. Instead of predefining properties for each database, users add metadata to individual notes when it becomes necessary (e.g., type: person or type: country, plus date: 2021). Dataview queries then generate filtered tables on demand.

What makes Dataview “views” more flexible than Notion’s database tables?

Dataview views are queries that filter the same underlying set of notes. The transcript shows a Dataview query that returns the Japan page by filtering where date contains 2021, then adding metadata to other notes (like Kieran) so they automatically appear. Similar queries can be reused for a “People” view by filtering type: person, meaning the view updates as metadata changes rather than requiring structural reorganization.

Review Questions

  1. In Notion, what constraint prevents a single page from naturally fitting multiple overlapping categories, and how does that affect long-term organization?
  2. Compare how Notion databases and Obsidian Dataview handle changing future queries (e.g., switching from category-based browsing to a time-based list like “2021”).
  3. How do links and tags in Obsidian change the workflow compared with folder placement, and what does that enable for note discovery?

Key Points

  1. 1

    Notion’s folder hierarchy forces an up-front placement decision that can distort how notes are later understood or reused.

  2. 2

    Obsidian’s bottom-up workflow allows notes to be created immediately and connected later through links and tags.

  3. 3

    Notion database structure can become rigid when users later want cross-cutting views that span multiple original categories.

  4. 4

    Obsidian Dataview treats the entire vault as the dataset and builds database-like tables through metadata-driven queries.

  5. 5

    With Dataview, adding fields like type and date after the fact reshapes query results without reorganizing the underlying notes.

  6. 6

    Dataview “views” can change over time because they are queries, not fixed database containers.

  7. 7

    Notion fits best when the structure and use case are known; Obsidian fits best when the information model needs to evolve with the user.

Highlights

Notion requires deciding where a note goes before writing it, and a page can’t live in multiple folders—overlap forces awkward reorganization.
Obsidian’s links and tags let one note be discoverable through multiple topics without moving it between categories.
Notion databases demand category planning; Obsidian Dataview turns metadata into flexible query views over the same underlying vault.
Dataview queries can filter by fields like type and date (e.g., returning Japan and Kieran once date: 2021 is added).