Dynamic Priority Management In Notion

A table design trick to automate prioritization of tasks

Aug 19, 2023

Epistemic Status: high confidence the transition from static priority systems to dynamic priority systems is beneficial, based on months of personal usage and success stories

Epistemic Effort: medium, implemented idea and tested/tweaked for several months prior to writing this blog post

Priorities are life-defining in that they are mental tools we use to deal with our finitude. There is only so much time and attention at your disposal, so the question is how to allocate those resources.

When you prioritize “A” over “B”, you are making a value judgment that “A” deserves your attention more than “B” does, and value judgments are a reflection of your value hierarchy. Your value hierarchy exists whether you are conscious of it or not, and it is the foundation of all your decision-making.

One can view priority management as the practice of aligning the contents of your life (what you pay attention to) with your values. What makes this practice tricky is the fact that humans change over time, which means our value hierarchy changes, and thus priorities change. Put simply, priorities are not static, but they are dynamic.

I have toyed around with a few system designs over the years to assist me with priority management, but nothing has been too successful until I realized the system needed to reflect the dynamic property of priorities. In this piece, I’ll discuss priority management at an intermediate system proficiency level (systems thinking), where I will focus on Notion implementations of two priority management approaches. The popular approach is pervasive in many Notion templates and tutorials, which is what I previously used, I call “static priorities”. I’ll reveal some flaws in this design and introduce the new design I’ve been using in 2023 called “dynamic priorities” which I argue is a better system for priority management.

Status Quo: Static Priorities

Here is what static priorities look like. You're essentially creating a Notion table property called “Priority” with three categories: low, medium, and high.

I used this for a couple of years, but I eventually realized it provided little value and created unnecessary friction when creating tasks. I would fill in the priority, but it didn't actually affect how I planned my work. It was just another productivity box to check without serving a true tangible purpose.

There are a few problems with trying to get static priorities to work.

Inconsistency. Even with qualitative criteria, it’s very hard to keep the definitions of “low”, “medium”, “high”, or whatever typology you use, consistent across tasks and months of usage.
Manual updates. I’ve already discussed priorities as dynamic objects. One must continuously update the priority of tasks every week, which can be a tedious and time-consuming process to do manually. It’s just not feasible to manage this at scale. Every week, you have to reassess tens or hundreds of task priorities!
Basement tasks. There are some tasks that you don’t have to ever do, but it’s incredibly important to yourself to get them done within some time period. If you ever thought “I don’t need to do this immediately, but I definitely want to do it at some point in the future,” that’s what I call a “basement task”. You place it somewhere out of view with the delusion you’ll return to it at some point and act on it. With static priorities, you’ll set these as “low” because they are never urgent, but boy does that pile of “low” add up and you never look at them because you’re pile of “high” is always filled.

For 3 years I’ve been wanting to take a solo adversity trip where all I have is a journal and pen, no phone, no food. I added it to my task system, and set a low priority because I thought “I don’t need to do this RIGHT NOW, but I definitely want to do it at some point in the future”. And it’s that subtle phrase “at some point in the future” that I found myself uttering over and over, but those tasks tagged with “low” never saw the light of day, and I never took that trip as long as I had a static priority management system.

Eliminating the priority property altogether is even worse. Without any priority property, you must sift through a massive database every week to figure out what needs to be done or what you really want to do.

Dynamic Priorities

"What actually determines priority?" Let's explore this with a thought experiment. A project due in two months is of lower priority than a project due in two days, but eventually, the first project will also be due in two days. Therefore, priorities are time-dependent. This insight became the seed that grew into dynamic priorities.

I came up with a new Notion design pattern to implement dynamic priorities. This system sets the priority of a task based on its deadline, which may not necessarily be a hard deadline. In fact, 90% of my tasks are soft deadlines, which means there is no third party dictating a due date but rather I am quantifying the priority of the task in “days until I really want this done.” To implement this system, I created a priority property that isn't a category but rather a formula that calculates the time between now and the deadline and then organizes it into a series of "priority" categories.

Advantage #1: Priorities are objectively defined

I love this approach because it standardizes how I assign priorities. All I have to do is think about when I would like to pay considerable attention to a task. Every category has an objective meaning. There is no ambiguity.

Advantage #2: Priorities automatically update as time passes

Everything is automated, and the view of my high-priority tasks updates every day with new tasks as time passes. I call this the “receptive field” because I ignore everything else. It's pointless to look at all tasks during weekly planning. I only attend to the ones that matter at the time.

Advantage #3: Identify what needs to be removed

