Get AI summaries of any video or article — Sign up free
How To Use Obsidian: Properties, DataView, & ONE HUGE PROBLEM TO AVOID thumbnail

How To Use Obsidian: Properties, DataView, & ONE HUGE PROBLEM TO AVOID

4 min read

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.

TL;DR

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?

Front matter (YAML) requires correct syntax and punctuation, including the “three dashes” structure and exact key formatting; a small mistake can break parsing. Properties View keeps the same idea—structured fields—but provides a graphical interface for adding properties (director, release date, genre, tags) and choosing property types. That makes metadata entry more consistent and less dependent on knowing YAML syntax.

Why do property types matter when later building DataView dashboards?

Property types act as constraints on what gets stored and how queries interpret it. For example, a number field should receive numeric values so DataView can sort or graph correctly, while a list field supports multiple items like “action sci-fi” or multiple tags. This reduces the chance of mixing incompatible data types (like words in a field expected to behave numerically).

How does DataView filter notes using metadata?

DataView queries specify a source scope (such as the “movies” folder) and then apply conditions on properties. In the example, the query lists items from the movies folder where tag equals action, returning only “The Matrix.” Adding additional conditions (using logical “and”) further narrows results to notes matching multiple tags like action and classic.

What’s the practical workflow for turning metadata into “dashboard” pages?

First, store consistent fields at the top of each note using Properties View (e.g., tags, release date, genre). Next, create a separate note that contains a DataView query. That query pulls matching notes from a chosen folder and filters by property values, producing a live list or table that updates as new notes with matching metadata are added.

What single formatting mistake can break DataView queries, and how is it fixed?

Using spaces in property keys can cause DataView parsing failures. The example shows an error when querying a field named “release date”; removing the space (changing to something like “releasedate”) fixes the table output. The cleanup can be painful if the space was used across many notes, so property names should avoid spaces from the start.

Review Questions

  1. When would you choose a list property type instead of text for something like tags or genres?
  2. How would you structure a DataView query to show only notes in a specific folder that match multiple tags?
  3. Why might a DataView table fail even when the underlying values look correct? What naming rule prevents that?

Key Points

  1. 1

    Enable the core plugin “Properties View” to add metadata fields via a sidebar UI instead of hand-writing YAML front matter.

  2. 2

    Use property types (text, list, number, checkbox, date/time) to keep data consistent and queryable.

  3. 3

    Store tags and other fields in Properties so DataView can filter notes without changing the underlying note content.

  4. 4

    Build dynamic “dashboard” notes by writing DataView queries that target a specific folder and property conditions.

  5. 5

    Avoid spaces in property keys used by DataView (e.g., prefer “releasedate” over “release date”) to prevent parsing errors.

  6. 6

    If DataView queries return unexpected results, check both the query logic (conditions like tag equals X) and the property naming/formatting rules.

Highlights

Properties View centralizes metadata at the top of each note and supports collapsible fields, making structured notes easier to maintain.
DataView can generate filtered lists from a specific folder using property conditions like “tag equals action,” then expand to multi-condition filters.
A “parsing failed” DataView error can come from property-key formatting—spaces in keys like “release date” break queries; removing the space fixes it.

Topics

Mentioned