How To Use Obsidian: Properties, DataView, & ONE HUGE PROBLEM TO AVOID
Based on Obsidian Explained (No Code Required)'s video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
Enable the core plugin “Properties View” to add metadata fields via a sidebar UI instead of hand-writing YAML front matter.
Briefing
Obsidian’s new Properties workflow lets users build structured “metadata” for notes without hand-writing YAML front matter, and that metadata can then power DataView dashboards that filter and aggregate information across a vault. The practical payoff is straightforward: instead of relying only on folders, links, or hashtags scattered through notes, users can store consistent fields—like director, release year, genre, and tags—at the top of each note and then generate dynamic lists or tables from that structured data.
The walkthrough starts with a movie-tracking example. Each movie note stores details such as director (e.g., “Wachowskis”), release date (e.g., “1999”), genre (e.g., “action sci-fi”), and tags (e.g., “action,” “kung fu,” “martial arts,” “explosions”). Previously, doing this well often meant creating templates and/or writing front matter manually, which requires correct YAML syntax (including the “three dashes” structure) and is easy to break with small punctuation mistakes. The update shifts that burden: enabling the core plugin “Properties View” surfaces a sidebar UI where users can add fields and choose property types—text, list, number, checkbox, or date/time—so the metadata stays organized and collapsible right at the top of the note.
A key detail is that property types act like guardrails. If a field is defined as a number, DataView and other tooling can treat it as numeric; if it’s text or a list, it behaves accordingly. That reduces the risk of entering incompatible data (like words into a field meant for graphing numbers), which matters when later queries depend on consistent typing.
Once metadata lives in Properties, DataView becomes the next step: it can query notes by folder and property values to produce filtered views. The example uses a DataView list query that pulls results from the “movies” folder where a tag equals “action,” returning only matching notes (initially “The Matrix”). The walkthrough then adds more complex filtering using logical conditions (e.g., requiring both “action” and “classic” tags) so users can build “grouped” pages like “Action Films” or “Classic Movies” that stay automatically updated as new notes are added.
The most important warning comes later: DataView queries can fail in confusing ways if property names or values include spaces in the wrong place. A specific troubleshooting moment shows a “parsing failed” error when trying to query a field named “release date.” Removing the space (using “releasedate” instead) fixes the table output. The presenter notes that this can force hours of cleanup across an entire vault if spaces were already used inconsistently. The takeaway is blunt: when defining property keys for DataView, avoid spaces—use underscores, dashes, or capitalization instead—so future dashboards don’t break.
Cornell Notes
Obsidian’s Properties View (a core plugin) lets users add structured metadata to notes through a sidebar UI, avoiding error-prone YAML front matter. By defining property types (text, list, number, checkbox, date/time), users reduce data-entry mistakes and make later queries more reliable. With the DataView plugin, that metadata can be queried to generate dynamic lists or tables filtered by folder and property values—such as showing only movies tagged “action” or “classic.” The biggest pitfall is query-breaking formatting: using spaces in property keys (e.g., “release date”) can cause DataView parsing errors, so property names should avoid spaces (use underscores/dashes or capitalization).
What problem do Properties View and front matter solve differently for metadata-heavy notes?
Why do property types matter when later building DataView dashboards?
How does DataView filter notes using metadata?
What’s the practical workflow for turning metadata into “dashboard” pages?
What single formatting mistake can break DataView queries, and how is it fixed?
Review Questions
- When would you choose a list property type instead of text for something like tags or genres?
- How would you structure a DataView query to show only notes in a specific folder that match multiple tags?
- Why might a DataView table fail even when the underlying values look correct? What naming rule prevents that?
Key Points
- 1
Enable the core plugin “Properties View” to add metadata fields via a sidebar UI instead of hand-writing YAML front matter.
- 2
Use property types (text, list, number, checkbox, date/time) to keep data consistent and queryable.
- 3
Store tags and other fields in Properties so DataView can filter notes without changing the underlying note content.
- 4
Build dynamic “dashboard” notes by writing DataView queries that target a specific folder and property conditions.
- 5
Avoid spaces in property keys used by DataView (e.g., prefer “releasedate” over “release date”) to prevent parsing errors.
- 6
If DataView queries return unexpected results, check both the query logic (conditions like tag equals X) and the property naming/formatting rules.