TL;DR: Every Tatask app (web, iPhone, Android) keeps a full copy of your tasks in a local WatermelonDB database. You read and write locally, so the app is fast and works offline. A sync engine exchanges changes with Firestore in the background: on sign-in, when you reconnect, when you come back to the app, and whenever another device changes something. Deletes are tombstones, conflicts are last-write-wins, and signing out of the web app wipes the local copy.

Tatask is offline-first. That's a phrase that gets used loosely, so this post explains what it means in practice for Tatask: where your tasks live, how they move between devices, and the trade-offs I chose. It's written for developers and the curious. If you just want to know whether it works on a train, the answer is yes, and the offline and sync feature page is the short version.

The problem

A to-do list gets used in bad conditions: on the Underground, on a plane, in a basement gym, on hotel Wi-Fi. If every action waits for a server, the app is only as reliable as the connection. People notice quickly, and they start writing things down somewhere else.

So the requirement was: everything you do in Tatask should work with no connection at all, and should reach your other devices when a connection comes back.

A local database on every device

Each Tatask app has its own complete database of your tasks, on the device.

I use WatermelonDB, a reactive database built for apps with lots of records that need to sync.

• On iPhone and Android, the Expo app runs WatermelonDB on SQLite through its native adapter.
• In the browser, the web app runs WatermelonDB on its LokiJS adapter, which stores data in IndexedDB. The browser has no native SQLite binding, so this is WatermelonDB's official web option. The schema and sync logic are the same; only the storage engine underneath changes.

The data model is deliberately small: a tasks table and a users table. A task's position in the tree is just a parent_id pointing at another task, with a sentinel for the root. Tags are derived from hashtags in the text. Due dates, completion times and deletion times live in a metadata field. The two apps share the same contract, so a task edited on one is read correctly by the other.

Reads and writes are local

When you add, edit, complete or move a task, the app writes to the local database and the screen updates straight away. Nothing waits for the network.

The UI is reactive. Components subscribe to queries on the local database, so when a record changes, whether you changed it or a sync brought the change in, every view showing it updates. In the Svelte web app, that's a thin store wrapper around WatermelonDB's observables. In the React Native app, it's withObservables.

Sync

Sync uses WatermelonDB's built-in synchronize() protocol, which has two halves: pull and push. Both talk directly to Firestore from the client. There's no custom sync server to run.

Pull

The app asks Firestore for documents belonging to you that have changed since the last pull. Those changes are applied to the local database. If a composite index is missing, there's a slower fallback query, so sync degrades rather than fails.

Push

Local changes since the last sync are written to Firestore in batches using merge writes, so a push only touches the fields that changed. Batches are capped well below Firestore's per-batch limit.

When sync runs

There's no polling timer. Sync runs:

• when you sign in
• when the browser comes back online (web) or the app comes back to the foreground (mobile)
• when a realtime Firestore listener sees a change made on another device

That last one is what makes changes appear on your laptop a few seconds after you make them on your phone. The listener is debounced and ignores writes the device itself just made, so it doesn't trigger a sync storm.

A small queue makes sure only one sync runs at a time. If a sync is requested while one is in progress, it's folded into a single follow-up run.

Deletes are tombstones

If you delete a task on your phone while your laptop is offline, the laptop needs to find out about the delete later. A real database delete would leave nothing to find.

So deletes are soft: the task gets a deleted_at timestamp and is synced like any other change. When a device pulls a task with deleted_at set, it removes the task locally. Every device hears about every delete, however long it's been offline.

Conflicts: last write wins

If the same task is edited on two offline devices, which version wins? I use last write wins, based on the task's updated-at timestamp.

There are cleverer approaches, like CRDTs or field-level merging. For a single person's to-do list they're mostly unnecessary. Real simultaneous edits to the same task on two devices are rare, and when they happen, the most recent edit is almost always the one you meant. Simple and predictable beat clever here.

Sign-out wipes the local copy

A local database has one downside: your tasks are stored on the device. On a shared or work computer, the next person to use the browser shouldn't find them.

So on the web, signing out wipes the local database before anything else happens. Sync listeners are stopped first and any in-flight sync is awaited, so a late write can't recreate data after the wipe. If the wipe fails for any reason, the app still signs you out and does a hard navigation, rather than leaving a half-signed-out state.

Subscriptions offline

One more offline detail: a paying user should never be locked out because they're on a plane. The web app caches the last confirmed subscription status on the device and trusts it for up to 14 days without a server check. If there's no cached status at all, the app shows a neutral loading state rather than the paywall. Only a live check can newly lock someone out.

How I test it

Offline behaviour is easy to break without noticing, so it's tested end to end. The web app's test suite runs against local Firebase emulators and checks, among other things, that edits made offline reach the server when the connection returns, that one user's data never appears for another after a sign-out and sign-in on the same browser, and that a cached subscription keeps the app usable offline while a missing cache shows a loading state rather than the paywall.

What I gave up

Offline-first isn't free:

• Complexity. Sync code has to handle partial failures, timestamps in different formats from older data, and records that change during a sync.
• First load. The first time you sign in on a device, it has to pull your whole list before it's fully up to date.
• Storage. Your tasks take up space on each device. For a to-do list that's small, but it's not zero.

For a to-do list, that trade is worth it. The app is fast because nothing waits for a server, and it works wherever you are.

Related reading

• A giant upgrade to Tatask, on moving the web app to Svelte 5
• Why every developer should build a to-do app
• Why you need one list on every device

TL;DR: If your tasks live in a notes app, your inbox, a notebook and two to-do apps, you can never trust that you've seen everything. Pick one list that works on every device you use and moves with you offline. Use the big screen for planning and the phone for capture and quick ticks. Move everything else in over a week, then stop adding to the old places.

Here's a common setup. Work tasks in a project tool. Personal things in the phone's notes app. A few reminders in the calendar. Emails flagged "to do". A notebook on the desk. A sticky note on the fridge.

Each place made sense when you started using it. Together, they mean you can never answer a simple question: what do I need to do?

The real cost of scattered lists

You can't trust any of them

If tasks might be in five places, none of them is complete. Even when you're looking at your main list, part of your mind is wondering about the others. That background worry is the thing a to-do list is supposed to remove.

Things fall through the gaps

The task noted on your phone never makes it to the work list. The flagged email gets buried. The sticky note falls behind the radiator. Most dropped balls happen between systems, not within them.

Planning takes longer

To plan tomorrow properly, you'd have to check every place. In practice, nobody does, so tomorrow's plan is built on part of the picture.

One list, with everything in it

The fix is unglamorous: one list for everything, from work projects to buying bin bags. It can still be organised by area and project, and nesting makes that easy (see tags vs folders for one way to do it). But it's one place, and you only ever add to that place.

For that to work, the list has to be wherever you are.

What each device is good for

Devices aren't interchangeable. Each is better for some jobs.

The computer: planning

A big screen shows more at once. It's the right place for breaking projects down, the weekly review and choosing tomorrow's steps. In Tatask's web app, each opened task appears as a new column, so you can see a whole branch of a project and rearrange it by dragging. That's hard to do on a small screen.

The phone: capture and doing

The phone is always with you, so it's where new things arrive: an idea in the queue at the shop, a request in the corridor. It's also good for working through today's short list and ticking things off. Swipe to complete, star to add to Today.

We've argued before that phones aren't good productivity devices for deep work, and that still holds. As a remote control for your list, they're excellent.

Paper: fine, as an on-ramp

If you like paper for capture or for today's list, keep it. Just move anything written down into the main list at the end of each day, so nothing lives only on a scrap.

What to look for in a list that goes everywhere

It runs on every device you actually use. If you're on Windows at work and Android at home, an Apple-only app won't do. A web app plus phone apps covers most people.

It works offline. Trains, planes, basements, rural Wi-Fi. If the app stops working without a signal, you'll stop trusting it, and you'll start writing things down elsewhere. An offline-first app keeps a full copy of your tasks on each device and syncs when it can.

It syncs quickly. A task added on your phone should be on your laptop by the time you sit down.

It's quick to add to. If capturing takes more than a few seconds, you'll use the notes app instead and you're back to two lists.

One account, one subscription. Having to buy the app separately per platform is a small friction that pushes people towards half-measures.

Tatask was built around these points: a web app, apps for iPhone and Android, a full copy of your list on each device, and one subscription that covers all of them. The offline and sync page explains how it works, and there's a technical write-up for the curious.

Switching to one list

Moving everything over is easier than it sounds if you don't try to do it in one sitting.

Week one

1. Pick the list. Whatever you choose, commit to it for a month.
2. Install it everywhere. Laptop, phone, and work computer if you can.
3. From today, add new things only to the new list.
4. Each evening, move one old source across. Monday the notes app, Tuesday flagged emails, Wednesday the notebook, and so on. Delete or archive as you go.

Week two

5. Do your first weekly review in the new list. It'll show you anything that's still missing.
6. Remove the old routes. Delete the old to-do app, unpin the notes app's "To do" note, stop flagging emails. If the old place is still there, you'll keep using it.

Common objections

"I like keeping work and personal separate"

That's reasonable, and one list doesn't stop you. Make "Work" and "Home" separate top-level branches and you can look at one without seeing the other. What one list removes is the need to check two apps to know what's on your plate. On a Saturday you open the Home branch; on a Monday, Work. During the weekly review you look at both, because your evenings and weekends are shared between them whether you like it or not.

"My employer makes us use a project tool"

Then team tasks belong there, where your colleagues can see them. Your own list can still hold everything else, plus a single task per team project that says "check the project board". The rule is that each task lives in exactly one place, not that everything lives in one app.

"I'm worried about putting personal things in a cloud app"

Check what the app does with your data and whether you can delete your account and everything in it. An offline-first app keeps a copy on your device too, so look for one that clears that copy when you sign out of a shared computer.

"I've tried this before and drifted back"

Usually that's because the old places were still there, or because adding something to the new list took longer than scribbling a note. Remove the old routes, and make sure capture on your phone takes a few seconds: open, type, done.

"Paper works for me"

Then keep paper for today's list, and make the app the master copy. The habit that matters is moving anything written down into the main list at the end of each day.

The payoff

With one list, you stop wondering what you've missed. When everything is in one place and that place is always with you, you can look at it and know you're seeing the whole picture. That's when planning gets quick and the background worry goes quiet.

If you're not sure how to plan from that list, my two-minute planning method quiz suggests a method that fits how you work.

TL;DR: Big tasks get avoided because they're vague, uncomfortable, or both. Make them concrete by breaking them down until the first step is tiny. Lower the bar to "start" rather than "finish". Decide exactly when and where you'll do it. Remove the easy escapes for the first ten minutes. Be kind to yourself when it doesn't work; guilt makes the next attempt harder.

Everyone has a task that has been on their list for too long. The tax return. The difficult email. The chapter you keep meaning to start. You're not lazy: you're probably busy all day, just not with that.

Procrastination on big tasks is common, understandable and fixable. This post looks at why it happens and what helps.

Why big tasks get put off

They're vague

"Write the report" doesn't tell you what to do first. Before you can start, you have to work out what the task involves, and that thinking is invisible, effortful and easy to postpone. Meanwhile "reply to Sam" has no thinking attached, so it wins.

They're uncomfortable

Big tasks often come with feelings: worry about doing them badly, boredom, confusion, or the weight of how much depends on them. Psychologist Tim Pychyl, who has studied procrastination for decades, describes it largely as a way of avoiding those feelings. Putting the task off gives instant relief. The cost comes later.

The reward is far away

Finishing a big task might be months away. Ticking off a small one feels good now. Our brains favour the near reward, so the small tasks keep winning.

Unfinished tasks keep nagging

The longer a big task waits, the more it nags. That makes it more uncomfortable, which makes it more likely to be avoided. It's a loop, and the way out is to start, however small.

What helps

1. Break it down until the first step is tiny

The single most effective fix. Take the big task and break it into parts, then break the first part down again, until the first step is so small it barely counts. "Write the report" becomes:

• Write the report
  • Outline
    • Open a document and write the five section headings
    • Write one sentence under each heading
  • Draft each section
  • Edit

"Open a document and write the five section headings" takes five minutes and needs no courage. Once it's done, the next step is obvious. My guide to breaking down a big project explains the method in full.

2. Aim to start, not to finish

"Work on the report until it's done" is daunting. "Work on the report for 20 minutes" isn't. Lower the bar to starting and let yourself stop when the time's up. Most days you won't want to stop, because getting going was the hard part.

3. Decide exactly when

Research on what psychologist Peter Gollwitzer calls implementation intentions suggests that plans in the form "when X happens, I'll do Y" are much more likely to be acted on than general goals. Instead of "I'll do the tax return this week", decide "On Tuesday after dinner, I'll gather last year's P60 and bank statements".

Put the step on that day's list. In Tatask, star it so it shows in Today, or give it a due date.

4. Do it first

Avoided tasks get harder as the day goes on. Do the first step before you open email. That's the core of Eat the Frog, and it works best when the frog is small.

5. Remove the escape routes, briefly

For the first ten minutes, close email, put your phone in another room and shut unrelated tabs. You don't need a perfect focus setup, just enough friction that drifting off takes effort. My older posts on staying focused and context switching go deeper.

6. Make the discomfort smaller

If a task feels bad because you're worried about doing it badly, give yourself permission to do a rough first version. "Write a bad first draft" is easier to start than "write the report". If it feels bad because it's boring, pair it with something pleasant: good coffee, a nice spot, music.

7. Be kind about slips

Research on self-forgiveness suggests that people who forgive themselves for procrastinating are less likely to do it next time. Guilt adds to the discomfort that caused the avoidance in the first place. If you missed today, plan tomorrow's tiny step and move on.

Quick fixes for specific situations

You don't know where to start. Your first task is to find out. "Spend 20 minutes listing what the report needs to cover" or "Ask Jo how she did hers last year" are real tasks, and they move you forward.

You're waiting until you have a big block of time. Big blocks rarely appear. Do the smallest step in the next 15 minutes you have. Big tasks get done in small pieces more often than in heroic sessions.

You're worried it won't be good enough. Decide in advance that the first version is a draft that nobody will see. Perfectionism is much quieter when the stakes are explicitly low.

It depends on someone else. Send the message that gets them moving, then tag the task #waiting and check on it in your weekly review. You've done your part.

It's genuinely boring. Set a timer for 25 minutes and promise yourself a break at the end. Boring tasks shrink when they have a visible end.

You keep getting distracted. Write the distraction down instead of acting on it, and go back to the task. The thought is safe on the list.

When it's more than procrastination

Sometimes avoiding a task is a signal. If you've put something off for months, ask whether it still matters. If it doesn't, delete it; that's a decision, not a failure. And if procrastination is affecting large parts of your life, alongside low mood or anxiety, it's worth talking to a GP or a professional. A to-do list can't fix everything.

A worked example

Sam has been avoiding redoing their CV for two months. It's on the list as "Update CV".

1. Break it down. "Update CV" becomes: find the current file; list what's changed in two years; rewrite the summary; update the job history; ask a friend to check it.
2. Make the first step tiny. "Find the current CV file and open it." Two minutes.
3. Decide when. Wednesday, 8pm, after dinner.
4. Lower the bar. "Do the first two steps and stop if I want to."
5. Remove escapes. Phone on charge in the kitchen.

On Wednesday, Sam finds the file, lists the changes, and ends up rewriting the summary too, because by then it doesn't feel so bad.

If big tasks are a pattern

If most of your list feels like this, the problem might be how the list is built rather than any single task. How to break down a big project walks through turning one into steps you can start.

For the bigger picture of why breaking things down helps, read the psychology behind task hierarchies and stress-free productivity.

