Using Notion Relations and Rollups to Build a Lightweight Relational Layer

Problem: Keeping task metadata in sync across projects

Many teams use separate Notion databases for projects and tasks. When a project’s status changes, you often need to update every related task manually, which is error‑prone and time‑consuming. A better approach is to let Notion treat the two databases as related tables and surface aggregated data automatically.

Thesis: Relations and Rollups give you a lightweight relational layer without leaving Notion

By adding a Relation property you create a graph‑like link between records in two databases. A Rollup property then pulls a chosen field (e.g., status, due date) from the linked records and can aggregate it (e.g., show the latest status). This mirrors a foreign‑key join, but stays inside Notion’s UI and works with its native views.

How Relations work

A Relation property stores an array of block IDs that point to pages in another database. When you select a Relation cell, Notion shows a picker that lets you choose one or more existing pages. Under the hood, each selected page’s block ID is added to the Relation’s value list.

How Rollups surface aggregated data

A Rollup property reads the Relation array, fetches the referenced pages, extracts a specific property from each, and applies an aggregation function (e.g., Show original, Calculate > Latest date, Count all). The result appears as a regular column that updates whenever the linked data changes.

Worked Example: Linking Tasks to Projects

1. Create the databases
   • In a workspace, add a Table – Projects database with columns: Name (title), Status (select), Due Date (date).
   • Add a Table – Tasks database with columns: Task Name (title), Assignee (person), Due Date (date).

Add a Relation from Tasks to Projects

• Open the Tasks database, click + Add a property → Relation → choose Projects.
• Name it Related Project and allow linking to multiple projects if needed.

Add a Rollup to show the project status

• Still in Tasks, add a new property → Rollup.
• Relation: Related Project.
• Property to rollup: Status (from Projects).
• Calculation: Show original (if each task links to one project) or Concatenate unique for multiple links.

Use the data

• Now each task row displays the status of its linked project.
• Change a project’s status in the Projects table; all linked tasks update automatically.

# Example: Fetching a task’s block children via the Notion API
# Run this in a terminal or script with your integration token.
# Replace TASK_PAGE_ID with the ID of a task page.

curl -X GET "https://api.notion.com/v1/blocks/TASK_PAGE_ID/children" \
  -H "Authorization: Bearer $NOTION_TOKEN" \
  -H "Notion-Version: 2022-06-28"

# Expected JSON includes a "results" array where each object has an "id" and "type".
# Relation values appear under the property "Related Project" as an array of IDs.

Trade‑off: Flexibility vs. consistency

Notion’s schema‑less databases let you add any property to any page, which is great for ad‑hoc work but can lead to inconsistent data when many people edit the same database. A Relation‑Rollup pattern mitigates this by centralizing the source of truth (the Projects database) and exposing only derived values in Tasks. However, deeply nested Relations (e.g., Tasks → Projects → Clients) increase the amount of data the API must fetch and can slow page rendering, especially in large workspaces.

Actionable closing

If you need cross‑database visibility without building an external sync, start with a single Relation and a simple Rollup (like showing a status or counting linked items). Verify the setup by:

1. Creating a test project and a few test tasks.
2. Linking each task to the project via the Relation picker.
3. Confirming the Rollup column reflects the project’s status.
4. Using the API call above to check that the Relation property stores the expected block IDs.

Watch your workspace’s API usage; if you notice frequent “rate limit exceeded” responses, batch your requests or add a short delay between calls. With these precautions, Relations and Rollups become a practical engineering tool for keeping structured content in sync inside Notion.