Get AI summaries of any video or article — Sign up free
Notion database views in Obsidian Projects plugin thumbnail

Notion database views in Obsidian Projects plugin

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

Obsidian Projects parses note data once into a unified dataset, then reuses it across multiple views (table, board, calendar, gallery) to avoid duplicated metadata.

Briefing

Obsidian Projects is built to make “Notion-style” database views possible inside Obsidian without forcing users to rewrite their notes for every visualization. The core idea is a unified data format: Projects parses note metadata once, then feeds the same structured dataset to multiple views—table, board, calendar, and gallery—so switching perspectives doesn’t require duplicating notes or reconfiguring front matter for each plugin.

The need behind Projects comes from content workflows. Nicole van der Hoeven describes tracking multiple recurring deliverables—blog posts, scripts, drafts—where each item has a status and a due date. Traditional approaches in Obsidian can work, but calendar and board plugins often require their own specific front matter properties, and interoperability is inconsistent. That leads to copying content, maintaining multiple versions of the same note, or being stuck with one view type instead of moving fluidly between board, calendar, and table.

Projects addresses that by separating “querying” from “presentation.” The querying layer pulls in notes from chosen folders (optionally including subfolders), filters them, and parses their fields into a record-based dataset. The views then focus on rendering: a table view exposes structured fields like status, dates, and booleans; a board view groups items by a chosen YAML property; a calendar view places items using extracted date fields and can display additional properties as checkboxes; and a gallery view renders items in a grid based on an image field. In the demo, a single set of YAML front matter drives all four views, and edits in one view stay synchronized with the others.

A key design constraint is “Leave No Trace.” Projects aims not to clutter markdown notes with plugin-specific configuration. Instead, configuration lives in the Projects plugin, while the notes remain plain markdown with front matter that already matches established patterns. The plugin also aims to be a data provider rather than a competitor to other view plugins. The ambition is to let other plugins register themselves as custom views so they can reuse Projects’ parsed dataset without re-implementing indexing, filtering, and event handling.

The live walkthrough shows how Projects can plug into existing DataView workflows. By pasting a DataView query into a new project, the dataset can be reshaped using DataView’s field selection and aliasing, and the Projects views adapt to the resulting fields. There’s a tradeoff: when fields are aliased through DataView, Projects may not know the original property names, which limits editing back into the source notes.

Beyond content calendars, participants explore broader use cases: RPG campaign management, session tracking, and visualizing cover art or character images through the gallery view. Questions from the community focus on drag-and-drop limitations (sorting cards isn’t fully supported yet), future filtering UI, and whether tasks or richer field types can be supported. The roadmap emphasizes better filtering before data reaches views, tighter integration with other Obsidian database-like tools, and expanding the view ecosystem—so users can keep their notes clean while gaining database-style navigation across multiple representations.

Cornell Notes

Obsidian Projects turns markdown notes into a database-like system by parsing note data once and reusing it across multiple views. It supports four built-in views—table, board, calendar, and gallery—so users can switch perspectives without duplicating notes or rewriting front matter for each plugin. The plugin’s “Leave No Trace” philosophy keeps notes uncluttered by storing configuration inside Projects rather than forcing extra metadata into every note. Projects also integrates with DataView, letting users define which notes and fields to include via existing queries, though aliased fields can limit editing back to the original properties. The longer-term goal is for other plugins to register as custom views, using Projects’ shared dataset for presentation.

What problem does Projects solve compared with using separate board/calendar plugins in Obsidian?

Projects targets the interoperability gap. Many calendar or Kanban-style plugins require their own front matter properties or formats, so users end up duplicating notes or maintaining multiple sets of metadata just to support different views. Projects instead uses a unified data format: it parses notes once and then feeds the same structured dataset to multiple views (table, board, calendar, gallery). That makes switching views practical for workflows like recurring content schedules.

How does Projects separate data handling from UI rendering?

Projects splits work into two layers. First, the querying layer selects notes from chosen folders (optionally including subfolders), filters them, and parses their fields into a record-style dataset. Second, each view renders that dataset in a different way: the table view shows structured fields, the board view groups items by a chosen YAML property (and can prioritize notes), the calendar view uses extracted date fields and can display other properties as checkboxes, and the gallery view uses an image field to render a grid.

What does “Leave No Trace” mean in practice?

“Leave No Trace” means Projects should not force extra plugin-specific configuration into the markdown notes themselves. Instead, Projects stores its configuration internally while relying on existing note patterns (regular YAML front matter) to extract status, dates, booleans, tags, and images. The goal is reliability for work use and easier sharing with teammates, without adding clutter or enforcing a rigid schema on every note.

How does DataView integration work, and what limitation appears with editing?

Users can create a Projects project and paste a DataView query to define which notes and fields to include. The views then use the resulting dataset, so existing DataView field selection can drive Projects views “plug and play.” However, if DataView aliases fields, Projects may not know the original property names, so it can’t reliably map edits back to the source note fields—editing may be disabled or limited for those properties.

What’s the status of drag-and-drop and filtering in Projects?

Drag-and-drop is limited right now. Users can drag and drop views and reorder columns, but sorting cards within the board isn’t supported yet (it’s described as planned). Filtering is also not fully UI-driven yet; an open issue aims to add a search/filter box that applies filtering before data is sent to views, enabling field-based filtering earlier in the pipeline.

Why is Projects designed to work as a platform for other plugins’ views?

Projects aims to become a shared data provider so other plugins can focus on presentation. The plan is for external plugins to register themselves as custom views and receive the same parsed dataset, without re-implementing indexing, event handling, or note querying. The presenter notes that this makes it easier to add new view types—like a timeline or Mermaid-based visualization—while keeping Projects’ core responsibility focused on data parsing and distribution.

Review Questions

  1. How does Projects ensure that switching between table, board, calendar, and gallery views doesn’t require duplicating notes or rewriting front matter for each view?
  2. What tradeoff arises when Projects uses DataView queries that alias fields, and how does that affect editing?
  3. Explain how “Leave No Trace” influences where Projects stores configuration and how that impacts note cleanliness and team sharing.

Key Points

  1. 1

    Obsidian Projects parses note data once into a unified dataset, then reuses it across multiple views (table, board, calendar, gallery) to avoid duplicated metadata.

  2. 2

    The plugin’s architecture separates querying/filtering from presentation, letting each view focus on rendering rather than re-parsing notes.

  3. 3

    Projects follows a “Leave No Trace” philosophy by keeping plugin configuration out of markdown notes while still using standard YAML front matter patterns.

  4. 4

    DataView can be used to define which notes and fields feed a Projects project, but aliased fields can limit the plugin’s ability to edit original properties.

  5. 5

    Drag-and-drop is partially supported (views/columns), while card-level sorting in the board is not yet available and is planned.

  6. 6

    A major roadmap goal is enabling other plugins to register as custom views so they can reuse Projects’ parsed dataset without rebuilding the data pipeline.

Highlights

Projects’ unified data format lets one set of YAML front matter drive table, board, calendar, and gallery views without duplicating notes.
“Leave No Trace” keeps Projects configuration out of the notes themselves, relying on existing markdown patterns while storing plugin behavior internally.
DataView queries can be pasted directly into a Projects project, enabling plug-and-play reuse of existing field selection—though aliased fields can restrict editing back to source properties.
The long-term vision is a view ecosystem: other plugins register as custom views and receive Projects’ parsed dataset for presentation.

Topics

Mentioned