TL;DR: PARA sorts everything into four groups: Projects (have an end), Areas (ongoing responsibilities), Resources (things you're interested in) and Archive (anything inactive). On a task tree, make each area a top-level task, put projects inside their area, and complete or archive projects when they're done. Keep resources in your notes app, not your to-do list.

PARA is an organising system created by Tiago Forte, best known from his book Building a Second Brain. It was designed for notes and files, but it works well for tasks too, and its core distinction, between projects and areas, clears up a lot of to-do list confusion.

The four categories

Projects are short-term efforts with a goal and an end. "Launch the new website by June." "Plan Dad's 70th." "Finish the dissertation." When they're done, they're done.

Areas are ongoing responsibilities with a standard to maintain, but no finish line. Health, finances, home, your job, your relationships. You never complete "finances"; you keep it in good shape.

Resources are topics you're interested in or might need later: recipes, design inspiration, notes on gardening.

Archive is anything inactive from the other three: finished projects, areas you're no longer responsible for, resources you've lost interest in.

Forte's main point is that projects are the most actionable category and should be organised first. Everything else supports them.

Projects vs areas: the useful bit

Many to-do lists mix the two. "Health" and "Run a half marathon" sit side by side as if they were the same kind of thing. They aren't:

• "Health" is a responsibility. It will never be finished.
• "Run a half marathon in May" is a project. It will be finished, on a particular day.

When areas are treated as projects, they never get ticked off and they make you feel behind. When projects are treated as areas, they drift, because nothing marks them as finished. Separating them makes both easier to manage.

A good check: if you can't describe what done looks like, it's probably an area.

PARA on a task tree

A nested to-do list maps onto PARA naturally, because areas contain projects and projects contain steps.

Top level: areas

Make each area a top-level task:

• Work
• Home
• Health
• Money
• Side project

Keep this list short. Five to eight areas covers most lives.

Inside each area: projects

Put each active project inside the area it belongs to.

• Health
  • Run a half marathon in May
  • Book a dentist check-up
• Home
  • Garden ready for a party in July
  • Sort out the loft

Inside each project: steps

Then break each project down until the next step is obvious, as in how to break down a big project.

• Health
  • Run a half marathon in May
    • Pick a training plan
    • Buy proper running shoes
    • Week 1 runs
      • Easy 3k on Tuesday
      • Easy 3k on Thursday
      • 5k on Sunday

Ongoing tasks inside areas

Areas also hold recurring responsibilities that aren't projects: "Pay credit card" monthly inside Money, "Water the plants" weekly inside Home. Make them repeating tasks and they'll come back on their own.

Resources: keep them elsewhere

Resources are information, not tasks. A to-do list full of recipes and articles to read gets cluttered fast. Keep resources in your notes app, bookmarks or a read-later service, and only put a task on your list when there's something to do with it ("Try the lentil recipe on Sunday").

Archive: complete and move on

When a project is finished, complete it. In most apps, completed tasks move out of the way, and in Tatask they go to the Archive view, which is PARA's fourth category built in. When an area stops being your responsibility (you sell the car, leave the job), complete or delete the whole branch.

Using tags alongside PARA

PARA gives every task one home. Sometimes you want to see tasks across areas: every phone call, every errand, everything you're waiting on. That's what tags are for. A few cross-cutting tags (#calls, #errands, #waiting) sit happily alongside PARA's structure. I explain the split in tags vs folders.

A complete example

Here's what a full PARA tree might look like for someone with a job, a home and a running hobby. Only the active projects are broken down; everything else stays rough.

• Work
  • Q3 report for the board
    • Pull revenue numbers from finance
    • Draft the summary
    • Review with Alex on Thursday
  • Hire a junior designer
    • Write the job description
    • Post the role
  • Send weekly update to the team (repeats every Friday)
• Home
  • Garden ready for a party in July
    • Order tile samples
    • Measure the patio
  • Water the plants (repeats every Sunday)
• Health
  • Run a half marathon in May
    • Week 3 runs
  • Book a dentist check-up
• Money
  • Pay credit card in full (repeats on the 1st)
  • Switch energy supplier
• Someday
  • Learn to make sourdough
  • Plan a trip to Japan

Five areas, seven active projects, a handful of repeats and a short Someday list. Resources, such as running plans, the job description template and sourdough recipes, live in the notes app, with links from tasks where needed.

Notice what isn't here: no "Health" project with no end, and no area cluttered with articles to read. Everything in the tree is either something to do or a container for things to do.

Daily use

PARA organises the list, but it doesn't tell you what to do today. Each evening or morning, pick a few next steps from your active projects and put them on a daily list. In Tatask, starring a task adds it to Today without moving it out of its project. See how to plan your day for the routine.

Weekly upkeep

During your weekly review, add three PARA checks:

1. Are any projects finished? Complete them.
2. Are any projects really areas? If something has no end, move its tasks into the area and delete the "project".
3. Is any area missing a project it needs? If an area feels neglected, maybe it needs a small project to get it back in shape.

Does PARA suit you?

PARA suits people with several areas of life that each have ongoing projects, and people who already organise their notes and files this way and want their tasks to match. If you mostly struggle with daily focus rather than organisation, a lighter method like the Ivy Lee method may help more. PARA also pairs well with Getting Things Done: GTD handles the flow of tasks, PARA handles where they live.

Set it up in fifteen minutes

1. Write down your five to eight areas.
2. Under each, list the projects that are active right now. Move the rest to a "Someday" task.
3. For each active project, add the next step.
4. Put resources in your notes app.

That's enough to start. The structure will settle as you use it.

TL;DR: Ask two questions of each task: is it important (does it matter for my goals)? Is it urgent (does it need doing now)? Important and urgent: do it. Important, not urgent: schedule it, and protect that time. Urgent, not important: delegate or batch it. Neither: delete it. Most people's problem is that the second quadrant never gets done.

The Eisenhower matrix is named after Dwight D. Eisenhower, who in a 1954 speech quoted a former college president: "I have two kinds of problems, the urgent and the important. The urgent are not important, and the important are never urgent." Stephen Covey turned the idea into a four-box grid in The 7 Habits of Highly Effective People, and it's been a staple of time management ever since.

It's popular because it names a problem nearly everyone has: the urgent crowds out the important. This guide shows how to use it in practice, without drawing boxes every morning.

The four quadrants

Every task gets two yes-or-no questions.

• Important? Does it move you towards something you care about: your goals, your work's purpose, your health, your people?
• Urgent? Does it need doing now, or very soon, or there'll be a consequence?

That gives four boxes.

1. Urgent and important: do it

A client deadline today. A burst pipe. A sick child. These need attention now, and they matter. You don't need a method to tell you to do them.

2. Important, not urgent: schedule it

Planning next quarter. Learning a skill. Exercise. Seeing friends. Fixing the process that causes the crises in box 1. None of these will shout at you, which is why they don't get done.

This is the box the matrix exists for. Covey argued that effective people spend most of their time here, and that time spent here shrinks box 1 over time, because planned work causes fewer emergencies.

3. Urgent, not important: delegate or batch it

Most emails. Many meetings. Requests that are urgent to someone else but don't move your work forward. They feel important because they're loud.

If you can hand them to someone else, do. Most people can't, so the practical move is to batch them: deal with them together, at a set time, as quickly as possible.

4. Neither: delete it

Busywork, tasks that stopped mattering weeks ago, things you're doing out of habit. Delete them. If deleting feels wrong, ask what would actually happen if you never did it. Usually nothing.

Using it day to day

Drawing a grid every morning gets old fast. Here's a lighter way to apply the same thinking with an ordinary to-do list.

Use dates for urgency

Give a task a due date only when there's a real deadline. Then urgency is visible: anything in your Due list today is urgent by definition. Avoid fake dates ("I'd like to do this Thursday"), or the Due list stops meaning anything. In Tatask, the Due view shows overdue, today and upcoming tasks across all your projects.

Use your daily list for importance

When you plan tomorrow, choose a few tasks that matter, even if nothing is forcing them. That's how box 2 gets time. If your daily list is only ever made of things that are due, you're living in boxes 1 and 3. A Today list you fill on purpose, separate from what's due, keeps them apart.

Batch box 3

Set one or two short slots a day for email and small requests. Outside those slots, write new requests down instead of doing them.

Delete during the weekly review

Box 4 tasks hide in long lists. Your weekly review is the time to find and delete them.

An example

It's Monday. Here's what's on the list:

• Finish the client proposal (due Wednesday)
• Reply to 40 unread emails
• Book the car service (MOT expires in three weeks)
• Plan the Q4 marketing calendar (nobody's asked for it yet)
• Reorganise the shared drive folders
• Go for a run
• Fill in the expenses form (due Friday, five minutes)

Sorted:

• Do: finish the client proposal (due Wednesday, matters).
• Schedule: plan the Q4 calendar (block two hours on Tuesday morning), go for a run (Monday, Wednesday, Friday at lunch), book the car service (it's not urgent yet, but will be; do it this week).
• Batch: emails (twice a day, 30 minutes each), expenses form (in the email slot on Thursday).
• Delete: reorganise the shared drive. Nobody's asked for it, and it won't change anything.

Monday's list: proposal first, run at lunch, emails in two slots. The Q4 plan has a protected slot on Tuesday instead of waiting until it becomes an emergency.

A weekly version

Sorting tasks daily works, but the matrix is most useful once a week, during your weekly review. Look at everything on your list and ask:

1. What in box 2 will I protect time for this week? Pick one or two things, and put them in your calendar like meetings.
2. What's likely to become urgent? Anything due in the next fortnight that needs preparation should be started now, while it's still box 2.
3. What's in box 3 that I can stop doing? Unnecessary meetings, reports nobody reads, notifications you don't need.
4. What can I delete? Every list has tasks that quietly stopped mattering.

Done weekly, the matrix shifts your time towards box 2 gradually, which is how box 1 shrinks. Fewer things become emergencies when they're handled before they're urgent.

Common traps

Calling everything important

If every task is important, none is. Be honest: important means it connects to a goal you actually have. Being asked for something doesn't make it important.

Confusing urgency with stress

Some tasks feel urgent because you're anxious about them, not because of a deadline. Ask what actually happens if it waits until tomorrow. If the answer is "nothing", it's not urgent.

Never getting to box 2

The classic failure. You agree that planning and learning matter, then spend every day on boxes 1 and 3. The fix is to schedule box 2 work like a meeting, and do it first. Eat the Frog is one way to make that a habit.

Using it once and forgetting it

The matrix works best as a question you ask by habit. After a few weeks of asking "important? urgent?", you'll do it automatically when new tasks arrive.

When it isn't the right tool

The matrix is great for deciding what to do. It says little about how to do big things. If your important tasks keep stalling because they're too big to start, pair it with a breakdown approach: see how to break down a big project.

If you're not sure the matrix suits how you work, my planning method quiz compares it with four other approaches. And if you want a fuller system, Getting Things Done with a task tree covers one that includes the same ideas.

TL;DR: Make anything that comes round on a schedule into a repeating task, so it reappears when it's due and you can stop remembering it. Match the repeat to the real rhythm (weekdays for weekly jobs, dates for monthly ones). Keep daily repeats to a minimum, review your repeats every few months, and put a weekly review on repeat first.

A surprising amount of mental effort goes on things that happen again and again. Bins go out on Tuesday. Rent leaves on the 1st. The car needs servicing every March. The plants need watering on Sunday. None of them are hard, but each one is a small thing to remember, and together they add up to a low hum of "don't forget".

Recurring tasks take that hum away. Set each one up once, and your list brings it back when it's due.

What belongs on repeat

The test is simple: does it come round on a schedule, and would I otherwise have to remember it?

Good candidates:

Poor candidates:

• Things you already do without thinking. Brushing your teeth doesn't need a reminder.
• Vague intentions. "Exercise more" isn't a task. "Run 5k" on Tuesday and Saturday is.
• Things with no real schedule. If it's "whenever I get round to it", it belongs on your normal list.

Matching the rhythm

Most apps offer a few repeat patterns. Use the one that matches how the job actually works.

Daily is for genuinely daily things. Use it sparingly, or your list fills with the same items every morning and you start ignoring them.

Weekly, on chosen days suits anything tied to the weekday: bins, classes, a weekly call.

Monthly, on chosen dates suits anything tied to the calendar: bills, rent, invoices. You can pick more than one date, such as the 1st and the 15th.

Yearly suits renewals, services and birthdays. These are the ones people forget most, because a year is long enough to lose track completely.

In Tatask all four are available on any task, at any depth in your project tree. When you complete a repeating task, it comes back as open on its next date, and the Due view lists everything that's overdue, due today or coming up.

Five rules for routines that last

1. Start with the weekly review

If you set up only one repeating task, make it a weekly review: twenty minutes, same time each week, to look at everything. It's the routine that keeps every other routine honest. See how to do a weekly review.

2. Put the steps inside

A repeating task can have subtasks. "Weekly review" can contain "clear inboxes", "walk projects" and "plan Monday". "Monthly money check" can contain "check statements", "move savings" and "pay credit card". The checklist comes back with the task every time.

3. Set it for when you'll actually do it

A repeat that lands on a day you can't act on it is noise. If you do the food shop on Saturdays, the meal plan belongs on Friday, not Monday.

4. Keep daily repeats few

Five daily repeats means five items every single day before you've added anything new. That's where lists start to feel like nagging. Keep daily repeats for the one or two things you truly forget, and track other habits somewhere else if you need to.

5. Review your repeats every few months

Life changes. The gym class moves, the subscription gets cancelled, the plant dies. Every three months or so, look through your repeating tasks and delete or adjust the ones that no longer fit. A stale repeat trains you to ignore the list.

A starter set to copy

Here's a set that suits a lot of people. Take the ones that apply, change the days, and ignore the rest.

Weekly

• Friday: weekly review
• Sunday: plan meals and write the shopping list
• Sunday: water the houseplants
• Bin day: put the bins out

Monthly

• 1st: check rent or mortgage went out
• 1st: pay credit card in full
• 15th: back up phone photos

Every three months (set four yearly repeats, or a monthly one you skip)

• Back up laptop
• Test smoke alarms

Yearly

• Car insurance renewal (two weeks before the date)
• Car service and MOT
• Boiler service
• Birthdays you'd hate to miss (a week before, so there's time to buy something)

Notice the yearly ones are set before the deadline. A reminder on the day you need to renew is a reminder that you're late.

Repeating tasks inside projects

Repeats don't have to sit at the top level. Put them inside the project they belong to. "Water the lavender" can live inside "Garden" and repeat weekly through the summer. "Send monthly report" can live inside the client project it's for. You'll see it in the Due list when it's due, and in its project when you're working there.

Routines and the daily list

A repeating task tells you when something is due. It doesn't mean you'll do it that day. When planning tomorrow, look at what's due and decide: do it, or move it. Due dates and daily choices are different jobs, and keeping them separate stops your daily list turning into a pile of overdue chores. More on that in how to plan your day.

Recurring tasks vs habit trackers

Habit-tracking apps and recurring tasks overlap, but they do different jobs. A habit tracker counts streaks: how many days in a row you meditated or read. A recurring task makes sure something gets done when it's due, without reminding you of every day you missed.

For things you want to do every day as a habit, a tracker or a simple calendar tick may suit you better. Your to-do list stays focused on things that need doing, and doesn't fill up with the same seven daily items.

For things that need doing on a schedule, whether or not you feel like it (bills, bins, renewals, reviews), recurring tasks are the right tool. They come back when due, sit in your Due list until done, and then go away until next time. Nobody needs a streak counter for putting the bins out.

A useful split: habits about who you want to become go in a tracker or a journal; chores and commitments with a schedule go on the list.

Getting started

Tonight, set up three repeats:

1. A weekly review on Friday.
2. The household job you most often forget.
3. The yearly renewal that would hurt most if you missed it.

Next week, add another three if those are working. Within a month most of the regular stuff will be off your mind and on your list, where it belongs.

TL;DR: Pick the one important task you're most likely to avoid, make it small enough to finish in a morning, and do it before anything else. It works because the worst part of the day is over early and the rest feels easier. It backfires when the frog is too big, when every task is a frog, or when your best hours aren't the morning.

"Eat a live frog first thing in the morning, and nothing worse will happen to you the rest of the day." It's usually credited to Mark Twain, though there's no solid evidence he said it. Brian Tracy turned it into a book, Eat That Frog!, in 2001, and the phrase stuck.

The idea is simple: your frog is the task you least want to do and most need to. Do it first. Once it's done, the rest of the day is downhill.

Why it works

Avoidance gets worse as the day goes on

A dreaded task doesn't get easier at 3pm. It gets harder, because you're tired, the day has filled with other things, and you've spent hours aware of not doing it. Doing it first removes all of that.

Mornings are protected time (for many people)

Early in the day, fewer people need you, your inbox hasn't taken over yet, and your attention is fresher. That's the best time for work that needs effort.

Momentum

Finishing the hardest thing early gives you a sense of progress that carries through the day. Everything after it feels like a bonus.

How to do it

1. Choose the frog the night before

In the evening, look at your list and ask: which task would make the biggest difference, and which am I most likely to put off? Often it's the same one. That's your frog.

Choosing the night before matters. If you choose in the morning, you'll talk yourself into an easier one.

2. Make it swallowable

A frog that can't be finished in one sitting is a project, not a frog. "Write the business plan" will defeat you. "Draft the competitor section of the business plan" won't.

If the frog is big, break it down and make the first concrete step the frog. My guide to breaking down a big project shows how. Small enough means you could finish it before lunch, ideally in an hour or two.

3. Do it before anything else

Before email, before messages, before the news. Open the task and start. If you need a ritual, keep it short: coffee, sit down, start.

4. Put it somewhere you can't miss

Write it on a sticky note or put it at the top of your daily list. In Tatask, star it so it's in Today and drag it to the top. When you open the app in the morning, it's the first thing you see.

How to pick the right frog

Choosing the frog is the skill. A few questions help:

• Which task, if done, would make the rest of the week easier? Often it unblocks other work or other people.
• Which task have I moved from one day to the next more than twice? Repeated carrying-over is the clearest sign of avoidance.
• Which task would I be relieved to have finished? Relief is a good detector of dread.

Some examples of good frogs:

• "Write the first paragraph of the funding application" (not "do the funding application")
• "Call the bank about the missing payment"
• "Give Sam feedback on the presentation"
• "Draft the email declining the project"

And some poor ones:

• "Clear my inbox" (busy, not important)
• "Plan the year" (too big for one morning)
• "Tidy the desk" (pleasant avoidance dressed up as work)

If two candidates seem equal, pick the one with an external consequence: someone waiting, a deadline approaching, money at stake. If no task feels like a frog this week, enjoy it; the method isn't meant to manufacture dread.

When it backfires

Eat the Frog is good advice for a specific problem. Applied to the wrong one, it causes trouble.

When every task is a frog

If your list is full of dreaded tasks, choosing one each morning won't fix it. That's a sign of something bigger: too much on, unclear priorities, or work that doesn't suit you. A weekly look at everything, like the weekly review, is a better starting point.

When the frog is too big

The most common failure. You start the huge task, make little progress by lunchtime, and feel worse than if you hadn't started. The fix is always the same: make the frog smaller.

When your best hours aren't the morning

The method assumes morning is your peak. If you do your best work at 2pm or 10pm, eat the frog at the start of those hours. The principle is to do the important thing before the day fills up, whenever your day really starts.

When the morning isn't yours

If you have a 9am stand-up and back-to-back meetings until 11, you can't do the frog first. Do it in the first free block of an hour or more, and protect that block in your calendar.

When it becomes a source of guilt

Some days the frog won't happen. A child is ill, something breaks, a deadline moves. If you miss it, carry it to tomorrow and move on. A method that makes you feel bad on bad days won't last.

Eat the Frog with other methods

It combines well with others:

• With the Ivy Lee method: make the frog item number one on your list of six. See the Ivy Lee method.
• With GTD: choose your frog from your next actions during daily planning. See Getting Things Done with a task tree.
• With the Eisenhower matrix: frogs usually live in the "important but not urgent" box, which is exactly where things get neglected. See the Eisenhower matrix guide.

A note on procrastination

Eat the Frog is a procrastination fix, but it only treats one kind: avoiding something you know you should do. If you're stuck because you don't know where to start, or because the task makes you anxious, it helps to understand why first. How to stop procrastinating on big tasks goes into that.

Try it this week

For five working days:

1. Each evening, choose tomorrow's frog. One task.
2. Make sure it can be finished in a morning. If not, shrink it.
3. Start it before you open email.

At the end of the week, ask whether the days felt different. Most people find the afternoons feel lighter, because the thing hanging over them is already done.

Want to know whether Eat the Frog is the right method for you? My planning method quiz takes two minutes.

TL;DR: Folders (or a task tree) answer "what is this part of?", and every task has exactly one home. Tags answer "when do I want to see this?", and a task can have several. Use structure for projects and tags for things that cut across projects, such as place, tool or waiting on someone. Keep the tags list short.

Every to-do app eventually asks you to decide how to organise things. Some lean on folders and projects. Some lean on tags and filters. Many offer both and leave you to work out which to use where.

Get it wrong and you end up with forty tags you never use, or a deep folder structure where you can never find the thing you need. Get it right and the list mostly organises itself.

The difference in one line

• A folder says what a task belongs to. Each task has one home.
• A tag says when you'll want to see a task. Each task can have several.

Everything below follows from that difference.

When folders (or a tree) are right

Use structure when the relationship is "part of". A task to order tile samples is part of choosing tiles, which is part of redoing the patio, which is part of the garden project. That chain is real and it matters. Finishing all the parts finishes the whole.

Folders and trees are good at:

• Breaking work down. The structure shows how pieces add up.
• Seeing progress. You can tell how much of a project is done.
• Hiding what you're not working on. Everything inside a closed folder is out of sight.

Their weakness is that everything has exactly one home. A phone call about the garden lives in the garden project, and a phone call about the car lives in the car project. On Saturday morning, when you want to make all your calls, you have to go hunting.

When tags are right

Use tags when the relationship is "this is also a…". The garden call and the car call are in different projects, but they're both calls. Tag them #calls and you can see every call in one place, while each still lives in its own project.

Tags are good at:

• Places and tools: #home, #office, #errands, #computer. What can I do where I am right now?
• Kinds of work: #calls, #emails, #writing, #admin. Batch similar jobs together.
• Status: #waiting for anything stalled on someone else.
• Energy or time: #quick, #deep, for matching tasks to how you feel.

Their weakness is that they don't show how things add up. A tag can't tell you a project is 70% done, and a pile of tags isn't a plan.

The mistake most people make

The common failure is using one tool for both jobs.

All folders. Every way of slicing the list becomes a folder, so you get "Work", "Work / Calls", "Home / Calls", "Calls / Urgent". Tasks get duplicated across folders or lost in the wrong one.

All tags. Projects become tags too, so a task might be #garden #patio #tiles #weekend #errands. Now there's no structure, nothing adds up, and every task needs five decisions before you can write it down.

A simple setup that uses both

1. Use structure for projects. Every project is a folder or, in a tree-based app, a parent task. Its steps live inside it. Big projects have sub-projects.
2. Use a handful of tags for things that cut across projects. Start with three or four, such as #calls, #errands, #waiting and #home.
3. Add a tag only when you've wanted it twice. If you find yourself thinking "I wish I could see all my X", that's a tag. If you're inventing tags in advance "just in case", stop.
4. Delete tags you don't use. Once a month, look at your tags. If you haven't opened one's view, remove it.

This maps neatly onto David Allen's Getting Things Done, where projects hold next actions and "contexts" (calls, computer, errands) are separate lists. In a modern app, contexts are just tags. There's more on this in Getting Things Done with a task tree.

Hashtags: the low-friction version

The least effort way to tag is to type the tag into the task itself: "Call the plumber about the boiler #calls #home". No menus, no tag picker, no setup screen. The tag exists as soon as you type it.

This is how tags work in Tatask. Any word starting with # becomes a tag, and each tag gets its own view listing every task with it, across every project. There's more on the tags feature page. The low friction matters: if tagging takes three taps, you'll stop doing it within a week.

What about PARA?

Tiago Forte's PARA method (Projects, Areas, Resources, Archive) is a folder system designed mainly for notes and files. It works well alongside a to-do list, and the "Projects" and "Areas" parts map onto a task tree directly. I wrote about running PARA on a task tree.

What this looks like for different people

A freelancer might have a folder (or parent task) per client, with each client's jobs inside. Tags handle what cuts across clients: #invoices for billing, #calls for the phone, #waiting for anything stuck on a client's reply. On Friday afternoon, the #invoices view shows every bill to send, from every client, on one screen.

A student might have a parent task per module, with coursework inside. Tags cover places and modes: #library for things that need the library, #reading for reading lists, #group for anything involving a group project.

Someone running a household might have branches for Home, Car, Money and Family. Tags cover where things happen: #errands for things to pick up when out, #online for things to do from a laptop, #weekend for jobs that need a free Saturday.

In every case the structure answers "what is this for?", and the tags answer "when can I do it?". The tags list stays under ten.

A quick audit of your current list

If your list feels disorganised, try this:

1. Count your tags. More than ten? Pick the five you use and delete the rest.
2. Look for tags that are really projects. If a tag only ever appears inside one project, it's not cutting across anything. Remove it; the project already groups those tasks.
3. Look for folders that are really tags. If you have "Calls" folders in three places, replace them with one #calls tag.
4. Check your projects have structure. If a project is a flat list of twenty items, group them into three to five parts.

Ten minutes of this usually leaves a list that's easier to read and quicker to add to.

The rule of thumb

If finishing all of them would finish something bigger, use structure. If they just have something in common, use a tag.

For more on keeping a list that works, my older post your to-do list sucks covers the other ways lists go wrong.

TL;DR: Start with three to five meaningful tasks a day, plus small fixed jobs grouped into one item. Count how many you actually finish for a week, then plan to that number. Leave room for interruptions, make tasks small enough to finish, and keep the rest of your list out of sight.

There's a particular feeling at six o'clock when today's to-do list still has eleven items on it. You worked hard all day. You're tired. And the list says you failed.

Usually the list is the problem, not you. Most people plan far more than a day can hold, then feel bad about the gap every evening. Getting the number right is one of the simplest changes you can make, and it changes how the whole day feels.

Why we overplan

Two things push us towards long lists.

We underestimate how long tasks take. This is so common it has a name, the planning fallacy, first described by Daniel Kahneman and Amos Tversky. We imagine the task going smoothly and forget the interruptions, the false starts and the bit we didn't know about. Studies since have found it holds even when people have done the same task before.

We forget about everything that isn't on the list. Meetings, messages, lunch, the colleague who needs five minutes, the email that turns into an hour. A typical knowledge worker has far less uninterrupted time in a day than the hours on their contract suggest.

Put those together and a plan that looks reasonable at 9am is fiction by 11.

A good starting number

For most people, three to five meaningful tasks is a good starting point. "Meaningful" here means a task that moves something forward and takes real attention: drafting a section, designing a page, preparing a presentation, fixing a bug.

On top of that, you'll have small fixed jobs: pay an invoice, book an appointment, reply to a few emails. Group these into one line ("admin: invoices, dentist, emails to Jo and Sam") so they don't crowd the list.

Some well-known methods land in the same range:

• The Ivy Lee method uses six, ranked.
• The 1-3-5 rule suggests one big task, three medium and five small.
• Eat the Frog focuses on just one, done first.

They all agree on the principle: a short list, chosen on purpose.

Find your real number

Rather than trust a rule, measure. For one week:

1. Plan your day as normal.
2. At the end of the day, count how many meaningful tasks you finished.
3. Write the number down.

After five days, take the average. That's your real daily capacity right now. Plan to that number, or one less, for the next fortnight.

Most people find the number is lower than they expected, often by half. That's not a sign you're slow. It's a sign your days have more interruptions than your plans allow for.

Make tasks finishable

The other half of the problem is task size. If one item on your list is "write the report", you can work on it all day and still not tick it off. The list feels as long at 6pm as it did at 9am.

Break big work into steps you can finish in one sitting: "draft the summary", "pull Q2 numbers", "write the recommendations section". Now the same day's work produces three ticks instead of zero, and you can see your progress. My guide to breaking down a big project shows how.

Leave slack

A day with no slack breaks at the first surprise. Plan roughly 60 to 70% of your available time and let the rest absorb whatever comes up. If nothing does, you finish early and choose another task, which feels much better than the reverse.

Keep the rest out of sight

A short daily list only helps if you look at it instead of the full list. Your full list might have a hundred items across every project. Looking at it while you work keeps reminding you how much isn't getting done.

Keep two things separate:

• The full list: everything, organised by project.
• Today's list: the three to five you chose.

During the day, only look at today's list. In Tatask that's the Today list: star the tasks you've chosen and they appear on their own, wherever they live in your projects. On the web, the count beside the star tells you how many are left.

What about urgent tasks that appear mid-day?

Write them down. Then ask whether it really has to happen today. Most "urgent" things can wait until tomorrow's plan. If it can't, swap it in and drop something else, so the list stays the same length. Adding without removing is how a plan for five becomes a list of nine.

A worked example

Priya is a product designer. Her usual daily list has nine items, and she finishes four or five. Every evening she moves the rest to tomorrow and feels behind.

For one week she counts what she actually finishes: 4, 5, 3, 5, 4. Her average is a little over four, so she plans four meaningful tasks a day for the next fortnight, plus one admin line.

She also notices that two of her usual items are too big. "Redesign onboarding" appears on her list most days and never gets ticked off. She breaks it into "sketch three options for the welcome screen", "review options with Tom" and "build the chosen option in Figma". Now it produces a tick most days, and she can see it moving.

By the end of the fortnight she finishes her four most days, and on good days adds a fifth. She ends the day with fewer unfinished items than before, despite planning less, because the list now matches the day she actually has. Her output hasn't dropped either: the tasks she drops from the plan were mostly the ones that used to roll over anyway.

The lesson isn't that four is the magic number. It's that her number, measured honestly, was lower than her ambition, and planning to it made the days calmer.

Signs you've got the number right

• You finish your list most days.
• When you don't, it's because something unusual happened, not because of the plan.
• You end the day knowing what you got done rather than what you didn't.
• The number creeps up over time as tasks get better defined and you protect your focus.

That last one is worth noticing. Capacity isn't fixed. Fewer context switches, clearer tasks and a protected first hour all raise it. But you get there by planning honestly to today's number, not by writing tomorrow's ambitions on today's list.

Try it

Tonight, plan tomorrow with exactly three meaningful tasks and one admin line. Do them in order. If you finish early, add one more. At the end of the week, see how it felt compared with your usual list. For the bigger routine around this, read how to plan your day.

TL;DR: A work breakdown structure (WBS) is a tree of everything a project involves, from the outcome down to small, concrete pieces. Two rules from project management are worth borrowing: each level must add up to its parent (the 100% rule), and break down by deliverables (things) rather than activities where you can. For personal projects, keep going until the pieces fit in a single sitting.

If you've ever worked on a large project at work, you may have seen a work breakdown structure: a diagram of boxes branching down from the project name into smaller and smaller pieces. Project managers have used them for decades to plan construction, software and defence projects.

The idea is too useful to leave to project managers. A WBS is just a disciplined way of breaking a big thing into small things, and a couple of its rules fix the most common mistakes people make when planning personal projects.

What a WBS is

A work breakdown structure is a hierarchy. At the top is the whole project, described as an outcome. Below it are the major pieces of work. Each of those is broken into smaller pieces, and so on, until the pieces at the bottom are small enough to estimate, assign and do.

The bottom-level pieces are traditionally called work packages. In a personal to-do list, they're your actual tasks.

A WBS says what the work is. It doesn't say when or in what order. Scheduling is a separate step, which is part of why WBS planning feels less overwhelming than drawing up a timeline.

Two rules worth borrowing

The 100% rule

Each level of the breakdown must account for 100% of the work in the level above, and nothing more. If you complete every child of a task, the task is complete. If something's left over, a child is missing.

This rule catches the gaps that sink personal projects. Planning a wedding, you list venue, food, music and outfits, and only find out a month before that nobody's done invitations. Checking each level against the 100% rule ("if I do all of these, is the parent done?") surfaces the missing piece early.

It also stops scope creep. If a child doesn't contribute to its parent, it doesn't belong there. Move it to its own project or drop it.

Break down by things, not activities

Project managers prefer to break work down by deliverables (things that will exist) rather than activities (things you'll do), at least at the upper levels.

Compare these for a home office:

By activity:

• Research
• Buy things
• Install things
• Tidy up

By deliverable:

• Desk area
• Lighting
• Storage
• Cable management

The deliverable version is easier to check against the 100% rule and easier to track. You can see that "lighting" is done; "research" is never really done. At the lowest level, tasks naturally become activities ("measure the alcove", "order the lamp"), and that's fine.

How small should the pieces be?

Formal project management often uses the 8/80 rule: work packages should take between 8 and 80 hours. That's for teams on large projects where tracking hundreds of tiny tasks would be overhead.

For personal projects, go much smaller. A good bottom-level task:

• starts with a verb
• has a clear end point
• fits in one sitting, ideally under an hour

The reason is different from the corporate one. At work, the aim is estimation and assignment. At home, it's getting started. A task you can finish in one evening is a task you'll actually start on a Tuesday night. I covered that side of it in how to break down a big project.

Worked example: a home office

Outcome: A home office I can work in all day by the end of next month

• Desk area
  • Choose a desk that fits the alcove
    • Measure the alcove
    • Shortlist three desks under £300
  • Order the desk
  • Assemble the desk
• Chair
  • Try two chairs in a shop
  • Order the chair
• Lighting
  • Order a desk lamp
  • Swap the ceiling bulb for a daylight bulb
• Storage
  • Clear the shelf above the radiator
  • Order two magazine files
• Cable management
  • Order a cable tray
  • Fit the cable tray under the desk

Check the 100% rule at the top level: if the desk area, chair, lighting, storage and cables are all done, is the office ready to work in all day? Probably, but there's no mention of internet. Add "Network": "Test wifi speed at the desk" and, if it's poor, "Order a powerline adapter". The rule caught a gap before it became a problem.

From WBS to a to-do list

On paper, a WBS is a box diagram. As a to-do list, it's a tree: every box is a task, and its children are subtasks. Any list that allows nesting works.

Once it's a tree, the scheduling questions get easier:

• What's next? Pick the next unfinished task on the branch you're working on.
• What's today? Choose a few bottom-level tasks and put them on today's list. In Tatask you'd star them so they appear in Today.
• What has a deadline? Put due dates on the tasks that have them, at whatever level they belong.
• How far along am I? Count finished children. Tatask shows this as a ring on each parent task, so you can see that "Desk area" is two-thirds done without opening it.

From breakdown to schedule

Once the tree exists, you can turn it into a rough plan in three steps.

1. Mark dependencies. Some tasks can't start until others finish. You can't assemble a desk you haven't ordered. Note these, either by putting dependent tasks in order within a branch or with a #waiting tag.
2. Date the fixed points. Anything with a real deadline (a delivery slot, a booking) gets a due date. Leave everything else undated.
3. Choose this week's tasks. From the branches that can move, pick the next few tasks for this week. Don't schedule the whole project. Schedules for personal projects go stale within days; a fresh weekly choice doesn't.

This keeps the WBS useful as the project changes. When a new task appears, it goes into the tree where it belongs. When plans change, you choose differently next week. The tree stays the source of truth for what the work is, and your weekly and daily lists decide when.

When to use a formal WBS

For most personal projects, a quick breakdown is enough. The WBS rules earn their keep when:

• the project is big enough that missing a piece would hurt (a house move, a wedding, a product launch)
• other people are involved and need to see the whole shape of the work
• you keep finding surprise tasks late in the project

In those cases, spend twenty minutes building the tree properly, checking each level against the 100% rule. Then stop planning and start on the first task.

Further reading

• How to break down a big project, my main guide to breakdowns
• Task management for the digital age, on why hierarchical lists suit modern work
• Breaking down complex projects, with strategies for larger work projects
• The nested tasks feature page, for how this works in Tatask

TL;DR: Once a week, spend twenty minutes in three parts. Clear (5 minutes): get everything new into your list. Review (10 minutes): walk every project, close what's done, make sure each has a small next step. Plan (5 minutes): pick next week's priorities and choose Monday's first steps. Make it a repeating task so it comes back on its own.

Every to-do list works brilliantly for about two weeks. Then new things arrive faster than you file them, finished projects linger, and half the items no longer mean anything. You stop trusting the list, and once you don't trust it, you start carrying things in your head again.

A weekly review is the fix. It's a short, regular session where you look at everything and bring your list back in line with reality. David Allen made it famous in Getting Things Done and called it the key to the whole system. You don't have to use GTD to benefit from it.

What a weekly review is for

It does three jobs:

1. Catch what's slipped through. Notes, emails, promises made in passing. They all land somewhere during the week. The review gets them into one place.
2. Keep projects moving. A project without a clear next step stalls quietly. The review checks every project has one.
3. Set up next week. You start Monday with a plan instead of an inbox.

Daily planning picks tomorrow's few steps. The weekly review makes sure there are good steps to pick. If you only do one of the two, do the review.

The twenty-minute review

Part 1: Clear (5 minutes)

Collect everything that's arrived this week and isn't on your list yet:

• Notes in your phone, notebook or sticky notes
• Screenshots and photos taken as reminders
• Emails that need an action (add the action as a task; you can leave the email where it is)
• Anything still in your head: promises, worries, ideas

Don't organise it. Just get it onto the list. If something takes under two minutes, do it now instead.

Part 2: Review (10 minutes)

Walk through your projects one by one. For each:

• Tick off anything you've done but haven't marked.
• Delete anything that no longer matters. This is the most underrated part of the review. A list full of dead tasks is a list you won't trust. Deleting without guilt is a skill.
• Check the next step. Is it clear and small? If it's vague ("work on proposal"), break it down until it starts with a verb and fits in one sitting.
• Check what you're waiting on. If you've been waiting on someone for a week, the next step might be a nudge.

Then look at dates:

• Glance back over the last week in your calendar. Anything that needs follow-up?
• Look ahead two weeks. Anything that needs preparation now?
• Check your Due list for anything overdue or coming up.

Part 3: Plan (5 minutes)

• Choose three priorities for next week. Not everything you'll do, just the three that would make it a good week. Write them down or star their next steps.
• Choose Monday's first steps. So Monday morning starts with a decision already made, as in daily planning.

That's it. Close the laptop.

Making it stick

The review only works if it happens most weeks. A few things help.

Same time, same place

Pick a slot and protect it. Friday at 4pm works well: the week is fresh in your mind and the weekend starts clean. Some people prefer Sunday evening with a cup of tea. Choose whichever you'll actually do, and put it in your calendar.

Make it a repeating task

Add "Weekly review" as a task that repeats every week on your chosen day. It'll reappear when it's due, so you don't have to remember it. In Tatask, set a weekly repeat on Friday, and keep the steps as subtasks so the checklist is built in. Our post on recurring tasks and routines has more on this.

Use a checklist

For the first few weeks, a checklist stops you skipping steps. Write the three stages on a card and pin it near your desk until you don't need it.

Keep it short

If your review takes an hour every week, something's off. Usually it means too many projects, or projects that are too vague. Trim the list, move things to "someday", and keep the review to twenty minutes. A short review you do beats a thorough one you skip.

Don't do the work during the review

It's tempting to start fixing things as you find them. Resist, except for two-minute jobs. The review is for deciding, not doing. Write down what needs doing and get on with it on Monday.

A worked example

Here's what a real Friday review might look like for someone with a job, a house and a side project.

Clear (4 minutes). Three notes on the phone ("ask Jo about holiday dates", "book bike service", "idea: newsletter for side project"). Two emails needing replies. One worry: the car insurance renewal. All six go on the list.

Review (11 minutes).

• Work: the quarterly report's next step was "work on the report". Broken down into "draft the summary section" and "pull Q2 numbers from finance". A meeting follow-up that never happened is deleted, because the decision was made anyway.
• Home: the garden project has been stuck for three weeks on "choose tiles". Broken into "order sample pack from two suppliers". The bike service is booked online in under two minutes, so it's done on the spot.
• Side project: the newsletter idea goes into Someday. Not this month.
• Dates: car insurance renews in nine days. "Get two quotes" is added with a due date on Tuesday.

Plan (5 minutes). Priorities for next week: finish the report draft, order tile samples, sort the car insurance. Monday's first steps are starred: "draft the summary section" and "order sample pack".

Twenty minutes, and the week ahead is clear.

Questions to ask during the review

If you're not sure whether a project is on track, these questions help:

• What's the very next step, and could I do it in one sitting?
• Is this still worth doing? Would I start it today if it weren't already on the list?
• What am I waiting on, and from whom?
• Is anything due in the next two weeks that needs preparing now?
• What's one thing I could stop doing next week?

You don't need to answer all of them for every project. Pick the ones that fit.

If you're starting from a mess

Your first review might take an hour or more, especially if your list has been neglected. That's fine. Do the clear step properly, delete generously, and don't try to make everything perfect. From the second week on, it gets much shorter.

The payoff

People who keep a weekly review going usually say the same thing: they stop worrying about forgetting things. When everything has been looked at in the last seven days, you can trust that nothing important is hiding in the list, and that makes the rest of the week much quieter.

TL;DR: Getting Things Done is five habits: capture everything, decide what each thing needs, organise it into projects and next actions, review it weekly, and do the work. A task tree suits it well. Projects become parent tasks, next actions become the subtasks at the edge of each branch, contexts become tags, and the weekly review becomes a repeating task.

David Allen's Getting Things Done came out in 2001 and is still the most influential personal productivity system around. Plenty of people have read it, set it up over a weekend, and abandoned it a month later. Usually that's because the setup got too complicated, not because the ideas were wrong.

This post explains GTD in plain terms and shows a lightweight way to run it on a nested to-do list, with as little structure as possible.

GTD in five steps

1. Capture

Write down everything that has your attention. Work projects, errands, ideas, worries, things you've promised people. Allen calls it "getting it out of your head". The aim is a mind that isn't spending energy trying to remember things.

You need one place where everything lands first: an inbox. In a to-do app, that can be your top-level list or a task called "Inbox".

2. Clarify

Go through the inbox one item at a time and ask: is it actionable?

• No: delete it, file it as reference, or park it in a "Someday" list.
• Yes, and it takes under two minutes: do it now.
• Yes, and it needs one step: it's a next action. Write it as a verb.
• Yes, and it needs more than one step: it's a project. Decide the very next action.

The two-minute rule alone is worth the book. Tracking a quick task takes longer than doing it.

3. Organise

Allen's lists are:

• Projects: any outcome needing more than one step.
• Next actions, grouped by context: where or with what you can do them (calls, at the computer, errands, at home).
• Waiting for: things you've handed to someone else.
• Calendar: things that must happen on a specific day.
• Someday/maybe: things you might do but aren't committed to.

4. Reflect

Once a week, review everything: empty the inbox, check every project has a next action, look at your calendar, and update the waiting list. Allen calls this the weekly review and says it's what keeps the system trustworthy. In our experience he's right. See how to do a weekly review for a twenty-minute version.

5. Engage

Do the work. When you have time, pick from the next actions that fit your context, the time available and your energy.

Why a tree fits GTD

The awkward part of GTD in most apps is keeping projects and next actions connected. Many setups have a project list in one place and next actions in another, linked only by name. When you finish a next action, you have to go and find the project to decide what's next.

In a task tree, a project is a task with children, and its next actions sit inside it. Finishing one leaves you looking at the rest. And because the tree can go as deep as needed, big projects can have sub-projects without needing a separate system. Allen's "natural planning" (purpose, outcome, brainstorm, organise, next actions) maps straight onto a branch.

A lightweight GTD setup on a task tree

Here's a setup that uses nothing more than nested tasks, tags, dates and a short daily list. It works in Tatask, and in any app with the same building blocks.

Top level

Keep the top level short:

• Inbox: capture here. Clarify it daily or every few days.
• One task per area or big project: "Work", "Home", "Move house", "Side project".
• Someday: anything you're not committed to yet.

Projects and next actions

Inside each area, every project is a task. Inside each project, its steps. The next action is simply the first unfinished step on each branch, so you don't need a separate next-actions list. If the next step is vague, break it down until it isn't.

Contexts as tags

Put a tag in each next action for where you can do it:

• #calls
• #computer
• #errands
• #home
• #waiting for things you're waiting on someone else for

When you're at the shops, open #errands and see everything from every project you can do there. That's exactly what Allen's context lists are for, without maintaining separate lists. More on this in tags vs folders and on the tags feature page.

Calendar items as dates

Anything that must happen on a particular day gets a due date. Allen is strict that the calendar is only for things that genuinely must happen that day, and that's good advice. Don't put dates on things you'd merely like to do on a day; that's what the daily list is for.

Today

Allen doesn't prescribe a daily list, but most people find one helps. Each morning (or the evening before), choose a handful of next actions and star them so they show up in Today. It's a bridge between the full system and what you'll actually do.

The weekly review as a repeating task

Make "Weekly review" a task that repeats every Friday. It'll come back on its own, and you can keep the checklist as its subtasks.

Where people go wrong with GTD

Too many contexts

Allen's examples include a dozen contexts. Most people need four or five. If a tag view is never opened, delete the tag.

Treating every idea as a project

Not everything you write down needs a project. If you're not committed, it goes in Someday. Reviewing Someday monthly is plenty.

Skipping the weekly review

This is the one that kills most GTD setups. Without the review, inboxes overflow, projects lose their next actions, and you stop trusting the lists. Twenty minutes a week is the cost of keeping the system honest.

Perfecting the system instead of using it

GTD rewards tinkering, which is dangerous. If you've spent more time setting up than doing, simplify. A rough system you use beats a beautiful one you don't.

Is GTD right for you?

GTD suits people with a lot going on across several areas who want to feel sure nothing has been forgotten. It's more setup than simpler methods like the Ivy Lee method, but it catches more.

If you mainly struggle with one important task each day, Eat the Frog is lighter. If urgent things keep crowding out important ones, try the Eisenhower matrix. For organising notes and reference material alongside tasks, the PARA method pairs well with GTD.

Not sure? My two-minute planning method quiz suggests a starting point.

Start small

You don't need the full system on day one. Try this for a week:

1. Capture everything into one inbox.
2. Clarify it once a day using the two-minute rule.
3. Make sure each project has a clear next action.
4. Do a weekly review on Friday.

Add contexts and Someday lists once the basics are habits. The parts that stick are the parts worth keeping.

TL;DR: At the end of each day, write down the six most important things to do tomorrow. Rank them. Tomorrow, work on number one until it's done, then number two, and so on. Move anything unfinished to the next day's list. Repeat. It sounds too simple to work, which is mostly why it does.

The Ivy Lee method is the oldest productivity system most people use without knowing its name. It takes five minutes a day, needs no app, and fits on a scrap of paper. A hundred years on, it's still one of the best ways to get the important things done.

The story

The method is usually told like this. In 1918, Charles Schwab, president of Bethlehem Steel, one of the largest companies in America, wanted his managers to be more productive. He met with Ivy Lee, a well-known consultant, who said he needed fifteen minutes with each executive. Asked about his fee, Lee said Schwab could pay whatever he thought it was worth after three months.

Lee told each manager to do the following at the end of every working day:

1. Write down the six most important things to do tomorrow.
2. Rank them in order of importance.
3. Tomorrow, work on the first task until it's finished before moving to the second.
4. At the end of the day, move any unfinished items to a new list of six for the following day.
5. Repeat every working day.

Three months later, the story goes, Schwab sent Lee a cheque for $25,000, a fortune at the time.

How much of that is true is hard to say. The story has been retold so many times that the details are shaky. The method itself doesn't depend on the legend, though, and it holds up for good reasons.

Why it works

It forces a choice

Most of us have far more than six things we could do tomorrow. Limiting the list to six means deciding what matters most, and that decision is the valuable part. A list of twenty is a list of options. A list of six is a plan.

It's made the night before

You choose tomorrow's tasks when today is still fresh, and when you're not under the pressure of a new day. The morning starts with the first task already decided, so you skip the half hour of email-checking that often passes for "getting started".

It removes switching

Working on one thing until it's finished cuts out the cost of jumping between tasks. Every switch takes time to get back up to speed, and a day of switching feels busy without moving anything far. We looked at this in more detail in context switching is the enemy of productivity.

It's small enough to keep doing

There's no setup, no weekly maintenance, no categories. That's why people still use it. Complicated systems tend to get abandoned the first time life gets busy. Six lines on a piece of paper survive.

How to do it well

Make the tasks concrete

"Work on the website" isn't a task you can finish. "Write the copy for the pricing page" is. Each of the six should be specific enough that you know what done looks like. If your projects are too big to produce a clear next step, break them down first. My guide to breaking down a big project covers how.

Rank honestly

The top of the list should be the task that matters most, not the one you'd enjoy most. Often it's the one you've been avoiding. If you struggle with that, pair Ivy Lee with Eat the Frog: put the hardest important task first, every day.

Don't let small tasks crowd the list

Six items go fast if three of them are "reply to an email". Group small jobs into one item ("clear the email backlog") or deal with them in gaps between the big ones.

Expect to carry things over

Some days you'll finish two. That's fine. Carry the rest to the top of tomorrow's list and choose the remaining slots fresh. If you carry the same task for a week, it's either not important or too big. Drop it or break it down.

Adjusting the number

Six is a starting point. If you consistently finish all six by lunchtime, add more or make them bigger. If you rarely get past three, choose fewer. The point is a list you can usually finish. See how many tasks to plan per day for a way to calibrate it.

Ivy Lee in a to-do app

On paper, the method is perfect as it stands. In an app, you need two things:

1. A way to separate tomorrow's six from your full list, so you're not looking at everything all day.
2. A way to put those six in order.

In Tatask, that's the Today list. Star six tasks in the evening, wherever they sit in your project tree, and drag them into order. In the morning, open Today and start at the top. When a task is done, tick it off and move to the next.

The advantage over paper is that each starred task is still connected to its project. When you finish "Draft the pricing page copy", you can open the parent task and see what's next, which makes choosing tomorrow's six quicker.

A day with the Ivy Lee method

Here's what it looks like in practice for someone running a small online shop.

The evening before, they write:

1. Write product descriptions for the three new mugs
2. Reply to the wholesale enquiry
3. Photograph the new stock
4. Update the shipping prices on the website
5. Order more packaging
6. Draft Friday's newsletter

The next morning, they start with the descriptions and don't open email until they're done. By 11 the wholesale reply is sent. Photography takes longer than planned and fills the afternoon. At 5:30, items 4 to 6 are still open.

That evening, the new list starts with "Update the shipping prices", then "Order more packaging", then four fresh items. The newsletter moves to Thursday's list because it isn't due until Friday. Nothing about the unfinished items is a failure: the three most important things got done first.

Common objections

"My job is too reactive for this." If most of your day is responding to others, choose fewer tasks, maybe two or three, and do them first, before the reactive part starts. Even one important task done every morning adds up to a lot over a month.

"I don't know what's most important." That's useful to discover. If you can't rank six tasks, you may not be clear on your priorities, and that's a conversation worth having with yourself or your manager. A weekly review, where you look at all your projects together, helps a lot. See how to do a weekly review.

"It's too simple." Simplicity is the point. The method doesn't try to organise your whole life. It only makes sure each day starts with a clear, short plan.

Try it for a week

For the next five working days, before you finish work:

1. Write down six things for tomorrow.
2. Number them by importance.
3. Tomorrow, start with number one and don't move on until it's done.

At the end of the week, look at what you got done compared with a normal week. Most people notice a difference on the first day, because the morning's first hour goes to their most important task.

If you'd like to compare Ivy Lee with other approaches, my planning method quiz takes two minutes, and the daily planning guide shows how the method fits into a wider routine.

TL;DR: At the end of each day, spend ten minutes choosing three to five concrete steps for tomorrow. Put them in order. Do the first one before you open email. Plan fewer than you think you can do, and treat the list as the day's plan, not a wish list.

Most daily planning advice fails for the same reason: it asks for too much. Hour-by-hour schedules, colour-coded priorities, a morning ritual with journaling and affirmations. It works for a week, then a busy Tuesday breaks it and you're back to working from your inbox.

This routine is deliberately small. It takes ten minutes, needs nothing but a list, and is built to survive days that go wrong.

The idea in one sentence

Decide what you'll do tomorrow before tomorrow starts, keep the list short, and work through it in order.

Why plan at all

Without a plan, the day gets decided for you. Whatever is loudest wins: the latest email, the colleague at your desk, the notification on your phone. At six o'clock you've been busy all day and the thing that mattered hasn't moved.

A plan made in advance changes that in two ways. First, you make the decision about what matters when you're calm and can see the whole picture, rather than in the moment when everything feels urgent. Second, you remove the small decisions that drain the morning: "what should I do now?" has already been answered.

The routine

1. Clear your head (2 minutes)

Before choosing anything, write down what came up today that isn't on your list yet: the thing someone asked you to do, the idea you had in the shower, the bill that arrived. Getting it out of your head makes the next step easier, and it means tomorrow's plan is built on a complete picture.

2. Check what's due (1 minute)

Look at anything with a deadline tomorrow, and anything overdue. Some of it has to go on tomorrow's list. Some of it needs rescheduling, which is fine. A due date tells you when something must happen. It doesn't mean today is the best day to work on it.

If your app has a Due view, this is a ten-second glance.

3. Pick three to five steps (4 minutes)

This is the main event. Choose a short list of things you'll do tomorrow. Three to five is right for most people, plus any small fixed tasks like "pay invoice".

Two rules make this work:

Choose steps, not projects. "Write the report" won't fit in a day's plan; "Draft the summary section of the report" will. If the next step on a project isn't clear, that's a sign the project needs breaking down, which is better done in your weekly review than at 6pm.

Choose fewer than you think you can do. Almost everyone overestimates what fits in a day. Psychologists call it the planning fallacy, and it was described by Daniel Kahneman and Amos Tversky in the late 1970s. Meetings, messages and interruptions eat more time than we expect, every single day. If you finish your list early, add more. That feels far better than carrying half your plan forward every evening. There's a fuller answer to how many tasks to plan for a day in a separate post.

4. Put them in order (1 minute)

Order the list by what you'll do first. Usually that means the most important or most difficult step at the top, while your energy is highest. This is the core of the Ivy Lee method, which has been working for a century: work on the first item until it's done, then move on to the second.

Ordering also stops you cherry-picking. Without an order, you'll do the easiest item first, and then the next easiest.

5. Decide your first hour (1 minute)

Decide what you'll do in the first hour of tomorrow, before you look at email or messages. For most people it's the top item on the list.

The first hour sets the tone. If it goes to your inbox, the rest of the day tends to follow. If it goes to your most important step, you've made real progress before anyone else has had a say.

Then follow it

The plan only helps if you use it. During the day:

• Work top to bottom. Finish the first item before starting the second, unless something truly can't wait.
• Write down new things, don't do them. When something new comes up, add it to your list rather than switching to it. Most "urgent" requests can wait an hour, and many can wait until tomorrow's plan.
• Look at the plan, not the whole list. Your full list has everything on it, and looking at it will make you feel behind. Today's list is the only one that matters until it's done.

When the day goes wrong

Some days get taken over by a crisis, a sick child or a boss with a new priority. That's normal, and it isn't a failure of the plan.

When it happens, try to finish the top item if you possibly can. Then let the rest go. Tomorrow evening, carry over what still matters and drop what doesn't. A plan that bends is better than one you abandon after the first bad day.

Where to keep the list

Anywhere you'll see it. A sticky note on your monitor works. So does the back of your hand.

In an app, the list should be separate from everything else, so you can look at today without seeing the other 200 tasks. In Tatask that's the Today list: star a task anywhere in your project tree and it appears in Today. Drag them into order and you're done. On your phone, a short swipe left stars a task.

Variations

Time blocking. If your days are predictable, give each step a slot in your calendar. It adds structure but it's more fragile. One overrunning meeting and the whole afternoon shifts.

Eat the frog. If your problem is avoiding one hard thing, put that alone at the top and do it before anything else. See how to eat the frog.

Planning in the morning. If you're too tired in the evening, plan first thing instead. The same five steps apply. Do it before opening email, or the inbox will plan for you.

Not sure which approach fits? My two-minute planning method quiz suggests one based on how your days actually go.

A one-week experiment

For the next five working days:

1. Each evening, take ten minutes and choose three to five steps for tomorrow, in order.
2. Each morning, do the first one before email.
3. At the end of the week, count how many days you finished the list.

If the answer is zero, plan fewer. If it's five, plan one more. Most people settle on a number within a fortnight, and they stop ending the day wondering where it went.

TL;DR: Write the project as an outcome. List its parts. Take the part you'll do first and break it down again, and keep going until every step starts with a verb and fits in one sitting. Only plan the near part in detail. Then pick one step for today.

Some items sit on a to-do list for weeks. You read past them every morning. They aren't hard, exactly. You just can't see where to start, so your eye moves on to "reply to Sam" and "buy bin bags", which you can.

Those items are almost always projects written as if they were tasks. "Sort out the garden." "Launch the website." "Move house." Each one is really twenty jobs and a handful of decisions, folded into a single line. Breaking it down is how you unfold it.

This guide covers a method that works for anything from a dissertation to a kitchen refit, a worked example, and the mistakes that make a breakdown fall apart.

Why big tasks get avoided

It's tempting to call it laziness. It isn't. When a task is vague, your brain has to do two jobs before it can start: work out what the task involves, and then do the first part of it. The first job is the hard one, and it's invisible. You don't get to tick it off, and it doesn't feel like progress, so it's easy to put off.

A task like "Email three removal firms for quotes" has already had that thinking done. Starting it costs almost nothing.

There's also a stress effect. Unfinished goals nag at us. Psychologists E. J. Masicampo and Roy Baumeister found in 2011 that making a specific plan for an unfinished goal reduced how much it intruded on people's thoughts, even before they acted on it. A broken-down project is that kind of plan. I wrote more about this in the psychology behind task hierarchies.

The method

1. Write the outcome, not the topic

Start with one line describing what done looks like.

• Not "Garden", but "Garden ready for a party in July"
• Not "Website", but "New website live with the shop working"
• Not "Pension", but "Old pensions moved into one account"

An outcome tells you when to stop. A topic never ends.

2. List the parts

Underneath, write the main pieces the outcome is made of. Aim for three to seven. Don't sort them and don't worry about order yet. That comes later.

For "Garden ready for a party in July" that might be:

• Patio
• Flower beds
• Lighting
• Furniture
• Clear-up

If you find yourself writing fifteen parts, some of them probably belong together. If you can only think of one, you may have written a step rather than an outcome.

3. Break down only the part you'll do first

This is where most people go wrong. They try to plan every branch in detail on day one, run out of energy halfway through, and end up with a giant plan they don't trust.

Instead, pick the part you'll work on first and break that one down. Leave the others as single items. You'll break them down when you reach them, with whatever you've learned in the meantime.

4. Keep asking "could I start this right now?"

For each item, ask whether you could start it right now without thinking, and finish it in one sitting. If not, it has parts. Write them one level down.

A good bottom-level step has three qualities:

• It starts with a verb: email, measure, book, draft, compare, call.
• It has an obvious end. "Research patios" never finishes; "Compare porcelain and slate prices at two suppliers" does.
• It fits in one sitting, ideally well under an hour.

5. Pick today's step

Choose one or two steps to do today and put them where you'll see them. The breakdown is worth nothing if it lives in a document you don't open. If you use a Today list, star them.

A worked example: a house move

Here's the method applied to a real project, three levels deep in the part being worked on and rough elsewhere.

• Move house by the end of March
  • Sort out the removal
    • Email three removal firms for quotes
    • Compare quotes and book one
    • Confirm the date and access with the new landlord
  • Pack
  • Change addresses
  • Leave the old place

Only "Sort out the removal" has been broken down, because that's what needs doing first. Removal firms book up, so it's the urgent branch. "Pack" will be broken down in a fortnight, when it's closer.

When "Pack" comes round, it might look like this:

• Pack
  • Order boxes and tape
  • Pack one room per weekend
    • Spare room and loft
    • Books and kitchen cupboards
    • Everything else
  • Label boxes by room

Notice that "Pack one room per weekend" has its own children. Trees don't need to be the same depth everywhere. They go as deep as each part needs.

What a good breakdown looks like

You can tell a breakdown is working when:

• You can look at any branch and see what the next step is in a couple of seconds.
• Most bottom-level steps would take less than an hour.
• You're ticking off steps most days, even when the project is months long.
• The parts you're not working on are out of sight, so they're not adding noise.

That last point matters more than it sounds. A flat list of 60 steps for a house move is just as overwhelming as one line saying "move house". A tree lets the parts you're not working on fold away inside their parent.

Common mistakes

Planning too far ahead

Detailed plans for work months away are usually wrong by the time you get there. Plan the near part well and the rest roughly.

Steps that are really decisions

"Choose a removal firm" looks like a step, but it hides research and comparison. If a step involves a decision, the step before it is usually "gather what I need to decide". Make that its own task.

Steps that depend on someone else

"Get the landlord to confirm the date" isn't something you can do. "Email the landlord asking to confirm the date" is. If you're waiting on someone, tag it (#waiting works well) so you can check on it during your weekly review.

Breaking things down as a way to avoid starting

Breaking down can turn into procrastination. If you've spent twenty minutes refining a tree and haven't done a single step, stop and do the top one. The breakdown only has to be good enough to start.

Doing it on paper or in an app

You can do this with a pen. Indented lists in a notebook work fine.

The trouble with paper is that trees change. Steps get added, plans shift, parts move from one branch to another. An app that lets any task hold its own list makes that painless. That's the idea Tatask is built on: every task can hold subtasks, as deep as you like, and on the web each opened task becomes a new column so you can see the path from the goal to the step. There's more detail on the nested tasks feature page.

Whatever you use, the method is the same. For a more formal take on it, see how to use a work breakdown structure for everyday projects. If big tasks make you freeze, how to stop procrastinating on big tasks covers the emotional side. And my older post on breaking down complex projects has more strategies for work projects with several people involved.

A ten-minute exercise

Pick the item on your list that you've been skipping longest.

1. Rewrite it as an outcome.
2. List its parts.
3. Break down the first part until the top step starts with a verb and fits in twenty minutes.
4. Do that step today.

Most people find the project feels about half as heavy afterwards, before any real work has been done.

How we organise information

Mental models

We understand the world by building mental models of it, and cognitive psychology research has found that those models tend to be hierarchical: broad categories at the top, specific details underneath.

Working memory

Working memory only holds a little at once. George Miller's well-known "7 ± 2" paper suggested we can keep roughly 5 to 9 items in mind at a time. Grouping information into chunks gets around that limit, and a hierarchy is chunking you can see.

Why it suits task lists

Breaking things down

Faced with a big project, most people's first move is to split it into parts. Doing that on paper takes the anxiety out of a large project and gives you a better sense that you're in control of it.

Small wins

Finishing a task releases dopamine, which is where the sense of achievement comes from. A hierarchy gives you more of those moments, because you can see progress at several levels: a subtask done, then a group of subtasks, then a milestone.

What you get out of it

Less to keep track of

When the structure is written down, you aren't spending effort remembering it. That leaves more attention for the task in front of you and makes decisions about what to do next easier, and it's less stressful.

Motivation

Seeing how a small task connects to a bigger goal makes it more motivating. Clark Hull's goal-gradient hypothesis describes a related effect: the closer we think we are to a goal, the harder we work towards it.

Getting unstuck

Too many choices

With too many options in front of you, it's easy to freeze. A hierarchy gives you an obvious place to start, puts things in a rough order, and lets you look at one level at a time.

Feeling overwhelmed

A big project broken down feels more manageable. You can see the next concrete step, and as branches get ticked off, you can see how far you've come.

Putting it into practice

Build it up slowly

You don't need a perfect hierarchy on day one. Start with a few top-level categories and add detail as you go, working from general to specific.

Expect it to change

Your understanding of a project changes as you work on it, so the tree should too. In Tatask you can drag a task, along with everything under it, to wherever it now belongs.

If you'd like a list that works with how you already think, try Tatask free for 30 days.

References:

• Miller, G. A. (1956). The magical number seven, plus or minus two: Some limits on our capacity for processing information.
• Hull, C. L. (1932). The goal-gradient hypothesis and maze learning.

1. Breaking projects into a task tree

Productive people are good at turning a big project into small tasks. A nested list shows the big picture and the detail in the same place.

Most people think about a project as parts within parts, so a tree is closer to how you already plan than a flat list is. In Tatask you can nest as deep as you need, which makes it easy to keep breaking a project down until each step is something you can do.

A software project, for example, might start with "Frontend", "Backend" and "Testing". Each of those breaks down into specific tasks and subtasks. The project looks less daunting, and it's clear what has to happen next.

2. Using pen and paper as well as apps

Digital tools are hard to do without, but paper is still better for some jobs. Writing by hand has been shown to help memory and creative thinking, so notebooks remain good for brainstorming, notes in meetings and daily reflection.

The habit that makes this work is moving anything important from the notebook into the place you'll actually look later. You might sketch a project plan on paper, then type the structure into Tatask and refine it there over time.

3. Switching off on purpose

It's hard to stay focused if you never disconnect. Productive people schedule offline hours, away from their devices, to recharge and think. It lowers stress and helps keep burnout away.

4. Using AI as an assistant

AI tools are now good at summarising email, transcribing meetings and drafting a first plan for a project. Handing those jobs over leaves more of your time for the work that needs your own judgement.

AI can also help break a project down. Give it "Launch marketing campaign" and it'll suggest steps like "Develop messaging", "Create social media content" and "Set up analytics". Treat that as a first draft. The people who get the most out of AI check its suggestions against what they know and rewrite them to fit.

5. Protecting time for deep work

There's more competing for our attention every year, which makes long stretches of focused work more valuable. Productive people block out time for their hardest, most important tasks and guard it.

Regular deep work sessions are where real progress on important projects happens. The work is better for it, and it's more satisfying too.

6. Writing clearly for people who aren't online

Remote and flexible work means a lot of communication happens asynchronously, with people in different time zones on different schedules. The people who do it well write short, clear messages that include all the context the reader needs.

They also know when a live conversation is better: brainstorming, untangling a hard problem or getting to know a colleague.

7. Learning and adapting

New tools and methods appear all the time. Productive people try new techniques and keep the ones that help, without chasing every trend. Reading blogs, joining webinars and taking part in online communities are all good ways to keep up.

Most of these habits come down to a balance between useful tools and principles that have worked for a long time. If you want to start with the first one, try Tatask free for 30 days.

This post covers what makes a project complex, why breaking it down helps, a few ways to do it, and how to keep the result manageable.

What makes a project complex

Complex projects tend to have a few things in common:

• Lots of connected tasks. Many tasks depend on others being done first.
• Long timelines. Months or even years of sustained effort.
• A range of skills. Often more than one person, or more than one kind of work.
• Moving goals. Requirements change as the project goes on.
• High stakes. The outcome matters to your business, your goals or your organisation, which adds pressure.

That leads to familiar problems. The size of the thing makes you put it off. It's hard to tell which of the many tasks should come first. You get lost in the details and forget the goal. Splitting your time sensibly between parts is tricky, and so is keeping track of progress on several fronts at once.

There's a psychological cost too. A big project raises your cognitive load, and that can show up as stress. You overthink and can't start, motivation drops because the project seems impossible, and judgement suffers when you're overwhelmed.

Why breaking it down helps

Task breakdown (or task decomposition) means dividing a project into smaller units of work. The result is a hierarchy where each level adds more detail than the one above it.

It works because small, concrete tasks are easier to deal with than large, abstract ones. An overwhelming goal turns into a series of steps you can achieve.

A flat to-do list can't show that. A breakdown arranges tasks as parents and children, so you can see what belongs to what. It copes with a weekend job or a project that runs for years, and you can rearrange it as the project changes. At any point it shows what needs doing.

The practical benefits:

• The project feels smaller, because you're only ever looking at the next piece.
• Breaking it down surfaces problems and resource needs early.
• A specific task is easier to concentrate on than a vague one.
• Small tasks get finished, so you can see progress.
• You'll probably procrastinate less.
• In a team, well-defined tasks are easier to hand to the right person.
• When requirements change, you adjust a branch instead of redoing the whole plan.

Ways to break a project down

Top down

Start with the goal and work downwards:

1. Write down what you want to achieve.
2. Split the project into its main phases or milestones.
3. For each phase, list what it needs to produce.
4. Keep dividing until you reach tasks you can act on.

Every task you end up with connects back to the goal.

Bottom up

Start with the tasks and work upwards:

1. List every task you can think of, whatever its size.
2. Group related tasks together.
3. Work out what larger goal each group serves.
4. Arrange the groups and tasks into a hierarchy.

This is useful when you don't yet know the full scope of the project.

Visual techniques

A mind map starts with the project in the middle and branches out into topics and subtopics. Affinity diagramming means writing ideas on sticky notes and grouping similar ones, which shows you the natural categories. A fishbone diagram, which branches out like a fish skeleton, is good for finding the causes of a problem or the components of a solution.

SMART tasks

Once you have tasks, check that each one is:

• Specific: it says what needs to be done.
• Measurable: you'll know when it's finished.
• Achievable: it's realistic with what you have.
• Relevant: it moves the project forward.
• Time-bound: it has a deadline or a timeframe.

A system you can follow

1. Write down the project's main objective.
2. List its major components.
3. Break each component into tasks you can act on.
4. Arrange the tasks in a hierarchy.
5. Decide which tasks matter most or are most urgent.
6. Give each task a realistic timeframe.
7. Read through the whole thing to check nothing is missing and every task is clear.

The hierarchy usually looks something like this:

• Project: the overall goal
  • Components: the main phases or areas
    • Tasks: specific actions within each component
      • Subtasks: smaller steps needed to finish a task

You can zoom in on the details or out to the whole project without losing track of individual tasks.

How far to go

Breaking tasks down too finely turns planning into micromanagement and can be as overwhelming as not breaking them down at all. Stop when each task is clear enough to act on without more explanation, and make sure every detailed task still connects to a larger goal.

Tools

There are plenty of methods, GTD and Kanban among them. The best one is whichever you'll actually keep using.

Many project tools are complicated enough to add to your stress. I built Tatask to be the opposite: a simple list where any task can hold subtasks, as deep as you need.

• Nest tasks inside tasks to match your breakdown.
• Add a task or subtask with a click or a keystroke, so you can get ideas down without breaking your flow.
• Drag tasks, along with everything under them, to rearrange the plan as it changes.
• Collapse or expand any branch to switch between an overview and the detail.
• Tick tasks off and watch the project shrink.
• It syncs between devices and works offline, so you can work on the plan wherever you are.

With the whole project written down in one place, you don't have to carry it around in your head.

Common problems

Planning instead of doing

It's possible to spend so long planning that you never start. Give yourself a time limit for the first breakdown, start broad, and refine as you go. The plan can change later.

Losing sight of what matters

A detailed breakdown makes it easy to forget what's important. Review the list briefly every day or week. Each morning, pick the few tasks that will make the most difference. In Tatask, starring a task puts it on your Today list.

Working with a team

When a team shares a project, the breakdown becomes a group effort. Make sure each task has a clear owner, everyone can see the full breakdown, and you check in regularly. Tatask is for one person's work, so a shared team tool will suit this part better.

Combining it with other methods

Breaking a project down works well alongside other techniques:

• Pomodoro. Work on one task from your breakdown in 25-minute focused sessions.
• Time blocking. Give specific tasks specific slots in your calendar.
• OKRs. Break objectives into key results, and key results into tasks.
• Scrum. Break epics into user stories, and stories into tasks, to build the backlog.
• Kanban. Move tasks from the breakdown through stages of completion on a board.

Checking it's working

Keep an eye on a few numbers: how many tasks you finish each day or week, whether you hit your milestones on time, and how long tasks take compared with your estimates.

A weekly or monthly review is a good place to look at them. Some people keep a short journal of how their days went. In a team, ask people whether the breakdown is helping.

Then adjust. If you keep misjudging how big tasks are, break similar tasks down differently next time. If some areas keep getting overlooked or too much attention, change your categories. Your projects and the way you work will change, so the breakdown should too.

The hard part of a big project is usually working out where to start, and breaking it down answers that. Try it on your next project. If you'd like a tool built for it, Tatask is free for 30 days.

Tasks inside tasks

Tatask is built around a hierarchy. Any task can hold its own subtasks, a bit like folders on your computer, so the structure will feel familiar straight away.

That lets you break a big project into small steps, see how each step relates to the rest, and look at one part of the work without losing track of the whole.

Building the system

Start with the big areas

List your main projects or areas of responsibility. These become the top level of your tree. For example:

• Work projects
• Personal development
• Home
• Health and fitness

Break them down

Under each area, add more specific tasks. You can nest as deep as you like, so each part gets as much or as little detail as it needs.

• Work projects
  • Project A
    • Research
      • Literature review
      • Market analysis
    • Development
    • Testing
  • Project B
    • Prep for client meeting
    • Draft proposal

Keep it simple

A system you have to maintain is a system you'll eventually abandon. Tatask doesn't have much in the way of settings or workflows to learn. Each task can be expanded or collapsed, so you only see the part you're working on.

Prioritise

Once your tasks are in a tree, deciding what comes first is easier. You can drag tasks to reorder them, tag or star the important ones, and collapse whole sections you're not working on today.

Review and adjust

Every so often, look over the tree and change it. Projects change shape, new ones turn up, and finished ones can be cleared out. Moving a task (and everything under it) is a drag and drop.

Why it helps

When a project is broken into small tasks, you don't have to hold it all in your head. The next step is sitting there in the list, so you spend less time deciding what to do. Small tasks also get finished more often, and ticking things off is good for motivation.

It suits both kinds of planner. If you like to think at a high level, stay near the top of the tree. If you like detail, go as deep as you want. Either way you only have to look at one level at a time, which is a lot less stressful than seeing every task you've got at once.

Setting it up in Tatask

1. Create 3 to 5 top-level tasks for the main areas of your life or work.
2. Add subtasks to each one with the + button.
3. Keep breaking tasks down until each one is something you could actually sit down and do.
4. Drag tasks into the order you want to do them.
5. Work from the top of each area, expanding sections as you need them.

The point is a system that fits how you work, so change any of this that doesn't suit you.

Tatask is free for 30 days if you'd like to try it with a real project.

Start your free trial

Why flat lists struggle

A paper to-do list used to be enough for most people's days. It gets harder once work and home life involve several projects, other people in different time zones and a handful of apps you switch between all day. On a single linear list, all of that turns into one long column, and it quickly becomes overwhelming.

What hierarchical task management is

It's organising your tasks as a tree. Projects sit at the top and their subtasks are nested underneath, as many levels deep as you need. That's close to how most people break a problem down in their heads anyway.

The tree shows how tasks relate to each other and to the bigger goal they belong to. Real projects work that way: a series of connected steps and milestones, with smaller steps inside the big ones.

What it does better

Big projects

Large projects have a lot of parts, and some parts depend on others. A tree lets you break a daunting project into pieces you can actually start on.

In Tatask you might start with "Launch new product" and split it into "Research", "Development" and "Marketing". Each of those breaks down again into specific tasks. You can see the whole scope of the project and still find the single thing to do next.

Less to keep in your head

Because the tree shows how tasks connect, you don't have to remember it. The project lives on the page instead of in your working memory.

Tatask lets you collapse and expand any branch, so you can go from an overview of everything to one detailed list and back again. When you're looking at one branch, the next task is usually obvious.

Zooming in and out

Some days you only need to see a few urgent tasks. Other days you want to step back and look at all your projects. With collapsible branches you can do both: collapse everything for the overview, or open one branch to see its details.

Prioritising

When related tasks are grouped together, it's easier to spot which ones block the others and which ones matter most. In Tatask you drag tasks into order within their branch, so the important ones sit at the top. Reordering a short branch is much easier than shuffling a long flat list.

Different ways of planning

Some people start with broad goals and work downwards. Others start with specific tasks and group them later. A tree handles both. You can outline your projects first and fill in the details, or add tasks as they come to you and gather them under a parent afterwards.

Setting it up

1. List your top-level projects or areas of responsibility.
2. Under each one, add the major tasks or phases.
3. Keep breaking tasks down until each one is something you can act on.
4. Drag tasks into priority order within each level.
5. Look over the tree regularly and change what's no longer right.

If you're coming from a flat list, start with one project. Move the rest over once the first one feels natural.

Keeping it from getting complicated

A tree can grow into something harder to manage than the list it replaced. A few habits stop that:

• Give tasks short, clear names, so the structure stays readable.
• Prune regularly. Clear out finished tasks and question the ones that have sat untouched for weeks.
• Make sure the tasks at the bottom of each branch are specific things you can do.

If your projects have more parts than a flat list can show, try a tree. Tatask is free for 30 days.

Start your free trial

Why Svelte 5

Svelte 5 uses signals under the hood, which makes it faster, so Tatask should feel snappier.

It also introduces "runes", a new way to handle state and reactivity. They make the code simpler and easier to follow, which means a more stable app and quicker work on new features.

Reactivity is easier to reason about and the debugging tools are better, so I can build things faster and catch problems earlier. That should mean more frequent updates and fewer bugs.

Moving early also means Tatask can use new Svelte features and optimisations as they arrive.

What changes for you

Pages should load faster and interactions should feel smoother, and the interface should respond more quickly. Svelte 5 also makes some features possible that I'm looking forward to building.

It's a release candidate, so I tested it thoroughly before shipping. I wouldn't push this update if I didn't think the benefits far outweighed the risks.

I'll write more as I put Svelte 5 to work on the app.

Learn key skills

When starting out learning about any field it is important to study broadly around the area and see how different topics fit together. If you wanted to become a historian you wouldn't immediately spend all your time learning about The Boudican revolt of 60AD. First, you learn the basics and then you specialize once you've discovered what interests you and what you're good at. It's the same with web development.

Building a to-do list is a great way of learning those basics. It's a simple CRUD app so you can learn basic HTTP requests, some HTML, CSS and Javascript, a little about databases etc. The key is that you're getting a feel for how the pieces of web development fit together. Now you could build almost any CRUD app as a starter project and learn these concepts but a to-do list is the purest form of this in my opinion as I'll explain next.

A sliding scale of complexity

A to-do list app is the ultimate set of training wheels for a junior developer. It lends itself so nicely to focusing on whichever aspect of development you want to learn first while ignoring the rest. Want to learn HTML and CSS? Hard code some todos and try to make it look nice. Want to learn about handling HTTP requests? Use Postman or similar and try to get your server to perform CRUD actions on an in-memory array of to-dos.

The point is you can start with the simplest building blocks of development and work your way up however far you want. Maybe you want a nice microservice to handle scheduling to-dos. Or you've decided to try your hand at mobile development, then build your app in Swift, Kotlin, Flutter etc. The possibilities of such a simple app are endless.

I initially built Tatask because I wanted a to-do system that worked the way I did (more on that later), but the initial spark to actually build it came because I found Alpine JS and decided I wanted to try building something using that. Then a few months later I found myself with shiny object syndrome and decided to rebuild it all in Svelte so I learned that too and now absolutely love Svelte. The best way to learn in my opinion is by building projects, there's no way I'd have understood nearly as much if I'd simply read some documentation. A few months ago I decided I'd like to learn SwiftUI, so now Tatask has an iOS app and I know a reasonable amount about building Swift apps (with a diversion down the capacitor JS and Flutter routes briefly too!).

The point is, a to-do app is at its heart incredibly basic but at the same time has so much room for adding complexity and trying different tools and technologies.

There's no pressure to commercialize the project

At this point, there are so many different to-do list apps around that for an individual it's a terrible plan to try and make a business out of one. The market is so saturated and there's not much differentiation (Tatask aside of course 😉). This lack of pressure makes working on a to-do list a pleasure. It's like tending to a garden rather than a farm. Fundamentally you're trying to grow things in both but a garden is a place for relaxation and beauty and trying new things in order to make a perfect space for yourself. A farm on the other hand is for others, you are beholden to the market and that brings stress and external influences out of your control.

I'll admit that Tatask isn't exactly a garden as I wanted to learn about marketing so I added some payment plans and tried some promotion, but nor is it exactly a farm as it's still a small project not intended to take over my world.

To me Tatask is somewhat like a show garden, I invite people in to use and enjoy it, and if they spend a lot of time here then they can pay for it. I accept feature requests and fix broken fences etc. but I don't spend all my time manning the gate. At the end of the day, Tatask is mainly built for me and it has delivered enormously on the promise of teaching me lessons, but even more so on the goal of making me more productive.

Build something that works in the way you do

Everyone is most productive in different circumstances, some like the Pomodoro technique, and others like scribbling everything on Post-it notes and picking them up at random. I like breaking tasks down into smaller and smaller chunks until I can fit the entire thing in my working memory (shockingly limited these days), and complete it in under an hour so I don't get tired halfway through. What I'm saying is that no matter how many to-do list apps are out there, the perfect tool for you has probably not been built and you might be able to make yourself more efficient and more accomplished if you spend a weekend building it. Perhaps you want a giant list that randomizes order every time you open it so you can tackle serendipitous tasks. Build it! The payoff over time of a 5% increase in productivity quickly repays the initial time investment even if you disregard the skills you'll learn along the way.

Conclusion

There are so many routes to becoming a software developer and building a to-do list application is definitely one of the best. I've learned so much from building Tatask and can't recommend it highly enough to everyone else.

If you end up building your own, let me know, I'd love to visit your garden, and if you're looking for a freelance developer for an interesting project I'm open to work :)

You can email me at max@tatask.com

A great productivity device should still make tradeoffs in form and function as we all do different work, but we've made this device already and it's a laptop. With a physical keyboard, large display, portability, and flexible use cases, laptops are fantastic productivity machines.

It's pretty obvious to say that laptops are superior productivity devices compared to phones, but I'm going to argue that you should be avoiding using your phone for anything productive at all if possible. Here's why:

• Smartphones are primarily consumption devices
• Your brain can't handle multimodal usage of a smartphone properly
• Notifications can derail your train of productive thought in an instant

Smartphones are primarily consumption devices

Smartphones are better as consumption devices than production devices. They mostly have touchscreens which are better suited to tap and swipe gestures than typing or more complex inputs. As consumption devices they are wonderful, the responsiveness of a touch screen lets you easily swipe through various content types, and the portability means you can pull out your phone anywhere and quickly immerse yourself in the latest news or memes. From a productivity point of view though smartphones lack some critical features such as a large screen which doesn't force software designers to hide useful functionality behind nested menus in the name of space saving. There are physical keyboards on some smartphones but it's the exception rather than the rule and statistics show that the average user can type 38wpm on a touchscreen vs 52wpm on a physical keyboard (or, people type ~37% faster on a physical keyboard).

Your brain can't handle multimodal usage of a smartphone properly

As we learn new skills we create and reinforce pathways in our brain, that's why riding a bike becomes second nature once you've learned how and you don't need to make nearly the same effort to balance as when you first started trying. These pathways are also built in your brain as you use your phone, certain habits and activities become associated with your phone and become second nature. This would be great if you only ever used your phone for productive purposes. Every time you picked it up you'd habitually open up your notes app to start drafting a blog post, or your emails to triage your inbox.

I'm confident however that you're like me and use your phone for all sorts of other things like Twitter, Instagram or Hinge. And if you're anything like me then you use your phone way more for those apps than for anything productive. This means that whenever you open your phone with the intention of productivity you're fighting an uphill battle with your brain which wants to follow the well-established pathways and start doom-scrolling.

Notifications can derail your train of productive thought

Let's say you have the best intentions and have managed to start a productive activity using your phone. The problem is they are notification machines with every app vying for your attention and every time you get a notification you're going to be, at best distracted briefly from your work and losing a little concentration, and at worst completely stopping work to context switch and respond to the notification you've received. Even if you have notifications turned off there's always a part of your brain wondering if someone has sent you the latest funny meme while you've been working. Some people can blank this out, but for most, it's another barrier to true focus/flow. The solution once again, is just to use a laptop for your work and keep your phone in your bag or another room as out of sight helps keep it out of mind.

The prescription

Use your phone for what it's best at, and other devices for work. I have found my productivity vastly improved by not using my phone for anything productive if I can help it. For the same reason, I try not to use my laptop for anything consumptive either. Separating the two devices so that one is for work and the other is for almost everything else is enormously helpful as I now sit down with my laptop and instantly feel like doing something productive as it's habitual. If I'm on my phone and think of something work-related that needs to be done, I'll quickly add it to my task management system, Tatask, then go back to whatever Twitter thread I was reading. If I'm on my laptop and see an interesting article to read I'll send it to my Kindle using Ktool and then get back to work, or if I want to watch a Youtube video I'll do so on my television knowing that if I built a habit of watching Youtube on my laptop I'd be lost in every rabbit hole imaginable!

Conclusion

I think the primary reason we aren't productive with our phones is not the lack of physical keyboards or larger screens but because of the habits we've built around them. If you manage to train yourself to be productive on your phone without getting distracted by everything else a phone is capable of and arguably more designed for then please teach me how! For everyone else, try using separating what you use your phone for compared to what you use your laptop for.

In the meantime, I will point everyone who asks me why I didn't start building native apps for Tatask to this post as an explainer. Having said that, native apps are now in development because sometimes I really do need to organize my tasks on the go and that's ok because the key to productivity is flexibility! Thanks for reading, and good luck.

We need some example tasks so you can see what sort of data structure we're working with.

{
    text: 'Buy milk',
    tags: ['shopping', 'home']
},
{
    text: 'Repaint fence',
    tags: ['home', 'long']
},
{
    text: 'Redesign landing page',
    tags: ['design', 'long']
}

We'll store those in a tasks array.

We need a $: all_tags array to display the tags to filter by. We can set this using the following:

$: all_tags = [...new Set(tasks.map((x) => x.tags).flat())];

And finally, we need a filters data structure for which I'll use a Map.

let filters = new Map();

Displaying the list

Here's the basic structure of the list, note the filtered array is being referenced instead of the tasks array. We'll need that in the next step.

{#each filtered as task}
	<div>
		<p>{task.text}</p>
		{#each task.tags as tag}
			<p>{tag}</p>
		{/each}
	</div>
{/each}

Hooking up the filtered array

We again make use of Svelte's reactive $: variables like so:

$: filtered = tasks.filter(
	(x) =>
		(filters['tags'] != null &&
			Object.values(filters['tags']).every((func) => func == null || func(x))) ||
		!filters['tags']
);

It's not super straightforward so let me explain. We need to filter the tasks array by whatever filters are set in the filters Map. To do that we first check if the tags filter is set, then if it is set we run our task through every filter the tags map contains and check if the task produces a truthy value or not. If the tags filter is not set then we return true for this part of the filtering.

The dynamic bit

The above code is all fairly standard, I think the clever bit is how we dynamically create filtering functions. Here's some code and I'll explain it afterwards.

{#each all_tags as tag}
	<button
		on:click={() => {
			if (filters['tags'] == null) filters['tags'] = new Map();
			if (filters['tags'][tag] == null) {
				let f = (x) => {
					return x.tags != null && x.tags.includes(tag) != null;
				};
				// This is how you give the above function a dynamic
				// name so we can edit/delete it in the filters Map
				Object.defineProperty(f, 'name', {
					value: tag,
					writable: false
				});
				filters['tags'][tag] = f;
			} else {
				// Remove this tag filter if you click the tag again
				filters['tags'][tag] = null;
			}
		}}>{tag}</button
	>
{/each}

This code simply produces a list of clickable tags. When you click a tag it adds the tag's filter to the filters Map as filters["tag_name"] which will then filter the task list. We can do this as we are filtering the task list using every() which ensures that all added filters are run. We need to name the function so that we can remove the filter by clicking the tag button again while keeping any other added tags.

When you click on a tag you're essentially turning the task filtering function into this:

$: filtered = tasks.filter((x) => x.tags != null && x.tags.includes(tag));

You can of course add other filters as well, in Tatask you can filter by due dates, tags, assigned_to etc. You simply need to add further logical expressions to the filtered array.

Conclusion

I hope this tutorial is helpful, there was some demand for it on Reddit after I shared a demo video of filtering in Tatask that I added on Wednesday. I've never written a tutorial before so I'm not sure how intelligible or otherwise it is. Please email me at max@tatask.com if you have any suggestions or improvements. And if you want to see a more complete version of this filtering in action then do give Tatask a try. It's an incredibly powerful yet surprisingly simple way of managing tasks.

Good tools change how you handle your daily tasks, projects and work with other people. Below are seven things they help with.

7 ways task management software helps

The market for these tools has grown since the COVID-19 pandemic. According to Globe News Wire, the global task management software market was worth around $3.4 billion in 2020 and is projected to reach $8.3 billion by 2027, a 13% CAGR, largely because of demand for remote work tools.

1. Collaboration and communication

Task management software goes beyond individual to-do lists. Real-time collaboration lets team members work on the same tasks and projects without long email chains or status meetings. Because changes sync as they happen, everyone sees the same picture and works towards the same goals.

2. Organising tasks

The best workforce management software puts all your tasks in one place. Central task lists, categories and priorities make it easier to keep track of your workload, and customisable workflows let each person work the way that suits them. That's useful whether you're working alone or in a team.

3. Time tracking and resource allocation

Task management tools can record how long tasks and projects take, which shows where time is going and where you could save some. They also show who is working on what, so tasks can go to people who have the time and the right skills.

4. Automation

Repetitive tasks are slow and dull. Many tools can automate recurring tasks, reminders and notifications, which leaves more of your energy for the work that needs it. Templates for standard processes save time setting up the same tasks again and again.

5. Integrations and access

Most task management tools connect to calendars, communication tools and file-sharing platforms, so the information you need is in one place. Mobile apps let you keep working away from your desk, and sync means you can switch devices and pick up where you left off.

6. Reporting

Some apps report on task progress, completion rates and individual or team performance. That data shows where workflows could improve and where resources would be better spent.

7. Security

Your data needs to be safe in any task management tool. Look for encryption, secure backups and access controls, which protect your information from unauthorised access and loss.

Choosing a tool

The right software can make a real difference to how your workday goes, whether you need better organisation, collaboration, time tracking, automation, reporting or integrations. Work out which of these matter to you, then look for the tool that does those well.

Mono tab

Like me, you may have scoffed at your elderly relatives for having 486 tabs open on their device's browser and wondered how they can possibly need them all. The thing is, most of us are being at least a little hypocritical given we may have 10+ tabs open ourselves. We may open a few new tabs to gather together information that we are going to use later but this is a bad idea. Instead, you should open any link in your current tab, get the information you need and then get out. Your brain will thank you for taking a linear path through the web instead of trying to open up multiple processes at the same time which it has to keep track of the context of. How many times have you seen a collection of links that seem interesting, opened them all up in background tabs for later and then when later comes, you've forgotten why you opened those links in the first place? I have a theory that we were all far more productive before browser tabs were invented (credit InternetWorks), and since switching back to mono tabbing I can anecdotally confirm my hypothesis (n=1).

I highly recommend giving it a go and you'll quickly notice how different it is to browse the web when you can visit a link, get what you need and move on. This way you can build a linear map of everything you've visited in your brain instead of a garbled mess of overlapping tabs you quickly cycled through. You can do this manually by avoiding opening links in a new tab but of course, there are many links that default open in a new tab (grr). I found a great extension for Chrome (no affiliation) that successfully keeps your browser resolutely single tabbed, I'm sure there are others out there for your browser of choice. Try it for a couple of days and I'm sure you'll find it useful, plus it's a simple change with an extension to enforce the habit.

Break tasks into smaller brain-mode-based subtasks and perform subtasks in related batches.

If you know that you need to accomplish many different tasks in your day, batch them by similarity so your brain can stay in the same mode throughout each batch. To help avoid hard context switching you can try breaking your tasks down into subtasks until you can arrange them all into similar subtasks even if the main task is different. I'll use the example of a blogger. In order to write a few blog posts you have to do research, create visual aids, and write and promote the post for each post. Make those into subtasks and you'll quickly see that they all require completely different patterns of thoughts. So instead of writing a complete blog post each day of your working week you should try doing all the research for every post on Monday (bonus it will percolate in your brain and new ideas will form subconsciously), all the design on Tuesday etc. You'll find it much easier to get all the tasks done as your brain will spend the whole working day in the same mode and be more efficient.

Single monitor

For the same reasons above I long ago ditched multi-monitor setups. This one may be more of a spicy take as so many people swear by them, but I think many people stand to gain from ditching the extra monitors on their desks. It's not helpful having so much information in our faces if we can't parse it all at the same time. Eliminate the distractions and just focus on one thing at a time. For me, a laptop with at most 2 windows docked side by side is enough, and most of the time I have a single window visible to avoid being tempted to context switch by another window vying for my attention or the desire to try and use another tool to help me achieve my current task when really I just need to sit still and do it.

Remove items that promote multitasking from your workspace

Your mobile phone should be nowhere near where you work if you want to focus for any more than 5 minutes at a time. Move it away or hide it, it's designed for perfect multitasking and it needs to go.

Don't eat food at your desk and try to work, both will suffer. Eating should be a pleasurable experience, and you can't focus on work fully if you're eating. Do them one by one, not together.

Try going analog

It's a lot more difficult to be distracted by a piece of paper than a device capable of accessing endless memes. If it is at all possible with your work, scrap the laptop and use a pen and paper. If you're planning a project you can sketch it out on paper (side benefit: you aren't as constrained as most programs for project planning are).

If you can't use a pen and paper, maybe you can turn off the internet on your device, this will help remove the temptation to "simply check social media or emails" which will derail your focus and attention.

If you need the internet at all times to work then at least disable notifications so you're not being actively begged to context switch.

Make it clear to coworkers that you're focusing

It's nice to chat with coworkers during the day and I'm not saying you should be focusing monastically all day every day, that is not healthy, but you should try and schedule when you allow distractions that will cause you to context switch, and coworkers are often one of the biggest causes of distraction. How many times have you been in the middle of a tricky problem, a coworker has chatted to you for a minute or so, and you completely lose your train of thought?

I work in a coworking space in London and I know most of the people here. We chat regularly but I have some sizeable noise-cancelling headphones that are a pretty clear symbol I use when I don't want to be disturbed. I usually take them off whenever I've reached a natural pause in my work and then people know they can come and have a chat. Try it with your coworkers, have some form of signpost for them like big headphones so they know when they can come and disturb your focus.

Conclusion

We are more and more aware that multi-tasking isn't productive, the danger of it is in the context-switching penalty that we have to overcome. All of the strategies above have worked well for me to curb context switching and I hope they'll do the same for you. Your mileage may vary with which approaches work best but hopefully, you will have gained something from trying them.

Why do they suck?

• To-do lists are conventionally 1 dimensional. It's great for a shopping list where all the items are of roughly the same complexity to tick off (unless your list contains sugar and some real niche seaweed that can only be bought from a specialty shop during a full moon). It sucks if you have a list of tasks that are of varying complexity.

  If your to-do list for the day is "write a blog post", "do the laundry", "wash hair", then you're going to struggle as soon as you reach "write a blog post". This is because the task is not nearly specific or planned out enough for you to get started without a huge cognitive strain to think about all the steps that need to be taken to accomplish that task. The problem is that if you write down all those steps in a conventional list then it is going to be enormous and you're going to be overwhelmed and anxious. And what happens if you don't finish all the steps to complete "write a blog post" in one day? You feel bad, and it makes you think that you've been unproductive when you may have just bitten off more than you can chew. Having a task like "write a blog post" that could take days to complete is terrible for our sense of productivity as it lingers on our list. We all know how nice it is to get to the end of the day having ticked all the tasks off our list and seeing a blank slate for tomorrow. It's a great feeling, and it's a feeling that we should be able to have every day. The problem is that we're not using the right tools for the job.

• To-do lists don't have a way to show you just what you need to do today. To effectively use your day you should do some level of planning in advance as planning and doing are two different modes of thinking and it's good to batch them for maximum efficiency. A normal to-do list has many tasks on it that you aren't going to complete today but part of your brain will think about when you look at the list. You want as much of your focus as possible to be on what you need to do today, not the random errand you need to do for your neighbor on the weekend.

• Many task management apps have lots of automated workflows that ostensibly help keep you productive. In reality, many of those automations are either a distraction or in fact harmful to our long-term productivity as they teach us bad productivity habits. For example, if you have a task that is due today, but you don't complete it, then it will automatically be moved to tomorrow. This is a problem because you can just put it off until tomorrow knowing that you'll be reminded, it's enabling your lazy brain to have an excuse for putting off the task easily. This leads to a cycle of doing things at the very last minute and then half-assing them.

• To-do lists aren't good if your priorities change. If you have a list of tasks you need to do today and then something urgent comes up, you have to go through the list and shuffle everything around to fit the new task in. This is a waste of time and energy, especially if you're using your list to plan a big project and suddenly have to remove loads of tasks for a feature that was suddenly dropped.

• To-do lists are not good for planning projects. If you have a big project that you're working on, you're going to need to break it down into smaller tasks. This is a good thing to do, but it's not good to have all those tasks on your to-do list at once. It's overwhelming and it's not going to help you get the project done any faster.

How to fix them

• Add a 3rd dimension (hierarchy). Adding collapsable subtasks to to-do lists is great as it immediately solves the problem of having tasks of different complexities next to each other. You can easily see how complex a task is based on how many levels of subtasks it has and plan accordingly from there.

• Make it easy to cherry-pick tasks for your day. You need to be able to quickly add tasks to your plan for the day in such a way that you won't be able to see all your other tasks staring you in the face all day. This is essential as it cuts down the difficulty in focusing from having to ignore lots of things to simply taking each task one at a time. Bonus points if you can prioritize your daily tasks in the morning and then not touch them unless you're ticking them off.

• Break down your biggest projects into smaller and smaller chunks so they effectively work with the two points above. You should be able to see which areas of your project need to be worked on to accomplish various goals. This is a great way to make sure that you're not forgetting anything and that you're not getting overwhelmed by the size of the project. It's also really useful nesting projects so that when you're planning your day you can grab tasks from any level of the hierarchy you feel comfortable completing in a day. That way there's no excuse for not completing your daily list.

• Keep it simple. Don't add workflows that are going to make you lazy, they will seem like a great idea initially but will in fact hinder you in the long run, and also often end up being useless when not used in a very specific way. The power of your to-do list should be coming from the way it reflects your mental model for how you want to get things done, not from the app itself. The best to-do list app is the one that gets out of your way and lets you get things done.

What I use

I have tried many to-do list systems over the past 10+ years. I first used pen and paper as it was natural and flexible however I swiftly ran into problems when I wanted to prioritize tasks (you can't exactly drag and drop tasks around the list). I then switched to Wunderlist (RIP) which was a huge step up for my productivity and while I was a student at school it worked perfectly as I never really had to plan anything very complex. When I reached university Wunderlist had been acquired by Microsoft and folded into Microsoft to do, it is still a good app but at university, I was planning more complex projects and had outgrown it. I started looking at task management platforms but they were all way too complicated and messy for what I needed, and often focused more on businesses than individuals, so I came up with my own simple solution. I used a text file with indentation to represent subtasks and my productivity skyrocketed! The power came not from a complex app but from a simple structure that worked for me. I used it for a few years before deciding that it was a pain to sync across my devices, didn't allow me to schedule things easily, didn't have a natural way to cherry-pick my daily tasks, and wasn't particularly good for prioritizing easily.

Finally, I decided to build my own app - Tatask - you should check it out. It's designed to work as the perfect to-do list/task management app for your life. Everything is nestable, you can add tasks to your daily plan with a click, you can prioritize tasks, and you can schedule tasks for a specific time. I use it every day and it's the best to-do list app I've ever used. I hope you find it useful too.

I'll use the analogy of an old-fashioned steam train on a track to illustrate how certain things can keep you on track and how to avoid being derailed by distractions. We'll think of you as the driver, and the passengers as your thoughts and ideas that need to be brought to life/transported to their destination.

Your environment matters

We all know that it's nearly impossible to work if there's a jackhammer going on outside our window, but people seem less concerned about how to reach the other end of the work-environment-zen spectrum. Roald Dahl used to work in a shed at the bottom of his garden and Maya Angelou would rent a hotel room to write in because she knew she wouldn't be distracted there. I'm not saying you need to go to those extremes, but you should be aware of how your environment affects your ability to focus. Having a good work environment is like having a well-maintained train track. It's not going to make the train go faster, but it will make it easier to stay on track.

So how can we set up an anti-distraction work environment? Let's deal with the low-hanging fruit of distractions first and then focus on how to set it up for flow.

1. Turn off all the notifications on your phone and laptop. This is such a simple thing to do, but it's so effective. You don't realise quite how many times you get distracted by your devices until you look at the number of pickups on your iPhone screen time report. It's actually astonishing. Our brains are terrible at context switching, so every time you get distracted by a notification, it takes you a few minutes to get back into the flow of what you were doing. That's like bringing your train to a complete stop and then having to get it back up to speed again. So much wasted time!Even better than turning off notifications is to put your phone in another room. This Dataquest article is a simple explainer of the so-called phone proximity effect. In short, you get distracted subconsciously by your phone even if it's not making any noise.

2. Use sound to get you in the zone. A good playlist can change your mood entirely. I usually go with classical/electronic music without lyrics as that seems to work best for me. There are also some great white noise apps out there if that's your thing. Anecdotally, music helps occupy the part of my brain that is seeking distractions subconsciously. Turning on some music occupies that part just enough that it doesn't go seeking out extra dopamine hits in the form of checking my phone or opening a new tab. On our train it's important to have some music playing to keep the passengers entertained, but not so loud that it distracts the driver. we don't want any passengers jumping off the train when we slow down because they are bored with the journey.

3. Environmental consistency. If you set up your environment the same way each day and get into a nice habit of focusing and doing work once in that environment then you will find it easier and easier to enter the flow state each day that you sit down to work. This is like having a well-maintained train track. You know that the train is going to run smoothly and you can focus on the task at hand. If you're not worried about the track being broken up ahead you can go much faster.

Build momentum

The more momentum you have the harder it is to stop the train, that's obvious, but it's also true that the more momentum the train has the more damaging it is if it gets derailed. This is also true with distracted work, if you're deep in the zone and have many ideas flowing perfectly through your brain they can all come crashing down in one go and then you've lost a huge amount of productivity as you'll have to pick up the pieces again once you restart.

The solution to this is to break your work down into the smallest discrete tasks you can and then focus on them one at a time. This is beneficial for two reasons. Firstly, it's easier to get started on a small task than a big one. Secondly, if you get distracted while working on a small task it's much easier to pick up where you left off. I built Tatask for exactly this reason. It's a simple task management app that lets you break down your tasks into subtasks and then focus on them one at a time. Back to the train analogy, this is like building more stations along the track so that you can get passengers to their destinations quicker, the more stations, the closer the station is to the passenger's final destination. If we have small tasks we can also focus all our effort on getting that one task done and moving on, plus we'll get a nice dopamine hit/feeling of accomplishment when we tick it off the list. Closer stations mean less coal (willpower) needed to reach each station and we get a nice top-up of coal (dopamine boost for completing a task) when we reach each station.

Do the hardest thing first. In order to build momentum we should try to pick the hardest task to do first. If we can conquer the biggest hill then all subsequent stops along the track will be easy by comparison and we'll have some nice downhill momentum. If you know that something difficult is coming up then it will take your attention away from everything else. It's like having an enormous mountain in the distance down the track, if it's so daunting then all the passengers are going to be looking at it and not focusing on their destinations.

Take breaks wisely

A trick I learned fairly recently that has been amazingly useful is to schedule breaks not when you've finished a task, but when you're in the middle of a task and know exactly how to proceed. If you know you need a break then having everything set up and ready for your return is going to greatly improve your chances of getting back into a flow state quickly. I am sometimes writing code, need a break and I'll write some pseudo code for what I need to do next so that I have a springboard to jump off when I get back to work. This is like having a downhill section of track to use after you've stopped at a station, all it takes is a tiny push to get going and then you're moving. Don't make it difficult to rebuild momentum by having to do hard thinking without any momentum to back you up.

Monotask

Drifting a train across 2 sets of tracks would be incredibly cool, but also wildly inefficient and slow. Focus on one thing at a time and you'll get it done much quicker. Imagine that on your train's journey, you need to visit a point due north of your current location and then a point due east of there. If you go north for a bit, then east for a bit, then north again, then east again, you're going to be wasting a lot of time and energy turning the train in a slow arc to avoid derailing. If you go north all the way, make one turn and then east all the way you'll get there much quicker. Breaking your tasks down into discrete chunks also helps you plan your journey as you can order them such that you're minimising wasted time redirecting your train of thought. I find it useful to work on tasks of a similar genre one after the other. If I have coding tasks, writing tasks and design tasks it makes sense to group them as my brain is going to get used to one mode of thinking for each type of task.

There are extensions for Chrome and Firefox that block you from opening new tabs and try to ensure that all links open in the current tab. I find these extremely useful as they force me to get what I need from a page and then move on rather than opening multiple tabs for research and then having them clutter up my mental space. This is like having a train that can only go in one direction. You can't get distracted by a shiny new track if you can only go forwards.

Conclusion

I hope that you've found this article useful in your productivity journey. It's a journey and you're not going to reach productivity nirvana straight away. It takes time to build up the habits and discipline to get into a flow state and stay there. I'm still working on it myself, but I've found that these techniques have helped me a lot. I'd love to hear your thoughts on this article and any other techniques you've found useful. You can reach me at max@tatask.com. If you'd like to try out Tatask you can find it at tatask.com. It's designed to be as simple as possible so that you can get started quickly and not get distracted by the app itself. Happy productivity!

How I like to plan

In an ideal world I settle down to do some work on a Monday morning, instantly reach a flow state, power through my day and by 6pm I've ticked everything off my task list. The bigger the task the more satisfying it feels to tick off, but also the less likely I am to actually complete it. My solution to this is to plan big tasks in a tree-like structure so that I can tick off small tasks quickly and make progress on big tasks:

├── Big Project (eg. Launch new business)
│   ├── Project organisation (eg. Engineering, marketing etc.)
│   │    ├── Tasks (eg. Launch new blog)
│   │    │    ├── SubTasks (eg. Build index page)
│   │    │    │    ├── MicroTasks (eg. Sketch layout on paper)
│   │    │    │    │    ├── NanoTasks (It's not always neccesary to get to this level)

I'm not trying to claim any novelty to this approach at all, just stating how it works for me. While at university I developed this system to organise all my different courses, coursework etc. Originally it was a textfile but that has some drawbacks that i'll cover later.

The main benefits that a hierarchical task system provides for me:

• Easy to see how tasks add up to complete a bigger picture
• Ticking off some small tasks at the beginning of the day helps me build productive momentum which translates to more useful work achieved each day.
• You don't have to look at irrelevant tasks and feel stressed that you're not doing them. If I'm working on an engineering task I don't want to be reminded that I need to buy tofu for dinner.
• It's incredibly satisfying ticking off a large Task with many subtasks, much like closing all your tabs at the end of a project

Why don't you use one of the other 6,072,310 apps?

From what I've seen there are broadly 4 types of task management tool out there: Lists, Kanban, calendars and Hierarchical, I'll cover my problems with the what exists in each category already.

Of course the internet is vast and there might be some magical app that I haven't come across that would fit my working style perfectly but at this point I've done enough searching and decided it's easier to build my own than keep searching, finding one I like and then finding it doesn't work exactly as I desire. Call me pernickety all you like!

List style management

I used to use Wunderlist for everything before it was bought by Microsoft (now it's Microsoft Todo) and continued to use it afterwards for a while. It was and is a great tool. Soon though I needed to plan tasks slightly bigger than 'Do linear algebra homework' and lists just aren't useful when you have big goals. Either you have a list for big goals or you have hundreds of tasks staring you in the face that are often unrelated to each other and difficult to order correctly by priority. Mixing big and small tasks together in one list leads to confusion.

Kanban

After growing tired of Microsoft Todo I jumped on the fashionable Trello to see what the fuss was all about. It is super cool to be able to drag and drop tasks into upcoming, backlog etc. and have some more powerful tools at my disposal for scheduling things (that I end up never really using). Trello is a step in the right direction for me when organising projects as I can have different boards for engineering, marketing, admin etc. and for a while I am contented to drag and drop cards all over the place thinking I'm being really productive.

The illusion is shattered when I realise that dragging and dropping cards into upcoming doesn't actually result in them getting done as all of my tasks are too big and I have to add an intermediate step before starting the task of breaking it down on paper into how I'm going to complete it. A bit annoying and not helpful if I really just want to get started quickly in a spare moment. I tried breaking tasks down using the notes section of tasks in Trello which works and provides endless hierarchy if I use loads of hyphens and indentation everywhere. Not straightforward. Time for another rethink.

Calendars

I use a calendar, but that's for physical plans like meetings or parties, not for blocking out every second of my day. I've tried scheduling tasks down to the minute but as soon as the schedule slips I get stressed about having less time for my next task etc. My working style is much more about planning to get something done and then doing it for as long as needed before moving on. Smaller tasks are obviously best for this as I can come up for air after finishing each one and assess what I need to do next.

Having said that some tasks just need to be done on a certain day so I do need to have due dates occasionally. However it shouldn't be the central organising principle.

Hierarchical management

The obvious conclusion at this point is a hierarchical structure for tasks. It solves all my problems.

So I made a huge text file for anything I was planning and using sublime text it was easy to expand and shrink lines. Everything was nested perfectly and all was right with the world...for a little while.

Then I started missing the nice drag and drop of Trello when I needed to rearrange priorities. I could sync the textfile across devices but it just wasn't a smooth experience on those devices and as something I use every day, a task management system has to be smooth and unobtrusive. UX is paramount when it's used so regularly and any friction causes your little monkey brain to crave procrastination.

Time to look at some existing apps then.

I did some investigation and found a few options that seemed promising: Quire, Workflowy, Taskade etc. but none of them seemed to work right for me. One lacked the clean drag and drop cards I was looking for, another was way too complicated (I want to plan my work using an app, not have the app practically do my work for me with 1000 automated workflows and plugins), most treat hierarchy as an afterthought not the main character, and others were so clearly just designed for businesses not individual users. On that last point, that's not a bad thing as a lot of good work is done collaboratively, but that's not how I plan work and this is about me remember!

At this point it might be obvious that I was hankering to build my own perfect solution and almost dismissing alternatives out of hand. Cuff me.

A few other reasons I built my own

• I wanted a new challenge. I thought it was going to be a week long project to distract me from my other work. I put up a basic landing page, added a subscription plan (I have to pay for firebase somehow) and tweeted to my ~100 Twitter followers about it. It started getting some signups and immediately generated revenue when the free trial period was done. Having seen that, I decided I could focus on it for another month as my other work was chugging along nicely. Now it's 2 months in and Tatask is my full time 'side project', oops.
• Why on earth not? If no one decided to build something because someone else had built one already where would we be? We'd all be wearing identical clothes, living in the same huts and hunting with sharp sticks. I exaggerate but you get the point. We thrive because people are always trying to make things better (or what they believe is better, a few politicians spring to mind here). So why not build something to improve productivity.
• If I'm using an app every day and it doesn't have the perfect UX for me i'm going to start thinking about my own version soon enough.
• I wanted to try a new framework...Alpine js popped up on my radar and I thought it looked cool. Having built the initial version of Tatask using it in a weekend I can now attest to it being incredibly useful and easy to use. Highly recommend.
• Can I really call myself a software engineer if I haven't built a todo list app or screenshot tool?

The dream

My laundry list for Task management boils down to this:

• Hierarchical
• Drag and drop sorting
• Due dates
• Cross device sync
• Designed for simplicity
• Progress tracking

Combine these all together and you have Tatask. Since starting to use it a couple of months ago I have significantly boosted my personal productivity and feel like i'm now thriving rather than just trying to stay on top of everything.

If you like the sound of it feel free to give it a try. I'm betting there are others out there with a similar planning style to me.

Everyone has a picture of how they'd like their life to pan out. Too often though people will say "I want to start my own business", "I want to learn how to code" or "I'm going to travel the world" without having any concrete plan in place to reach those goals. It's like picking a point on a map you want to visit and setting off without having looked at any of the terrains between you and your destination. To reach your target you need to pick a route, even if it's only rough so that your effort of walking/cycling etc isn't wasted going in the wrong direction because you failed to see that there's a massive river between you and your destination and the bridge across it is miles off to your left.

The question is then, how do you effectively set goals and what system do you employ to help you achieve those goals? The first part of the question has been answered many times before and is well covered in productivity circles. Set SMART goals. The second part is perhaps more tricky as everyone likes to work differently. I'd suggest that any system designed to work with SMART principles is ideal and you can definitely level up your productivity using SMART goals even if you just use paper and a pen.

What are SMART goals?

SMART stands for Specific, Measurable, Achievable, Relevant and Time-bound. Let's break those down:

Specific: These goals are well-defined and unambiguous. A good example would be: "Bake a loaf of sourdough using the recipe from BBC good food" as opposed to "Learn how to bake". The former gives an easy action plan whereas the latter leaves you with so much cognitive work to do before you even know where to start.

Measurable: Set goals with numbers attached. Don't say "I'm going to improve my site's SEO", instead say "Write 3 1500+ word blog posts targetting my site's top 3 keywords". The first one it's hard to know when you can tick off the task from your list, the second is actionable and finite.

Achievable: It's important to set goals that you can achieve otherwise you'll become demoralised and end up giving up. Don't set goals that are too easy or you'll never reach your full potential, but don't set goals that are completely infeasible either. Don't try and learn to code in 1 night (Despite what a bunch of youtube videos may tell you), instead set the goal of building a specific small project using code over the next week. In my experience I find setting a goal that I think is slightly beyond my capabilities is where I thrive the most. It forces me to learn new things and the sense of achievement when I do end up hitting that goal is phenomenal.

Relevant: Make sure that your goals align with your values and ideals. If you're setting small goals to achieve larger goals then make sure that the small goals will move you in the right direction when you achieve them. There's no point in working on tasks that don't align with your overall goals in some way, you're just wasting precious time. That's not to say you should only work on things that are perfectly aligned with your goals as often working on something tangentially related has the benefit of showing you a new way to achieve your main goal from a different angle. An example of this would be a lumberjack taking some time to sharpen their axe, in the short term you're not going to be cutting down any trees but once it's done your tree-cutting ability will be far greater and the lost time will soon be made up for. They may even spot a chainsaw in the shed (a different angle to more efficiently achieve the overall goal).

Time-bound: Ensuring that you set a time period to complete a task/goal is important to give you the best chance at completing said goal. Setting deadlines and estimating how long a task will take is a good way to make sure you're not overburdening yourself. A huge benefit of having deadlines is that you can ignore those that are far away and focus on those that are more pressing. This frees up brain power to concentrate on what's in front of you right now. If you have estimated task completion times you can also get cracking on tasks when you have a spare moment as you know you'll be able to complete them in that time instead of being cut off mid-flow.

How to plan and organise SMART goals

So you're on board with SMART goals, how do you implement them? This is where I differ in opinion from most articles I've seen. It's ok if not every goal is SMART as long as their subtasks are SMART. I think people get too wound up in their systems and how they should do something to the point that they never actually start anything. I'm saying that you should have SMART goals but you shouldn't focus too much time and energy on making every goal perfectly SMART, give yourself some flexibility. Often just getting started on something you will find you know how to do it already. SMART goals are important for the bigger things that you can't keep the entirety of in your head at one time. You'll also find that the more you utilise SMART goals the more natural it will feel until you don't really have to think about it anymore.

To plan your SMART goals effectively it is important to have visibility over the tasks that you will complete to achieve your goal. A good way of planning your goals is to take your biggest goal and then break that down into subgoals that will help you achieve the main goal. You should then keep breaking down those subgoals in a SMART way until you have lots of small tasks that can each be completed in under an hour. By doing this you're setting yourself up for success as you won't put off a task because it will take a day or a week to complete, you can simply break that task into smaller chunks, make a start and then suddenly you're making progress towards your bigger goal.

Breaking tasks down like this can be done on paper but it gets really messy very quickly with nested bullet points especially if you need to edit a task or suddenly realise a task needs more breaking down. Paper also has the habit of getting lost. In the past I have found some success using a simple plain text file. This allows infinite nesting, editing, and is unlikely to get lost if you keep it saved to the cloud somewhere. It's a good solution but doesn't have the best user experience when it comes to rearranging tasks and it can also be overwhelming to see an enormous text file with every task you have on it, furthermore, plain text in this nested structure is hard to scan and find what you need to work on each day.

I ended up researching a load of task management tools designed for SMART goals and found that none of them behaved quite the way I wanted and very few were even able to work in a nested structure as described. In the end I decided to build my own, Tatask, I'll explain why I think it's the best SMART goals tool out there below.

Why Tatask

I built Tatask from the ground up with nested SMART goals in mind so that I could be as productive as possible. I'll explain why it is designed in the way it is to fit SMART principles. If you haven't seen it already, Tatask is a nested task management app that works very similarly to the filesystem on your phone/computer. Tasks are organised inside each other so you can break them down into nested subtasks and everything wrapped in a simple, user-friendly, interface so that the organisation of your tasks takes as little time as possible and you can start working on your tasks!

Specific: The very nature of nested tasks sets itself up for specificity. Even if your top-level goals aren't specific, once you've broken it down into a few layers of subtasks the lowest layer will necessarily be more specific than the top. This is hugely powerful for helping you to set goals in a way that leads you to achieve them.

Measurable: This is somewhat up to you to ensure yourself but Tatask does have some very satisfying animations when you tick off a task so you'll want to set tasks that will have a defined endpoint for you to check them off.

Achievable: No tool can tell you what is achievable for you, you know yourself best. Having said that if you lean into the SMART Tatask way of organising your goals then you might surprise yourself with how much you can achieve when your effort is all aligned in the right direction.

Relevant: Nesting really helps here as you can easily see whether subgoals are relevant to the parent goal. If a task doesn't contribute to the completion of its parent in some way then it's probably not relevant and you should scrap it or find a way to make it relevant to one of your goals.

Time-bound: Making tasks time bound is something Tatask is great at. It's easy to set due dates in most task management apps and of course, Tatask can do that! The more useful part of Time-bounding is when you set tasks that can be completed in a short time frame ie. those tasks that are the smallest subtask which might take only 20 minutes. If you can time-bound subtasks to fit in your attention span then you never have to think about coming back to a piece of work and forgetting what you were doing. You can enforce this really easily in Tatask if you just make sure to break up tasks until they can be done in less than an hour/30 minutes.

The role of regular review

Going back to the journey analogy from earlier it is important to regularly take a moment and take stock of where you are currently. Firstly because you may suddenly be able to see new routes forward from your current vantage point that were invisible before and secondly because it's important to celebrate how far you've come so far.

If you are taking a break and a new way of achieving your goals becomes apparent given the lessons you have learned since starting then naturally you should reassess how you are going to continue the journey to complete your goal. It might be possible to continue along how you started but it also might be far more efficient to go in a new direction knowing what you know now. After all, what's the point of wasting time and energy when there's a better way to achieve your goal? Review the new terrain in front of you and using this new information you can update your plan for proceeding in the future.

Celebrating how far you have come already is important too. Too often I see people who are incredibly focused on their goals, and achieve many things but never take a moment to look up from the treadmill at how far they have come. Life to them is just a never-ending series of tasks without any sense of accomplishment. Make sure you look up at what you have done, appreciate it fully and only then continue along the journey. You'll feel a greater sense of motivation to achieve more down the line and you'll feel a deeper sense of satisfaction in your life.

Thanks for reading! If you got this far and agreed with at least some of what I wrote then please do give Tatask a try. I want to empower everyone to be as productive as they can be as I think that it can lead to a very fulfilling way of life.