Get AI summaries of any video or article — Sign up free
Notion Office Hours: Formulas 201 đź§® thumbnail

Notion Office Hours: Formulas 201 đź§®

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

Use nested if statements to implement multi-branch decision logic based on checkbox true/false or select option values.

Briefing

Notion formulas 201 zeroes in on the “conditions” side of formula building—turning checkbox/select inputs into different outputs—then uses that same logic to automate task prioritization and generate visual progress bars. The core takeaway is that Notion’s if function (often nested) is the practical switchboard for decision-making: it lets users encode rules like “if important and urgent, do it; if important but not urgent, schedule it; if urgent but not important, delegate it; otherwise eliminate it.” That matters because it converts static task fields into dynamic, actionable views inside a Notion database.

The session starts by revisiting the formula anatomy from formulas 101: formulas become useful when they answer three questions—what action to take, what inputs to use, and what conditions must be met. Today’s exercises focus on the third question. For the first project, task prioritization, the Eisenhower Matrix is implemented directly in a tasks database. Users add two checkbox properties—Important and Urgent—and then build a formula property that outputs one of four action labels based on the checkbox combination. The logic is expressed with a top-level if that checks Important, and nested if statements that check Urgent to select between “do,” “schedule,” “delegate,” and “eliminate.”

Next comes a second prioritization method, a “Murry matrix” variant that swaps urgency/importance for two select properties: Effort (Low/Medium/High) and Impact (Low/Medium/High). The session assigns numeric priority values by mapping each Effort and Impact option to a number using if logic. To keep formulas manageable, it breaks the work into intermediate formula properties—Effort Priority, Impact Priority, and Total Priority—then uses another nested if chain to convert Total Priority into emoji indicators (police lights, flames, stars, coffee cups, sleepy face) so tasks can be sorted and scanned visually. A key workflow tip appears here: for complex formulas, writing in a code block (with line breaks/indentation for readability) before pasting into Notion reduces mistakes.

The second major exercise builds progress bars using four functions: if, slice, round, and format. The approach is to compute a percentage property first (completed units divided by total units, optionally rounded), then render a bar by slicing a string of filled circle characters and concatenating it with the remaining unfilled circles. The filled length is derived from the percentage (scaled to a 1–10 range and rounded), and the final output appends the percentage as text using format so it can be concatenated. The session also notes practical constraints—like the need to handle edge cases such as 0%—and points viewers to Notion VIP for formula cheat sheets and exercise files.

By the end, the emphasis is less on memorizing one-off tricks and more on mastering conditional logic patterns: nested if statements for multi-branch decisions, intermediate properties to decompose complexity, and string/number functions to turn calculated values into readable UI elements inside Notion.

Cornell Notes

Formulas 201 teaches how to encode decision rules in Notion using the if function—especially nested if statements—to produce different outputs based on conditions from checkbox and select properties. It demonstrates two prioritization systems: an Eisenhower Matrix using Important/Urgent checkboxes and a “Murry matrix” using Effort/Impact select options mapped to numeric priorities and emoji labels. The session then applies conditional logic and supporting functions (slice, round, format) to build visual progress bars from a calculated percentage. The practical payoff is turning database fields into automated, sortable action labels and UI-style indicators without manual updates.

How does the Eisenhower Matrix get implemented in Notion formulas?

Users add two checkbox properties to each task: Important and Urgent. A formula property then uses a top-level if to check whether Important is true. If Important is checked, a nested if checks Urgent: Important+Urgent returns “do,” while Important+not Urgent returns “schedule.” If Important is not checked, another nested if checks Urgent: not Important+Urgent returns “delegate,” and not Important+not Urgent returns “eliminate.” Because checkboxes behave like true/false, the formula can reference the checkbox directly without extra comparison operators.

Why does the session recommend breaking complex logic into intermediate properties?

