Get AI summaries of any video or article — Sign up free
Pro Task Manager In Notion Made Simple thumbnail

Pro Task Manager In Notion Made Simple

Red Gregory·
5 min read

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

TL;DR

Use a self-relation in the tasks database to link each subtask to its parent project, with “sync both ways” to keep relationships consistent.

Briefing

A Notion task manager can be built around one core idea: treat each project as a parent record and each task as a child record, then use relations, rollups, and filters to automatically sort work by deadline and priority. The result is a clean workspace where projects and their subtasks stay linked, subtasks roll up key project signals, and “next actions” rise to the top without manual reshuffling.

The setup starts with a single tasks database that holds both projects (A–D) and subtasks (A1–A3, etc.). A relation property named “subtasks” (renamed to “project” in the tasks view) connects each subtask back to its parent project. Enabling “sync both ways” ensures the relationship populates correctly from either side, so selecting a subtask automatically associates it with the right project. Once the links are in place, the workflow focuses on making the hierarchy visually and operationally useful.

For nesting, one approach uses a formula-based “id” property: if the “project” relation is not empty (meaning the record is a subtask), the formula displays the parent project name plus the subtask name; otherwise it shows the project name alone. Sorting by this “id” groups each project with all its subtasks in one continuous block. A second visualization technique uses a formula “sticker” with emoji blocks to distinguish projects from subtasks, then hides the “project” property to reduce clutter.

Sorting and prioritization depend on two fields: “deadline” (date) and “priority” (select with High/Medium/Low). Deadlines are assigned to projects, while subtasks also receive priorities so the system can decide what to do first. To make sorting smarter, the build creates rollups on the tasks view: “project due” uses a relation to the parent project and calculates the earliest associated date, while “project priority” rolls up the parent project’s priority using “earliest”/priority logic. With these rollups available, sorting can be layered—first by project due date and project priority, then by subtask priority—so a high-priority subtask inside a high-priority project bubbles above lower-priority items.

To manage completion, a “done” checkbox is added. An “archive” view filters for subtasks where “project is not empty” and “done is unchecked,” effectively removing completed items from the active list and sending them to an archive-style area. A separate rollup called “progress” on the projects database calculates percent checked from the “done” status of subtasks, giving each project a live completion meter.

Finally, the system becomes scalable through templates. A “new project” template creates a page that automatically links and displays all subtasks whose “project” relation contains the template’s project name, and it applies a chosen emoji. The same structure turns a standard tasks list into a dashboard-friendly project tracker where hierarchy, sorting, and progress update automatically through relations and rollups rather than manual maintenance.

Cornell Notes

The core build links projects to their subtasks using a parent-child relation in Notion, then uses rollups and filters to sort work automatically by deadline and priority. A “project due” rollup pulls the earliest parent deadline for each subtask, and a “project priority” rollup brings the parent project’s priority down to the task level. Sorting can then be layered: project-level signals first (due date, project priority) and subtask-level signals second (subtask priority), so the “next actions” appear in the right order. Completion is handled with a “done” checkbox plus an archive view that filters completed subtasks out of the active list. A “progress” rollup on projects calculates percent checked from subtasks, and templates let new projects auto-populate their subtasks and styling.

How does the system connect each subtask to the correct parent project in Notion?

It adds a relation property (named “subtasks” at first, then renamed to “project” in the main view) that connects the tasks database to itself. Each subtask record links to its parent project record via that relation. “Sync both ways” is enabled so the relationship populates reliably when selecting entries in relation cells. After enabling the relation, the view is adjusted to show the “project” property so subtasks can be connected (e.g., searching for A1, A2, A3 to link them to project A).

What’s the purpose of the formula-based “id” property and how does it achieve nesting?

The “id” formula creates a sortable key that groups subtasks under their parent project. If the “project” relation is not empty (the record is a subtask), the formula outputs the parent project name plus the subtask name in a consistent format (including parentheses). If the relation is empty (the record is a project), it outputs only the project name. Sorting ascending by this “id” produces a visual block where Project A appears with all its subtasks, then Project B with its subtasks, and so on.

How do rollups make sorting by project deadline and priority possible at the subtask level?

Two rollups are created in the tasks view. “project due” is a rollup that looks at the parent project relation and calculates the earliest date, so each subtask inherits the project’s due signal. “project priority” is another rollup that rolls up the parent project’s priority from the related project record. With these rollups present, sorting can use project-level fields (e.g., project due, project priority) while still keeping subtask-level priority in the sort order.

What sorting strategy ensures the correct order when both project priority and subtask priority matter?

Sorting is layered. First, tasks are sorted by project due (or project due date) and then by project priority. After that, a second sort is added for subtask priority. This changes the order from “all subtasks in a project” to “the highest-priority subtask inside the highest-priority project,” so items like d3 (high priority subtask in a high priority project) rise above other subtasks in the same project.

How does the build handle completed subtasks without losing them?

A “done” checkbox is added to the tasks database. An archive-style view filters for subtasks where “project is not empty” and “done is unchecked,” so completed subtasks can be hidden from the active list and effectively moved into an archive area. The “done” property is kept visible so items can be unchecked if needed to return them to the active workflow.

How is project progress calculated automatically?

On the projects database, a “progress” property is added as a rollup. It rolls up the subtasks’ “done” checkbox using a percent-checked calculation. As subtasks get checked off, the project’s progress percentage increases toward 100, providing a live completion indicator for each project.

Review Questions

  1. If a subtask’s “project” relation is empty, how would that affect nesting and rollup-based sorting?
  2. What combination of rollups and sort orders would you use if you wanted subtask priority to override project due date?
  3. How would you modify the archive filter if you wanted completed projects (not just subtasks) to disappear from the active dashboard?

Key Points

  1. 1

    Use a self-relation in the tasks database to link each subtask to its parent project, with “sync both ways” to keep relationships consistent.

  2. 2

    Create an optional formula “id” to generate a sortable key that visually nests subtasks under their parent project.

  3. 3

    Add “deadline” (date) and “priority” (select) to support sorting by time and urgency.

  4. 4

    Use rollups like “project due” (earliest parent date) and “project priority” to bring project-level signals down to each subtask.

  5. 5

    Layer sorts: prioritize project-level ordering first (due date, project priority), then subtask-level priority to determine next actions.

  6. 6

    Manage completion with a “done” checkbox and filtered archive views so completed subtasks leave the active list.

  7. 7

    Track progress with a project-level rollup that calculates percent checked from subtasks, and use templates to auto-populate new project pages with their subtasks.

Highlights

A parent-child relation plus rollups turns project deadlines and priorities into automatic sorting criteria for individual subtasks.
Sorting can be made truly actionable by layering project-level due/priority with subtask-level priority, so the “next action” list updates as priorities change.
A percent-checked rollup on projects provides a live progress meter without manually updating percentages.
Templates let new project pages auto-link the right subtasks based on the project relation containing the template’s project name.

Mentioned