Notion database views in Obsidian Projects plugin
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.
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?
How does Projects separate data handling from UI rendering?
What does “Leave No Trace” mean in practice?
How does DataView integration work, and what limitation appears with editing?
What’s the status of drag-and-drop and filtering in Projects?
Why is Projects designed to work as a platform for other plugins’ views?
Review Questions
- 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?
- What tradeoff arises when Projects uses DataView queries that alias fields, and how does that affect editing?
- Explain how “Leave No Trace” influences where Projects stores configuration and how that impacts note cleanliness and team sharing.
Key Points
- 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
The plugin’s architecture separates querying/filtering from presentation, letting each view focus on rendering rather than re-parsing notes.
- 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
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
Drag-and-drop is partially supported (views/columns), while card-level sorting in the board is not yet available and is planned.
- 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.