Get AI summaries of any video or article — Sign up free
TUTO OBSIDIAN dévore Notion avec le plugin DB folder thumbnail

TUTO OBSIDIAN dévore Notion avec le plugin DB folder

5 min read

Based on PKMind - Obsidian - Boostez votre Productivité's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Enable DataView before installing and using DB Folder, since DB Folder relies on it for table rendering and field handling.

Briefing

Obsidian can mimic Notion-style database tables using the DB Folder plugin—turning a folder of notes into a structured, filterable “database” driven by frontmatter fields. The setup hinges on having DataView enabled, after which DB Folder adds a table interface where each row corresponds to a note and each column maps to a specific metadata field (frontmatter or inline fields). The payoff is practical: entries can be edited from the table, sorted, searched, and even used to automatically organize notes into subfolders.

The walkthrough begins with installing and activating DB Folder in Obsidian, then creating a new database table (example: “My books”) inside a sandbox folder. Adding a row creates a new note entry, and clicking a row opens that note in a linked table view. Column layout matters: the first column can be kept as the “title/link” so it stays visible while working. Crucially, DB Folder stores table data as readable YAML in the note’s frontmatter. When a column is created, it has an identifier (often lowercase) that must remain stable; changing the column’s display name doesn’t break the underlying mapping because the identifier continues to drive which frontmatter key gets updated.

From there, the guide shows two-way synchronization between the table and the notes. A field can be created in the table and then reflected in the note’s frontmatter (e.g., author, year, status to read). Alternatively, a field written directly in a note can be pulled into the table by creating a column that references an existing frontmatter key. This bidirectional workflow supports incremental migration from manual note-taking to structured databases.

The most powerful part comes from column types. Beyond plain text, DB Folder supports select lists, checkboxes, dates, relationships, formulas, and tags. A “type” column set to Select enables controlled categories like “novels,” “essays,” and “classics,” each with custom labels and colors. A “tags” column behaves like multi-select taxonomy: adding tags in the table populates Obsidian’s tag system, and those tags appear as clickable items across the vault. The example then adds a formula column that composes values from other fields (e.g., author + year) to create a cleaner “bibliography” string.

Finally, the plugin can reorganize notes automatically. Using “group by” settings, notes are moved into subfolders based on a single Select field (e.g., type). Changing a note’s category in the table triggers relocation to the corresponding folder. The guide also introduces inline fields (stored in the body rather than frontmatter), plus optional features like task extraction into a “tasks” column—though it warns that some settings (like removing fields or overriding column configuration) can be destructive.

Overall, DB Folder turns Obsidian folders into database-like systems: structured metadata, controlled vocabularies, computed fields, search and filtering, and automatic folder classification—without locking data into a proprietary format. It’s positioned as a practical bridge for anyone who liked Notion’s database workflow but wants Obsidian’s local control and readable note files.

Cornell Notes

DB Folder lets Obsidian behave like a Notion-style database by rendering a table where each row maps to a note and each column maps to a metadata field. After enabling DataView, users install DB Folder, create a database table in a folder, and add columns whose identifiers control which frontmatter keys get written. Column display names can change without breaking data as long as the identifier stays consistent. The table supports controlled fields (Select with colored options), multi-value tags, and formula columns that combine other fields into cleaner output. With “group by” settings, a Select field can automatically classify notes into subfolders, making the system both searchable and self-organizing.

What prerequisites and core setup steps are required before DB Folder can create database tables in Obsidian?

DataView must be enabled first. The workflow is: install DB Folder, activate it, then create a new database table inside a chosen folder (the example uses a “sandbox” folder). Once the table exists, adding rows creates note-backed entries, and the table interface becomes the control panel for editing metadata.

How does DB Folder store table data in notes, and why do column identifiers matter?

DB Folder writes table values into the note’s frontmatter as YAML. Each column has an identifier (often lowercase) that acts as the stable key. Changing the column’s display name doesn’t change where data is written; the identifier does. If the identifier changes, the mapping breaks—so the guide emphasizes keeping the identifier consistent.

How can information flow both from the table to the note and from the note back to the table?

From table to note: creating a column like “author” or “year” and filling it updates the note’s frontmatter fields (e.g., author appears in the note’s YAML). From note to table: if a note already contains a frontmatter key (like “status to read”), a new column can be created in the table by selecting that existing field, pulling the value into the table view.

Why are column types (Select, Tags, Formula) central to making the table useful rather than just decorative?

Select columns enforce controlled categories with predefined options and can include custom labels and colors (e.g., “novels,” “essays,” “classics”). Tags columns allow multiple values per note and integrate with Obsidian’s tag system. Formula columns compute new fields by combining other row variables (e.g., producing “author year” like “Hemingway 1960”), enabling cleaner display without manual repetition.

How does “group by” classification work, and what field type does it require?

Grouping moves notes into subfolders based on a chosen column. The guide stresses that grouping requires a Select-type column (single-choice), because a note can’t belong to multiple folders at once. When a note’s Select value changes (e.g., “Ten Little …” becomes “classic”), the note is automatically relocated to the matching folder.

What settings can be risky when customizing fields and inline data?

Inline fields depend on the DataView setup and are stored in the note body rather than frontmatter. The guide warns that options like “remove fields” or “override” can delete or replace existing column configurations, potentially wiping custom mappings. It also notes that some changes may require closing and reopening the table to refresh available options.

Review Questions

  1. How do column identifiers differ from column display names in DB Folder, and what happens if an identifier changes?
  2. When would you choose a Select column versus a Tags column, and how does that choice affect grouping into folders?
  3. What are the potential consequences of using an “override” or “remove fields” option in DB Folder?

Key Points

  1. 1

    Enable DataView before installing and using DB Folder, since DB Folder relies on it for table rendering and field handling.

  2. 2

    DB Folder tables map rows to notes and columns to metadata keys stored as YAML frontmatter (or inline fields, depending on configuration).

  3. 3

    Column identifiers are the stable link between table columns and note fields; changing the display name is safe, but changing the identifier can break data mapping.

  4. 4

    Select columns provide controlled, colored categories; tags columns support multi-value taxonomy integrated with Obsidian tags.

  5. 5

    Formula columns can generate computed fields by combining values from other columns in the same row.

  6. 6

    “Group by” can automatically classify notes into subfolders based on a Select field, but it requires single-choice Select data.

  7. 7

    Some customization options (like overriding or removing fields) can be destructive and may wipe existing column configurations.

Highlights

DB Folder turns a folder of Obsidian notes into a database-like table where each cell edits YAML frontmatter (readable, non-proprietary).
Select-type columns enable both consistent categorization and automatic folder classification via “group by.”
Formula fields let users build cleaner composite outputs (e.g., “author year”) from existing metadata without manual duplication.

Topics

Mentioned