Get AI summaries of any video or article — Sign up free
How to build your ideal project roadmap (Block × Block) thumbnail

How to build your ideal project roadmap (Block × Block)

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

Store every project as a row in a single Notion database so one card contains both status properties and full lifecycle details.

Briefing

Project roadmaps in Notion work best when every project lives in a single database that acts as a “source of truth,” then gets reshaped into whatever view each team needs—table, Kanban board, timeline, or calendar—without duplicating information. In the example workspace for the fictional company fig.io, a “Project Roadmap” database gives a company-wide bird’s-eye view of project status, ownership, priority, OKR alignment, and launch timing, while still letting teams drill into full project context on one page.

The core setup starts with a database table where each row represents a project and each column (called properties) captures structured fields like status (e.g., approved or in progress), related OKRs, launch schedule dates, teams involved, owners, and priority. Clicking a project opens a full page containing the entire lifecycle: specifications, notes, links to supporting documents, checklists, milestones, and key decisions. That design eliminates the need to juggle multiple tools or tabs (spreadsheet + documentation + board/Jira ticket) because the roadmap card itself becomes the repository for both summary and detail.

Flexibility is a major theme. Teams can customize properties on the fly—for instance, adding an “initiative” property using select or multi-select tags such as Growth, Retention, and Advocacy. Once properties exist, they become the building blocks for slicing and dicing the roadmap. Notion’s filtered views let teams create reusable, named subsets like “All Growth Projects,” “High Priority Projects,” or “All Approved Projects,” using one or multiple filters (e.g., initiative contains Growth AND status is approved). Instead of maintaining separate spreadsheets for each audience, everyone can toggle between views that all pull from the same underlying database.

The same database powers multiple visual formats. A Kanban-style board groups projects by status, but can just as easily group by initiative, owner, or any other property—making it easy to see workload and dependencies. Drag-and-drop updates status instantly, and adding a new card can auto-assign ownership based on the column it’s created in. For planning and scheduling, timeline (Gantt-like) and calendar views overlay projects onto dates, helping teams spot overlaps, delays, and upcoming releases; moving cards updates launch dates dynamically. Calendar views also support month-level use cases like marketing content calendars or leave schedules.

At scale, the workflow depends on consistency. Notion emphasizes templates for database entries so teams don’t freehand new projects with inconsistent fields. Templates pre-fill default values such as priority, assigned teams, OKR linkage, and owners, and also standardize the structure of the project page body (specs, milestones, tasks). Finally, the roadmap can be embedded elsewhere using linked databases, so hubs for product, marketing, or other teams can show only the filtered slice they care about—while edits still update the master roadmap automatically. The result is less back-and-forth about “what’s going on,” more accountability, and faster access to context across teams.

Cornell Notes

A Notion project roadmap becomes effective when every project is stored as a row in a single database that contains both structured fields (status, priority, owner, OKR/initiative, dates) and full lifecycle details (specs, notes, links, milestones, decisions). Teams then create reusable filtered views—such as “All Growth Projects” or “High Priority Projects”—so different audiences see the right slice without maintaining separate spreadsheets. The same database can be visualized as a table, Kanban board (with drag-and-drop status changes), timeline (Gantt-like scheduling), or calendar (month-level planning). Templates keep entries consistent at scale by pre-filling defaults and standardizing the project page structure. Linked databases and embeds let team hubs operate on the same source of truth while showing only the views they need.

Why does a single “project roadmap” database reduce confusion compared with separate tools and documents?

Each project is a database row with summary properties (status, priority, owner, OKR/initiative, launch schedule) and a full project page body (specifications, notes, links, checklists, milestones, decisions). That means teams can open one card to get both the quick status and the detailed context, instead of switching between a spreadsheet, documentation, and a board/Jira ticket. The database becomes the repository of information, not just a list.

How do properties like “initiative” and “owner” turn into practical workflow tools?

Properties are the structured fields that enable sorting, filtering, and grouping. After adding an “initiative” multi-select (e.g., Growth, Retention, Advocacy), teams can filter the roadmap to show only projects tagged with Growth. Adding an “owner” property allows grouping by person so teams can see workload and dependencies—e.g., “Mike has two projects, Jen has two, Lily has three.”

What’s the difference between a master roadmap and the filtered views teams use day to day?

The master table holds all projects and all properties. Filtered views are saved subsets that reuse the same underlying data. For example, a view named “All Approved Projects” shows only rows where status is approved, and “All Growth Projects” shows only rows where initiative contains Growth. Teams can toggle between these views without reapplying filters each time, and leadership can be shown a targeted view instead of the entire roadmap.

How can one database support multiple planning styles (Kanban, timeline, calendar) without duplicating data?

Notion’s database views visualize the same rows in different formats. A board view groups cards by status (or by initiative/owner), and drag-and-drop updates the status property instantly. A timeline view overlays projects across date ranges (e.g., May 4 to May 19) so teams can detect overlaps or schedule slippage and move cards to shift dates. A calendar view places projects on a 30-day grid for month-level planning like content calendars or leave schedules.

How do templates help when a workspace grows to tens of thousands of projects?

Templates standardize how new projects are created so fields don’t vary wildly across teams. In the example, templates pre-fill defaults such as priority (high by default for certain feature types), assigned teams, OKR linkage, and the owner (e.g., a specific owner for marketing projects). The project page body is also templatized with sections for specs, supporting documentation, week-over-week milestones, and tasks—so contributors only fill in the unique details.

What does “linked database” embedding accomplish for team hubs?

Linked databases let other pages embed the same roadmap data without copying it. Team hubs can show a filtered slice (e.g., product hub showing only high-priority projects or only projects owned by Lily). Changes made in the embedded view update the master roadmap automatically, keeping everyone aligned on the same source of truth.

Review Questions

  1. If a team wants leadership to see only approved work, what combination of database properties and filtered views would make that possible?
  2. How would you design properties so that a Kanban board can group by status today and by owner tomorrow without rebuilding the database?
  3. What template fields would you pre-fill to ensure new projects are consistent across product, engineering, and marketing teams?

Key Points

  1. 1

    Store every project as a row in a single Notion database so one card contains both status properties and full lifecycle details.

  2. 2

    Use customizable properties (e.g., status, priority, owner, initiative/OKR, launch schedule) to enable filtering, grouping, and reusable views.

  3. 3

    Create saved filtered views for common audiences and purposes (e.g., “High Priority Projects,” “All Approved Projects”) to avoid duplicated roadmaps.

  4. 4

    Switch between table, Kanban board, timeline, and calendar views to match different planning needs while keeping the same underlying data.

  5. 5

    Use drag-and-drop on board views to update status instantly and keep the roadmap current.

  6. 6

    Apply templates to standardize new project entries at scale, including default priority, assigned teams, owners, and structured body sections.

  7. 7

    Embed linked databases into team hubs so each team works from the same source of truth while seeing only the slice they need.

Highlights

A project card in Notion can function as both the summary and the repository of record—status in properties, and specs/milestones/decisions in the page body.
Filtered views let teams reuse the same roadmap data to create audience-specific dashboards like “All Growth Projects” or “All Approved Projects.”
Timeline and calendar views visualize the same project rows over dates, making overlaps and schedule shifts easier to spot and adjust.
Templates pre-fill defaults and standardize project page structure, which is crucial when the roadmap contains tens of thousands of entries.
Linked database embeds allow team hubs to operate on filtered slices (e.g., only Lily’s projects) while automatically updating the master roadmap.

Topics