Get AI summaries of any video or article — Sign up free
Notion feels incomplete without this note-taking setup thumbnail

Notion feels incomplete without this note-taking setup

Thomas Frank Explains·
6 min read

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

TL;DR

Build the system on two linked databases: Notes (capture + metadata) and Tags (PAR categories + navigation).

Briefing

A complete, PARA-inspired note-taking system can be built in Notion from a blank free workspace by anchoring everything to two connected databases—one for notes and one for tags—then turning those databases into a dashboard of purpose-built views. The core idea is simple: every note gets structured metadata (favorite, type, tags, archive status, timestamps, and optional media/URL fields), while every tag becomes a navigational hub that can surface related notes quickly. The payoff is speed and retrieval: inbox processing, favorites, web clipping, voice notes, and journal/meeting workflows all become different “windows” into the same underlying data.

The build starts by creating an “Ultimate Notes” dashboard page and keeping it clean by disabling backlinks, page discussions, and minimizing inline comments. From there, it creates a “databases” subpage that holds the two foundational databases: a notes database and a tags database. The notes database is designed with properties that support capture and organization. It includes a favorite checkbox, a relation-based tags property linking to the tags database (with two-way relations so tags can list their notes), a select “type” property for special categories like voice notes, web clips, highlights/research, and journal/meeting notes, plus URL, created/updated timestamps, and media fields (including a dedicated audio file field for voice workflows). An archived checkbox implements the “A” in PARA, keeping old material out of daily views without deleting it.

To make the notes database usable as an app-like interface, the page layout is customized: key fields (tag, favorite, type, URL) are pinned, while helper properties (like formula outputs used for compact UI) are hidden. Two default table views are created—unarchived and archived—using filters on the archived checkbox and sorting by updated time. The tags database mirrors this structure but adds PARA semantics directly into tag types. Instead of a simple select, it uses a status property with a default value so every tag is automatically one of three categories: area, resource, or entity (a fourth concept added to separate “shape-based” collections like apps/repos/essays from topic-based resources). Tags also support hierarchy via parent/sub-tag relations, and a rollup computes a “root tag” so parent pages can automatically include notes tagged to their descendants.

Once the databases exist, the dashboard is assembled using list-style views that link to the notes database with different filters and sorts: a default Notes view (excluding web clips and journal/meeting types), an All view, an Inbox for untagged notes, a Clips view for web clippings (identified by URL/type logic), a Voice view, plus dedicated Journal and Meeting views. Favorites get their own view with favorite checked and no forced sorting so users can manually order. Formula properties are then filled in to create compact UI elements like a clickable URL icon and “updated short” (e.g., days since last update), and tag pages use formulas like note count and latest activity so tag ordering reflects activity inside related notes.

The final step turns the system into a low-friction workflow by adding database templates. Tag pages get templates that automatically generate an embedded notes area (recent, A–Z, by tag, favorites, voice) and a web clips area (including grouping by site via URL base). Journal and meeting templates auto-fill “today when duplicated” dates and prebuilt sections like plan/review or agenda/action items. A “New note” button adds pages quickly. After locking the database structure, the result is a free-plan Notion setup that supports capture (including web and voice), PARA-style organization, and fast retrieval through a dashboard of specialized views.

Cornell Notes

The system is built around two connected Notion databases—Notes and Tags—then surfaced through a dashboard of filtered views. Notes store capture-ready metadata (favorite, type, tags relation, URL, timestamps, media, and an archived checkbox for PARA). Tags encode PARA categories using a status property (area, resource, entity) and support hierarchy via parent/sub-tag relations plus a rollup for “root tag,” letting parent tags automatically include descendant-tag notes. Dashboard views (Notes, Inbox, Clips, Voice, Journal, Meeting, Favorites, All) are just different windows into the same notes database, sorted and filtered for fast retrieval. Templates make new pages self-populating: tag pages include embedded related-note and web-clip views, while journal/meeting pages auto-fill dates and sections.

Why does connecting the Notes database to the Tags database matter more than adding more fields?

