Get AI summaries of any video or article — Sign up free
Notion's New Automations Feature is a Game-Changer thumbnail

Notion's New Automations Feature is a Game-Changer

6 min read

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

TL;DR

Database automations use a trigger/action model (e.g., “Page added” or “Property edited” → actions like adding pages, editing properties, or sending Slack notifications).

Briefing

Notion’s new “database automations” feature brings true if-this-then-that workflows directly into database operations—turning status changes, page creation, and property edits into automatic timestamps, task generation, and Slack alerts. The practical payoff is less manual bookkeeping: completion dates and durations can populate themselves, default project checklists can appear instantly, and teams can get notified when work moves.

At the core is an automation builder tied to a specific database (or a specific view). A lightning-bolt menu adds automations where users define a trigger—such as “Page added” or “Property edited”—and then one or more actions. Triggers can be broad (any edit) or granular, including status changes and specific selections within properties. Actions range from adding pages (either to the same database or another one where the user has edit access), editing properties on existing pages, and sending Slack notifications to a connected workspace.

One early example focuses on time estimation accuracy. In a tasks database, when a task’s status moves into a “done” group, an automation writes a “completed date” timestamp. A formula then calculates a “completion gap” by comparing the completed timestamp against a due timestamp—highlighting whether tasks finish early or late. A second example expands this into lightweight time tracking. When status changes to “in progress,” an automation stamps a “started” time; when status moves to “done,” it stamps “completed.” A formula derives a sortable task duration, using a string-based output to work around limitations in Notion formula time objects. To keep the demo realistic, the automations are scoped to a specific “time tracker” view so they only run when edits happen there.

Slack notifications show how automations can combine multiple triggers with the same outcome. One automation sends a Slack message when a task is created and also when its status updates into key stages (like “in progress” and “complete”). The built-in Slack integration is convenient but slower than external automation tools—often taking a couple of minutes—so faster alternatives like pipedream, make.com, and zapier are positioned as options for teams that need near-real-time updates.

The most “game-changer” workflow is default task generation inside projects. When a new project page is added to a project database, an automation creates multiple related task pages in a tasks database, assigns owners automatically, and sets a relation back to the triggering project page using a dynamic “this page” value. The result: every new project comes with a prebuilt checklist (e.g., topic validation, filming, editing), already linked and sorted for execution.

That power comes with a warning: the “edit pages” action can be dangerous if filters aren’t set. If an automation edits a target database without constraints, it can unintentionally modify every page in that database—potentially wiping important fields. The transcript stresses permission hygiene and filter setup, especially in team spaces where many users may have full access.

Finally, the feature is framed as primarily available to paid Notion accounts. Free users can still use automations via templates (duplicate-and-run) and can build similar workflows using the Notion API through no-code tools. The broader message is clear: database automations make Notion feel less like a static tracker and more like a workflow engine—if users build carefully and avoid the “nuke my data” pitfalls.

Cornell Notes

Notion’s Database Automations add built-in if-this-then-that workflows inside databases, letting status changes and page events trigger automatic actions. Users can stamp timestamps, compute completion gaps, track task durations, send Slack notifications, and even generate default task checklists when new projects are created. A key implementation detail is the trigger/action model: “Page added” or “Property edited” can start one or more actions like adding pages, editing properties, or sending Slack messages. The feature is powerful enough to create time tracking and project scaffolding, but it can also be risky—especially when using “edit pages” without filters, which could unintentionally update every page in a target database. Paid accounts can build and edit automations directly; free accounts rely on templates or the Notion API via tools like pipedream or make.com.

How do database automations work at a practical level in Notion?

Each automation is built around a trigger and one or more actions. Triggers include “Page added” (fires when a new page enters the database) and “Property edited” (fires when a property changes). Status properties can be used with group/choice granularity—for example, triggering only when status moves into a “complete” group. Actions include adding new pages (to the same database or another database where the user has edit access), editing properties on existing pages, and sending Slack notifications to configured channels.

What’s the simplest time-estimation workflow described?

When a task’s status changes to the “done/complete” group, an automation writes a “completed date” timestamp into a dedicated property. A formula then calculates a “completion gap” by comparing the completed timestamp against the due timestamp. The point is to quantify whether tasks finish earlier or later than planned, so future estimates can be adjusted.

How does the transcript’s time tracking example handle duration sorting?

It stamps “started” when status moves to “in progress” and stamps “completed” when status moves to “done.” A formula then outputs a task duration in a string format rather than a numeric time object, because Notion formulas lack a super-useful time object. The string output is formatted so the view can still sort correctly by duration, enabling a sortable time-tracking dashboard.

How are default tasks automatically created for new projects?

When a new project page is added to a project database, the automation runs a trigger (“Page added”) and then uses an action that adds pages to a tasks database. For each default task, the automation sets properties like task name, assigns an assignee, and sets a relation back to the triggering project using a dynamic value (“this page”). The workflow can create multiple tasks per project (the transcript demonstrates creating several similar tasks), so each new project arrives with a linked checklist.

Why is “edit pages” considered a danger zone feature?

The “edit pages” action can update existing pages in a different target database. If filters aren’t set, the default behavior can apply to all pages in that target database. That means an automation could unintentionally overwrite properties across hundreds or thousands of rows in a production database. The transcript emphasizes using filters (e.g., only edit rows where “archived” is checked) and controlling who can create automations in team spaces.

What options exist for free Notion users?

Free accounts can’t create or edit automations directly. Instead, they can duplicate templates that contain automations into their own workspace and then use those prebuilt automations. For building custom workflows without paid automation editing, the transcript points to the Notion API and no-code tools such as pipedream, make.com, and zapier.

Review Questions

  1. What trigger types and action types are available in Notion database automations, and how do they combine to create a workflow?
  2. Describe how the completion gap calculation works and what properties it depends on.
  3. What safeguards should be used when employing the “edit pages” action to avoid unintended mass updates?

Key Points

  1. 1

    Database automations use a trigger/action model (e.g., “Page added” or “Property edited” → actions like adding pages, editing properties, or sending Slack notifications).

  2. 2

    Status changes can drive automatic timestamps, enabling completion-date tracking and formula-based “completion gap” analysis against due dates.

  3. 3

    Time tracking can be implemented by stamping “started” on “in progress” and “completed” on “done,” then deriving a sortable duration via a string-formula workaround.

  4. 4

    Default project task checklists can be generated automatically by creating multiple related task pages when a new project page is added, using a dynamic relation value (“this page”).

  5. 5

    Slack notifications can be triggered by both page creation and status updates, but the built-in integration may take a couple of minutes compared with API-based tools.

  6. 6

    The “edit pages” action is high-risk if filters are not set, because it can default to editing every page in the target database.

  7. 7

    Paid Notion accounts can build and edit automations directly; free users rely on templates or the Notion API via tools like pipedream and make.com.

Highlights

A single status change can automatically stamp timestamps and feed formulas that quantify schedule accuracy (completion gap vs due date).
Time tracking is possible inside Notion without external tools by pairing “started” and “completed” automations and using a sortable duration formula output.
New projects can automatically spawn a linked checklist of default tasks—complete with assignees—using relation values tied to the triggering page.
The “edit pages” action can silently become destructive when no filters are set, potentially updating every row in a target database.
Built-in Slack notifications are convenient but can lag by minutes, while API-based automation tools can be faster.

Topics

Mentioned