Tasks and notes: A match made in Roam

In March 2020, I fell in love with Roam Research.

I had been struggling for a few months to build my personal knowledge management (PKM) using Notion. But when I discovered Roam, I knew my notes had found their home.

At that time, I managed my tasks and projects in Todoist. I had been a happy Todoist user since 2014, when I first discovered David Allen’s life-changing Getting Things Done (GTD). By 2020, according to Todoist’s Karma metric, I was “Enlightened.” And I had never felt the urge to manage tasks using any app other than Todoist.

Within three weeks, I found myself instinctively typing [[double brackets]]—which define pages in Roam—while entering tasks in Todoist. My brain desperately wanted to tie my tasks directly to their context in Roam, without a clunky workaround like copying a Roam link into Todoist’s task comments.

I wanted to build my task management system in Roam Research, but three things were holding me back.

1. Building my task management in Roam was daunting. Todoist is built specifically to manage tasks. Roam has [[TODO]] mechanics, but you have to build the framework yourself.
2. I was afraid my tasks would get lost in my notes—or that my notes would be cluttered with to-dos. I didn’t want to be left with a useless blob.
3. Most important, I didn’t know how to deal with recurring tasks. Recurring tasks are a fundamental feature of dedicated task apps, but Roam doesn’t have native support for them.
   • NOTE: On the Saturday before I posted this, Roam shipped an as-yet-unnamed feature known as “∆” that founder Conor White-Sullivan says solves recurring and ongoing tasks (among other things). After toying with it for a few hours, I’m sticking with my method for now. If I find over time that ∆ changes my approach, I’ll update this post. Such is the glory of Roam—things change fast, and there are many different ways to get things done!

What changed my mind?

Ultimately, I decided I could build my task management in Roam if I could meet these three criteria:

1. Tasks must be deeply integrated into notes
2. Tasks must be completely separate from notes
3. There must be a simple mechanism for recurring tasks

The first two sound mutually exclusive, but using Roam’s amazing and flexible block references, you can keep notes both in context “in the wild” and also organized in your task management system.

The third would have been a dealbreaker. But in mid-April, I figured out a mechanism for recurring tasks. I refined it over time, and I’ll share it in this post.

Task Management in Roam Research: A Walkthrough

I wrote this for Roam Research users—Greetings, #roamcult!—who take notes in Roam but keep their tasks somewhere else. Maybe you see the potential magic in keeping your tasks with your notes, but you’re hesitant to take the leap. Or maybe your tasks are in Roam already, but you wish they were more organized.

If you’re not familiar with Roam Research at all, start with Nat Eliason’s excellent primer Roam: Why I Love It and How I Use It. He wrote it a few months ago—an eon in Roam time—but it’s still a great intro to the fundamentals. Then take Roam out for a spin. Come back here when you’ve fallen in love with it and never want to leave.

This post will walk you through the basics of building task management in Roam Research. Here’s what we’ll do:

1. Build your Task Framework
2. Get tasks from your notes into your system
3. Process your Projects, Next Actions, and Agenda
4. Build and maintain your Recurring Tasks

This post is an overview, but it goes into enough detail that you can implement the system yourself. If you’d like to explore the concepts more thoroughly in a course format, check out my course Powerful Task Management in Roam Research on Teachable.

---

Build your Task Framework

In Roam, you create pages and fill them with blocks of content. You can also use page names as tags or attributes. Because of this, every component of my Task Framework is its own page.

On my page called [[Task Framework]], I list every page used in my task management system, organized as Categories, Contexts, and Recurring Task handlers.

Categories

A category is a page where your tasks will either live or be “pulled” to by queries. Here are the categories I use:

[[Inbox]]
[[Projects]]
[[Projects: Active]]
     #active
[[Projects: Archive]]
     #archive
[[Next Actions]]
[[Agenda]]
[[Weekly Review]]
[[Reading List]]
[[Unassigned Tasks]]

The two category tags, #active and #archive, determine what is visible on my [[Projects: Active]] and [[Projects: Archive]] pages.

Contexts

A context is a page used as a tag. Contexts provide extra information about a task. They can tell you where, how, or when a task should be done, or define its priority or how long it will take.

Combined with queries, contexts make robust task management possible.

To make contexts easier to recognize at a glance, and to leverage Roam’s autocomplete, I use “@” as a prefix for all my contexts.

Here is a sample list of contexts. If you adopt my system, adjust this list to suit your specific needs.

Where?
    #@home
    #@work
    #@errand

How?
    #@call
    #@email

When?
    #@next
    #@waiting
    #@someday

Who?
    (spouse, colleague, etc.)

Priority
    #@p1
    #@p2

Duration
    #@5min
    #@15min
    #@60min

Energy Level
    #@high-energy
    #@low-energy

Recurring Tasks

The recurring task system defines the pages that help you process your routines. It takes about 15 minutes a week to maintain recurring tasks.

These are the pages you’ll need. We’ll cover how to use them in a moment.