It’s also easy to shift priorities. When a task enters my receptive field and I realize it’s not something I care for, or other things have come up that are more important to my well-being, I just toss it back a couple months or delete it altogether. I find when I delay something several times, that’s an indicator it’s not ever going to be worthy of my attention and should be dropped from the system altogether.

Advantage #4: Eliminate the basement

The beauty of dynamic priorities is that there is no basement. Everything surfaces eventually all on its own. In Q1 of 2023, I decided to take that solo adversity trip at some point in the second half of 2023, so I picked a date in August, and then I created a task to plan that trip a couple months in advance. At the time of creating that task, it was low priority. And I never saw it for months, until one day it popped up as a high priority item because that deadline was approaching and the dynamic priority field was continuously updating the whole time. Once in my receptive field, I assigned it to a day in the week, got to it, and had my trip planned. At the time of writing, I will be leaving for that trip tomorrow. There are countless other anecdotes of these “at some point in the future” tasks that I finally am executing thanks to this dynamic priorities solution.

Limitations

All systems have limitations, so let me address a few I ran into and how I overcame them.

Limitation #1: Some tasks take a long time to complete and by the time it enters your radar, it’s too late

One limitation I quickly discovered was that some tasks I created took a long time to complete, such as writing an essay, which would only come up on my radar within 1-2 weeks before the deadline. That's when I decided to set some ground rules to avoid these problems.

One ground rule is that a task should take no more than 20 hours to complete (that's 20 hours of total time spent on the task). If a task takes more than 20 hours, it needs to be broken down into smaller tasks. Notion's handy subtasks feature is useful for this purpose. I group tasks into higher-level tasks, which you can think of as initiatives or mini-projects.

Limitation #2: High-priority tasks still pile up

Sometimes, tasks can still pile up. In those cases, I have no choice but to deprioritize, which essentially means extending the soft deadline. The number of days I delay a task quantifies how much I am deprioritizing it relative to others.

Limitation #3: Shifting priorities often means shifting priorities of dependent tasks

Sometimes, I have tasks that depend on other tasks. Deprioritizing one task means deprioritizing all the downstream tasks. Fortunately, Notion has a task dependency feature that enables this automatically. You can set it to maintain time differences between tasks when you shift deadlines around.

Notion Implementation

You can set up a priority property that is not a category, but rather a formula that computes the time between now and the deadline and packetizes it into a series of "priority" categories. This allows you to execute "at some point in the future" tasks that you previously ignored or forgot about, as those tasks will eventually be highly prioritized when approaching their deadlines.

Here is my exact formula. I use four categories:

Critical: ≤ 4 days until deadline
High: ≤ 14 days until deadline
Medium: ≤ 60 days until deadline
Low: > 60 days until deadline

if(
	prop("Closed"), 
	"Closed", 
if(
	empty(prop("Deadline")), 
	"❔ Unknown", 
if(
	dateBetween(prop("Deadline"), now(), "days") > 60, 
	"💤 Low", 
if(
	dateBetween(prop("Deadline"), now(), "days") > 14, 
	"⚠️ Medium", 
if(
	dateBetween(prop("Deadline"), now(), "days") > 4, 
	"❗️ High", 
	"♨️ Critical"
)))))

When I complete a task, I close out the ticket (checkbox property) and the priority reflects “Closed.” Sometimes there is no priority (e.g. recurring tasks like weekly review), and those reflect “Unknown.”

Here is what my “receptive field” looks like (it’s just a table view grouped on the dynamic priority property). When doing weekly planning, I just focus on critical, and some high, priority tasks. The next week, this view automatically updates when the next batch of critical tasks.

I also show the priorities in other views, such as if some event comes up and I need to unassign something, I just drop off the lowest priority task.

Here is what my subtasks look like when I have to split a mini-project into tasks that take less than 20 hours.

Recap

Dynamic priorities are great because

Standardized and consistent priority assignment. The priority is calculated by a formula that computes the time between now and the deadline, which standardizes the priority-setting process. You now objectively know what low or high priority actually means.
Automated priority management. The view of high-priority tasks updates every day automatically with new tasks as time passes on, which allows you to ignore everything else and attend only to the tasks that matter.
Identify items that need to be subtracted. Delaying a task several times is an indicator that it's not going to be worthy of your attention, and it should be dropped from the system altogether.
Clear out the basement. Dynamic priorities allow you to execute on "at some point in the future" tasks that they previously ignored or forgot about, as those tasks will eventually be highly prioritized based on their deadlines.