Get AI summaries of any video or article — Sign up free
Notion Fundamentals | Building a product roadmap thumbnail

Notion Fundamentals | Building a product roadmap

Notion·
5 min read

Based on Notion's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Build the roadmap as a database where each row represents one item (bug, task, or epic) and each column is a typed property like status, deadline, and owner.

Briefing

A product roadmap in Notion becomes far more useful when it’s built as a database: each roadmap item lives as a row with structured properties, and the same underlying data can be rearranged into multiple views for different teams and planning needs. The core idea is simple—treat every roadmap item (bug, task, epic) as an object with fields like status, deadline, and owner—then let sorting, filtering, templates, and advanced database features turn that structure into day-to-day workflow.

The session starts with a quick history of databases to ground why this object-and-properties model matters. Relational database thinking traces back to the 1970s, credited to IBM computer scientist Edgar F. Codd, and it frames data as objects with associated attributes. In Notion, that translates directly into a table where each row represents one roadmap item and each column represents a property tied to that item. Instead of scattering details across separate documents, the roadmap row becomes the central place where the team can keep names, tags, and additional information—and then open each row as its own page for richer context.

From there, the walkthrough builds a “Product roadmap” workspace page and turns it into a full-page table. Rows begin with sample items, then the table grows properties that make the roadmap actionable: a single-select “status” (for example, Not started, In progress), a “deadline” date property (including optional end dates for ranges), and a “person responsible” field. It also adds auto-calculated metadata like “created by” and “created time,” which become useful once the dataset expands. With those properties in place, Notion’s sorting and filtering work by property—such as sorting by deadline to surface the most urgent work, or filtering to show only bugs whose “type” contains “bug.”

Consistency is handled through database templates. Instead of asking people to guess what information belongs in every new item, templates pre-fill the right sections. A “new bug” template can require fields like description, steps to reproduce, and recommendations, while a “new task” template can include more design-heavy inputs such as a problem statement, Figma mockups, and proposed work. When someone opens a row using the template, the structure arrives with it.

The roadmap’s flexibility comes from views. The same dataset powers a board view grouped by status or owner (a Jira-like kanban), a timeline view for scheduling with drag-and-drop planning, a calendar view for date-based review, plus simpler list and detail-rich gallery options. This avoids duplicating data across multiple tools or pages.

Finally, the session introduces advanced database “superpowers.” Relations connect the roadmap to another database—here, meeting notes—so each roadmap item can pull in related meetings. Roll-ups then analyze related data, such as calculating the earliest meeting date for a project to flag stalled work. Formulas provide automation and logic; the demo builds an “is overdue?” formula using an if statement comparing “now” to the deadline, returning overdue vs. not overdue. The result is a roadmap that’s not just a static plan, but a structured system that supports planning, reporting, and management signals across the organization.

Cornell Notes

The session shows how to build a product roadmap in Notion as a database so each roadmap item is a row with typed properties (status, deadline, owner, type/tags). Once properties exist, sorting and filtering become property-driven, and multiple views (board, timeline, calendar, list, gallery) can display the same underlying data for different audiences. Templates enforce consistent data entry by pre-filling the right fields for bugs, tasks, and epics. Relations and roll-ups connect the roadmap to other databases (like meeting notes) and compute signals such as the earliest related meeting date. Formulas add logic—for example, calculating whether a project is overdue based on the deadline.

Why does modeling a roadmap as a database row (instead of free-form pages) change how teams plan and track work?

Each roadmap item becomes an “object” with structured properties. In Notion, a row can store fields like status (single select), deadline (date or date range), and person responsible. That structure enables sorting and filtering by property, and it supports opening each row as its own page with additional narrative blocks. The same dataset can then be reshaped into multiple views without duplicating information.

How do templates improve consistency when multiple people add bugs, tasks, or epics?

Templates predefine what fields should be filled in for new rows. The demo creates a “new bug” template with required sections such as description, steps to reproduce, and recommendations. It also creates a “new task” template with more planning/design inputs like a problem statement, Figma mockups, and proposed work. When someone selects the template while creating a new row, the structure appears automatically, reducing guesswork and inconsistent reporting.

What’s the practical difference between board, timeline, and calendar views in a roadmap database?

All three views use the same underlying rows and properties but present them differently. A board view groups items by a property such as status or person responsible, producing a kanban-style workflow. A timeline view visualizes date ranges and supports scheduling by quarter or year increments, with optional property overlays like showing the person responsible. A calendar view places items on a calendar layout using the same date properties, and it can also be customized with filters, sorts, and visible properties.

How do relations and roll-ups work together to create management signals from connected data?

Relations link one database to another—for example, connecting product roadmap items to meeting notes. Once linked, roll-ups analyze the related records. In the demo, a roll-up uses a date range function over the related meeting notes to compute the earliest meeting date for a roadmap item. That computed value can help flag projects that haven’t had meetings for weeks, indicating potential stalling.

How can formulas automate roadmap status like “overdue” without manual updates?

A formula can compare properties and return conditional results. The demo creates an “is overdue?” formula using an if statement: it checks whether “now” is greater than the deadline property. If the condition is true, it returns “overdue”; otherwise it returns “not overdue.” Because it references the deadline property, the result updates automatically as time passes.

Review Questions

  1. If a roadmap needs to show different audiences (engineering vs. sales) the same work, which features let the team avoid duplicating data across pages?
  2. What property types are required before you can store meaningful values in a table column (and why does that matter later for sorting/filtering)?
  3. Describe a workflow that uses templates plus relations to ensure consistent bug reporting while also linking each bug to relevant meeting notes.

Key Points

  1. 1

    Build the roadmap as a database where each row represents one item (bug, task, or epic) and each column is a typed property like status, deadline, and owner.

  2. 2

    Use sorting and filtering based on specific properties (e.g., sort by deadline to prioritize, filter by type to isolate bugs).

  3. 3

    Create database templates for bugs and tasks so new entries start with the right fields (description, steps to reproduce, recommendations for bugs; problem statement, mockups, proposed work for tasks).

  4. 4

    Use multiple views (board, timeline, calendar, list, gallery) to present the same underlying roadmap data for different planning and reporting needs.

  5. 5

    Connect the roadmap to other operational data with relations (e.g., link roadmap items to meeting notes) to build a fuller project history.

  6. 6

    Use roll-ups to compute insights from related records, such as the earliest meeting date to identify stalled work.

  7. 7

    Add automation with formulas that return conditional values, such as calculating whether a project is overdue by comparing now to the deadline.

Highlights

A single roadmap dataset can power many perspectives—kanban board, timeline scheduling, and calendar review—without duplicating updates across separate pages.
Templates turn “how should we fill this out?” into a default structure, making bug and task reporting consistent across the team.
Relations plus roll-ups can convert meeting history into actionable signals, like detecting when a project hasn’t been discussed recently.
Formulas can automate status flags (e.g., overdue) by using conditional logic against deadline properties.

Topics

Mentioned

  • Edgar F. Codd
  • Zoe Ludwig
  • Ellia