[[Daily Tasks]]
[[Daily Tasks Archive]]
[[Weekly Tasks]]
[[Monthly Tasks]]
[[Annual Tasks]]

Full Task Framework page

Here’s what it looks like in “real life”:

---

Get tasks from your notes into your system

Since I started using Roam Research, I take notes on everything: voice lessons I teach, coaching sessions with my clients, books I’m reading—everything.

When I take notes, tasks arise. I don’t want to click away from my notes to write down a task, for two reasons:

1. It interrupts the flow of my thoughts, and
2. It pulls the task out of context.

After all, if I wanted to go somewhere else to list my tasks, I could’ve stayed with Todoist.

So here’s what I do: In the midst of my notes, I create a block that mentions the task, and at the end of it I type “#Inbox”. Then I hit Enter and keep taking notes. That’s it.

Here’s that concept in action:

Later, once a day, I review my [[Inbox]] page and process the potential tasks further. But before I explain that workflow, you need to understand how my Inbox is set up.

Inbox query

Theoretically, you could rely on Linked References on the [[Inbox]] page to intake all your ideas. However, I built a query so I could include #[[Quick Capture]] notes I’ve entered from my phone.

On the [[Inbox]] page, enter this query as a block:

{{[[query]]: {and: {or: [[Inbox]] [[Quick Capture]]} {not: {or: [[DONE]][[Daily Tasks]][[Weekly Tasks]][[Daily Tasks Archive]][[Task Framework]][[query]]}}}}}

Looks terrifying, doesn’t it? I go into more detail on Roam queries in Powerful Task Management in Roam Research, or you can learn more about them in this video from Robert Haisfield. Queries render a bit different now than in his video, but their basic functionality is the same.

For now, here’s all you need to know: this query compiles everything tagged either #Inbox or #[[Quick Capture]]. It also excludes any task that is already completed ([[DONE]]), and also excludes structural components of the system.

My [[Projects]] page

I organize my [[Projects]] page based on my priorities: Family, Development (personal & professional), Coaching, Creative, Music Work, and so forth. This provides me a nice heuristic: if an incoming project doesn’t fit into one of my priority areas, is it a project I should even be doing? (If you like this ooey-gooey coaching goodness, I can help you sort out your priorities, too!)

My individual projects are pages listed under my priorities. Each project page has sections for Tasks, Questions, and Notes, which allows me to keep all my information relevant to a project in the same place.

See the video below, or visit my demo Roam graph, to see my [[Projects]] page work.

Processing your Inbox into your Projects

The key to maintaining the link between your notes and your tasks is using Roam Research’s block references.

When you review each of your Inbox items every day, follow this process. Breaking it into nine steps makes it seem more complicated than it is. Watch the video after reading the process and you’ll see what I mean.

1. Open your [[Inbox]] in the right sidebar and your [[Projects]] in the main view.
2. Copy each Inbox item’s block reference by right-clicking its bullet point and selecting “Copy block ref”.
3. Paste the block reference into the appropriate project page.
4. Click elsewhere so the new reference appears, then click on the reference.
5. From the menu that appears, select “Replace with” and then “text with alias”.
6. Now, leave the alias (the brackets, asterisk, and block reference ID) alone, but replace the text with a clear, actionable task.
7. Add context tags as necessary.
8. Press CTRL+Enter to make it an official [[TODO]].
9. Remove the #Inbox tag from the original note.

---

Process your Projects, Next Actions, and Agenda

Now that we have our tasks populated into our clean system—while still integrated with their source notes!—we need to know what to do with them.

I use context tags attached to tasks, combined with queries on my [[Next Actions]] page, to organize my work.

How do Next Action queries work?

On my [[Next Actions]] page, I have a heading for each Where context: “Next Home”, “Next Work”, “Next Errands”, etc. Under each heading, a query selects all tasks tagged both #@next and the appropriate context.

For example:

{{[[query]]: {and: [[TODO]] [[@next]] [[@home]] {not: {or: [[Weekly Tasks]] [[DONE]]}}}}}

That query selects all to-dos tagged as next actions that I need to complete when I’m at home. It also filters out any potential mentions of that combination that appear in my Weekly Tasks, and—redundantly—it filters out completed tasks.

That’s redundant because [[TODO]] and [[DONE]] are mutually exclusive in Roam’s system. But doing it this way catches any potential unexpected behavior, and also helps me to see, at a glance, how the query works.

My other queries on the [[Next Actions]] page are the same, except they sub out @home for @work or @errand. Simple and straightforward.

Populate Next Actions

When I’m reviewing a specific project—or if I’m performing my overall Weekly Review—I look at my list of tasks in a project and determine which ones need to be done next.

Sometimes that’s as simple as whatever is next in sequence. Sometimes it’s based on dependencies. Maybe one task has to be done to make other tasks possible.

Whatever the reason, when I apply a #@next tag, I also apply a Where? context tag. That way, I know my next actions will appear where I need them.

Use Next Actions to populate the daily Agenda