The tags property in the Notes database is a relation to the Tags database (two-way). That means each note can link to multiple tags, and each tag page can automatically list its related notes. This relation is what powers the dashboard views (e.g., “Inbox” shows notes with empty tags; “Favorites” filters by the favorite checkbox; tag pages show recent notes filtered by “tags contains [this tag]”). Without the relation, tags would be decorative text instead of navigational structure.

How does the PARA “Archive” concept get implemented in this system?

Both databases include an archived checkbox. Notes views filter on archived being unchecked for active work, while an archived view filters on archived being checked. The same pattern is applied to tags (active tags vs archived tags). This keeps old notes accessible without cluttering daily views, aligning with PARA’s idea of moving material out of the way without deleting it.

What is the purpose of the “type” property, and how does it drive different views?

The notes database uses a select “type” property to label special note categories such as voice notes, web clips, highlights/research, and journal/meeting notes. Dashboard views then use filters based on type. For example, the default Notes view excludes web clips and journal/meeting types; the Clips view includes pages where URL is not empty or type is web clip; the Voice view filters where type is voice note; Journal and Meeting views filter by their respective types and sort by note date for chronological entry.

How does the system make tag pages automatically include notes from sub-tags?

Tags support parent/sub-tag relations. A rollup property called root tag is configured in the Notes database to compute the parent/root tag of each note based on the tag relation. Tag-page templates then use self-referential filters like “tags contains [this page]” and “root tag contains [this page]” so a parent tag page can show notes tagged directly to it and also notes tagged to any of its descendants.

Why use formula properties like “URL icon” and “updated short” instead of showing raw fields everywhere?

Formulas create compact UI elements that reduce horizontal clutter in narrow layouts (like Side Peek). “URL icon” turns a URL into a clickable icon, and “updated short” converts the updated timestamp into a compact “days since” display. On tag pages, formulas like latest activity help sort tags based on activity inside related notes rather than the tag page’s own last edited time.

What makes the templates essential for turning the setup into a workflow, not just a database?

Templates auto-generate page structure and dynamic dates. Tag templates create embedded related views (recent, A–Z, by tag, favorites, voice) and web-clip views, with self-referential filters so the template points to the newly created tag page (e.g., “where tags contains [new tag]”). Journal and meeting templates use “today when duplicated” for both title and note date and pre-fill sections like plan/review or agenda/action items, so capturing entries takes seconds.

Review Questions

  1. If a note has type = web clip and a non-empty URL, which dashboard view should it appear in, and why?
  2. How do parent/sub-tag relations and the root tag rollup work together to make a parent tag page include notes from descendant tags?
  3. What filters distinguish the Inbox view from the default Notes view in this system?

Key Points

  1. 1

    Build the system on two linked databases: Notes (capture + metadata) and Tags (PAR categories + navigation).

  2. 2

    Use a relation-based tags property with two-way linking so tag pages automatically list related notes.

  3. 3

    Implement PARA with an archived checkbox in both databases and separate unarchived vs archived views.

  4. 4

    Drive dashboard behavior with a select “type” property so each view can filter by note category (clips, voice, journal, meeting).

  5. 5

    Customize database page layouts by pinning the most-used properties and hiding helper/formula properties to keep entry screens fast.

  6. 6

    Use formulas to create compact clickable UI elements (URL icon, updated short) and to sort tag pages by latest activity across related notes.

  7. 7

    Make templates do the heavy lifting: tag pages embed filtered related views, while journal/meeting pages auto-fill dates and prebuilt sections.

Highlights

The tagging system uses Tiago Forte’s PARA categories (Projects/Areas/Resources/Archive) but adds an extra “entity” type for shape-based collections like apps, essays, and GitHub repos.
Tag pages can automatically include notes from sub-tags through parent/sub-tag relations plus a rollup that computes “root tag.”
Web clipping and voice notes are treated as first-class note types, with views built around URL/type logic and optional URL-based access to source media.
Formula properties like “URL icon” and “updated short” keep the interface usable in narrow layouts by replacing bulky raw fields with compact UI elements.
Templates turn the databases into a workflow: new tag pages spawn embedded note/clip views, and journal/meeting pages pre-fill sections using “today when duplicated.”

Topics

Mentioned