Instead of cramming everything into one huge formula, the “Murry matrix” approach creates separate formula properties—Effort Priority and Impact Priority—then combines them into Total Priority. Effort Priority maps Effort (Low/Medium/High) to numbers (1/2/3) using if logic. Impact Priority maps Impact to numbers in reverse (because high impact should raise priority): Low impact becomes 3, Medium stays 2, and High becomes 1. Total Priority is then computed as Effort Priority + Impact Priority, and a final nested if chain converts Total Priority into emoji labels.

What’s the role of slice, round, and format in building progress bars?

slice builds the visual bar by extracting a substring from a string of filled circles (and separately for unfilled circles). round converts a scaled percentage into an integer count of filled characters. format converts the numeric percentage into a text string so it can be concatenated with the bar characters and a percent sign. Together, these functions turn a computed percentage into a readable, text-based progress indicator inside a single formula property.

How is the progress percentage typically calculated before rendering the bar?

One method uses arithmetic on numeric properties: completed units divided by total units, then multiplied by 100 to get a percentage. The session highlights that percentages can look “ugly” due to decimals, so rounding can be applied (it mentions a rounding trick using multiplication/division around round). Another method uses relations and rollups: link tasks to projects and use a rollup to display “percent checked” from task completion, producing the percentage property needed for the progress bar.

What workflow tip helps reduce errors when writing nested if formulas?

For more complex formulas, the session suggests composing the logic in a code block (with JavaScript-style formatting/indentation) so line breaks and indentation make the structure easier to verify. After confirming the formula logic, it’s pasted into the Notion formula property; Notion may not preserve line breaks/tabs, so pasting via the browser address bar can remove unwanted characters.

What limitations and workarounds come up around formula-driven UI fields?

A Q&A exchange clarifies that formulas can display computed values, but they can’t manipulate certain property types like select options (i.e., a formula can’t update a select property’s chosen option). The workaround is to use formulas to display the desired output as text/emoji or other computed fields, and—when data needs to flow across databases—use relations and rollups to bring values into the target database where the formula runs.

Review Questions

  1. In the Eisenhower Matrix formula, what exact condition combinations map to “do,” “schedule,” “delegate,” and “eliminate”?
  2. How do Effort Priority and Impact Priority differ in their numeric mapping, and why is Impact reversed?
  3. Describe how slice and round work together to determine the number of filled characters in the progress bar.

Key Points

  1. 1

    Use nested if statements to implement multi-branch decision logic based on checkbox true/false or select option values.

  2. 2

    Eisenhower Matrix automation in Notion can be built with two checkbox properties (Important, Urgent) and a single formula property that outputs one of four action labels.

  3. 3

    For more complex prioritization, create intermediate formula properties (e.g., Effort Priority, Impact Priority, Total Priority) to keep logic readable and debuggable.

  4. 4

    Progress bars in Notion formulas can be rendered as text by combining slice (substring extraction), round (integer character counts), and format (number-to-text conversion).

  5. 5

    Compute a percentage property first (either via arithmetic or via relation/rollup “percent checked”), then use that percentage to drive the visual output.

  6. 6

    Write complex formulas in a formatted code block first to reduce syntax mistakes, then paste into Notion’s formula field for execution.

  7. 7

    Notion formulas can’t directly update select properties; they can compute and display values, while relations/rollups help move data between databases.

Highlights

The Eisenhower Matrix logic becomes a practical Notion automation: Important+Urgent → “do,” Important+not Urgent → “schedule,” not Important+Urgent → “delegate,” and neither → “eliminate.”
The “Murry matrix” turns Effort and Impact select options into numeric priorities and then into emoji labels, enabling sorting and quick scanning.
A progress bar can be built entirely from formula functions—slice to choose filled/unfilled characters, round to size the fill, and format to append the percentage as text.
Complex nested if formulas are easier to build correctly when drafted in a code block with indentation before pasting into Notion.

Topics

Mentioned