Each evening, I build my [[Agenda]] for the following day. I do this directly on my Daily Notes page—[[September 8th, 2020]], [[September 9th, 2020]], etc. That way, when I open Roam the next morning, my Agenda is there waiting for me.

To start, I type [[Agenda]] and indent underneath it. Then I review my calendar and add the times of specific meetings.

Next, I open [[Next Actions]] in my right sidebar and go through them. When I encounter one I’d like to schedule, I copy its block reference and paste that into the [[Agenda]].

If I were to copy and paste a task into my [[Agenda]], it would be a standalone task. But if I reference it, it’s linked with the original. When I check it off, it checks off the original task, too.

I draw from a few other sources for my [[Agenda]], but this is enough for you to understand the concept. Here’s a video to see it in action. The course digs a bit deeper if you want to know more.

Revisiting a project to assign new Next Actions

When I complete an action labeled #@next, I revisit its home project to label a new task as #@next. If I don’t have time to do that right away, I have a mechanism that helps me make sure projects don’t slip off my radar.

If I’m actively working on a project, I have it tagged #active on my [[Projects]] page. That way, each day I can give my [[Projects: Active]] page a once-over.

If I encounter any #active projects not reflected in my Next Actions list, that’s a cue I should check it for any overlooked tasks.

---

Build and maintain your Recurring Tasks

It will take an hour or two to set up your recurring task system for the first time. After that, you’ll only need about 15 minutes a week to keep your routines on track!

Here’s how it works.

Build your Daily Tasks page

The first thing on the [[Daily Tasks]] page is a template. In the template, your #routines should contain the tasks you do literally every single day. Your #Tasks will be blank until we add in the weekly, monthly, and annual tasks later.

Here’s how you use the template during your [[Weekly Review]]:

1. On the [[Daily Tasks]] page, under the template, create (or generate) the date notes for next week: e.g., [[September 6th, 2020]], [[September 7th, 2020]], [[September 8th, 2020]], and so forth.
2. Indented under each date, copy and paste the template.

This is actual “copy and paste,” not block references. You want these to be separate tasks from one another, because they need to be completed separately, once each day.

Here’s what that looks like:

Theoretically, you could copy this template directly onto Daily Notes. But this method lets you build the whole structure in one place, [[Daily Tasks]], rather than bouncing from page to page during the [[Weekly Review]]. Everything will appear on the correct day, neatly tucked in your Linked References.

Build your weekly, monthly, and annual tasks pages

The concept here is simple. You’ll just have some typing to do the first time you set these up.

On the [[Weekly Tasks]] page, create a heading for each day of the week: #Sunday, #Monday, #Tuesday, etc. Then, indented underneath each day, list the tasks (styled as TODOs) that need to be done that day.

On the [[Monthly Tasks]] page, create a heading for each date of the month: #01, #02, #03… #29, #30, #31. Then, as you did with weekly tasks, list the to-dos that need to be done on each date indented underneath each day.

On the [[Annual Tasks]] page, create a heading for each month of the year: #January, #February, etc. Then, under each, list to-dos that need to be accomplished each month. I nest them under an additional day-of-the-month tag, so they’re easy to understand when I’m populating my [[Daily Tasks]] list.

I have simple workarounds for biweekly, quarterly, and other recurring tasks that aren’t exactly weekly, monthly, or annual. The course covers those topics.

Populate your Daily Tasks during your Weekly Review

Read the process, and if you have any questions, watch the video!

Open your [[Daily Tasks]] in your main page, and have [[Weekly Tasks]], [[Monthly Tasks]], and [[Annual Tasks]] in your right sidebar.

Starting with [[Annual Tasks]], copy and paste to-dos under the #Tasks heading on the correct days of your [[Daily Tasks]] page.

Then move to [[Monthly Tasks]] and do the same, copying the tasks from dates of the months.

Finally, do the same with your [[Weekly Tasks]].

When you’re done, you have a [[Daily Tasks]] list that reflects every recurring task you need to accomplish over the next week.

The merits of this approach

There are two things I’ve come to love about this system:

1. I am much more intimately acquainted with my recurring tasks. I know exactly what’s coming up, because I engaged with it.
2. It requires me to complete my Weekly Review every single week. When I used Todoist, I could skip my weekly review for a month or two before friction built up in the system. That wasn’t a good habit.

Everything else

This post doesn’t cover the nitty-gritty of the [[Weekly Review]], and my [[Reading List]] is more about how my system integrates with literature notes in my Zettelkasten than it is about tasks. I didn’t detail [[Unassigned Tasks]] either, but the concept is probably self-explanatory, even if the implementation isn’t.

I also didn’t cover all the contexts, like #@waiting or #@someday or any of the priorities. They rely on tags and queries, too, and behave the way you would expect them to in a GTD context.

But I hope this post provides enough of a framework to get your task management up and running.

If you would like a deeper dive, sign up for Powerful Task Management in Roam Research on Teachable.

I want to hear other people’s solutions to task management in Roam. Or maybe you’ve made some refinements to my own system. Let me know in the comments or on Twitter (@rjnestor)!