A year ago I deleted Things, archived my Notion task DB, closed every kanban board, and made one rule for myself: every obligation lives in my email inbox or it doesn't exist.
I'm a solo dev. Nobody assigns me tickets. The only thing I have to coordinate is me-now talking to me-tomorrow. So I wanted to find out what actually happens when "task tracking" stops being an app and becomes a single, boring inbox.
Twelve months in, here's the honest report.
TL;DR
- Treating my email inbox as the only task queue cut my daily app-switching from around 40 hops to under 10, measured with a tiny script for two weeks.
- The model only holds if you commit to two rules: end-of-day zero-inbox, and any obligation that isn't already an email gets emailed to yourself within 5 seconds of thinking it.
- It broke in three predictable places — multi-day backlog, multi-step projects, and recurring tasks — and the patches are smaller than building a "real" tracker on top.
The setup
The trigger was embarrassingly small. I was on a walk in March, thought of a one-line bug fix, and reached for my phone to add it to my Things inbox. By the time I had unlocked the phone, opened Things, tapped the plus button, waited for the input field, typed the thing, and chosen a list, ninety seconds had passed. The thought I started with was already softer.
That night I counted: I had 312 open tasks across Things, Notion, GitHub Issues, two Linear projects from old contracts, a Reminders list for groceries, and Slack saved items I'd been ignoring since January. None of these systems talked to each other. Each one demanded its own ritual to enter and its own ritual to clear.
So I tried something stupid on purpose. I deleted Things from my phone. I exported the rest into a single text file, archived that text file, and decided that for one quarter the only place a task could live was in my own email inbox. If I forgot it, fine. If it mattered, future-me would email past-me about it eventually.
That quarter became a year.
What I tried first (and why it failed)
This wasn't my first run at unifying task tracking. Over five years I had cycled through OmniFocus, Things, Todoist, Notion databases, Apple Reminders, GitHub Issues even for personal stuff, plain markdown files in a tasks/ folder, and the back of my paper notebook. Each one felt clean for about three weeks.
The pattern was always the same. I would set up a beautiful taxonomy. I would import old tasks. I would feel productive about the meta-work of organizing. Then within a month the system would split — some things in the app, some things in email, some things in Slack, some things in my head. The system that was supposed to be the single source of truth had become one of seven sources of truth.
The deeper problem wasn't the apps. The deeper problem was that capture and review were separate rituals. Capture happened on my phone, in apps I had to open. Review happened on my laptop, in a different app I had to open. The two rituals never aligned, so the queue I captured into was never the queue I reviewed from.
Email already solved that. Capture from anywhere, review from anywhere, single inbox, archive when done. I had been ignoring the most-used piece of software on my devices because it didn't have "task management" in the name.
The thing that actually worked
The whole system fits in two sentences:
- The inbox is the queue. Anything not in it does not exist as a task.
- End every workday with the inbox at zero — meaning every email is either replied to, archived, or scheduled-send back to myself for the day I actually want to deal with it.
That second rule is doing all the heavy lifting. Scheduled-send turns email into a deferred queue. "Email me on Tuesday with the migration checklist" is one keystroke away on Gmail and Apple Mail. The thing I would have put in a "Someday" list now arrives in my morning inbox on the day it becomes relevant.
For capture-from-anywhere I use the simplest possible rig: an iOS shortcut that opens a one-field compose window pre-filled with my own email address. One tap, type the thing, hit send. The note shows up in my inbox in under a second. The whole capture takes about three seconds, including unlocking the phone. That ninety-second walk-thought from March takes three seconds now.
I measured the impact in two ways:
- A small script counted how often I switched between apps on my Mac during the day. The two weeks before deleting Things averaged 38 task-related app switches per day. The two weeks after averaged 9. The cost of every "let me check my system" moment is gone, because the system is the same window I already have open.
- I kept a one-line journal note every Friday: "did I forget anything important this week?". In the year before the experiment that note had a "yes" 22 weeks out of 52. In the year of inbox-as-queue it had a "yes" 6 weeks out of 52, and three of those were obligations from people who texted me instead of emailing me — which is a different problem.
Where it broke (and the patches)
The honest part. Three failure modes.
Backlog days. Some days I cannot get to inbox zero. A trip, a sick day, a launch crunch. The inbox piles up and the next morning is psychologically heavy. The patch was banal: I gave myself permission to open the inbox, select all, archive everything older than 7 days, and trust that whatever mattered would email me again. In a year that "mass archive" move has nuked something genuinely important exactly twice. Both times the sender followed up. The cost of the rare miss is much lower than the cost of carrying a permanent backlog.
Multi-step projects. "Ship the new export feature" is not a task, it's a project. Email is bad at projects because each email is flat. I tried to make threads work as projects and gave up. The patch is that I keep one plain markdown file per active project, named 2026-export-rewrite.md, in iCloud Drive. The inbox holds a single email titled "Project: export rewrite (link in body)" with a link to that file. The email is the entry point. The file is the workspace. When the project ends, I archive the email and the file together.
Recurring tasks. "Pay the AWS bill on the 1st" doesn't fit. Email is event-based, not schedule-based. I tried scheduled-send to myself every month, and it works for low-volume things, but for ten or twelve recurring obligations it becomes its own admin job. The patch is to keep recurring tasks in Apple Calendar with alarms, and accept that calendar is a separate system. Two systems is still a lot fewer than seven.
What I'd do differently if I started today: I'd accept the calendar split from day one instead of pretending email could swallow scheduled events. That fight cost me a month.
Takeaways for other solo devs
If you're shipping alone and tempted to try this:
- Stop searching for the perfect tracker. The cost of switching trackers is higher than the cost of any tracker's missing feature.
- Make capture cheaper than thought. If your capture ritual takes longer than three seconds you will lose tasks no matter how nice the app is.
- Trust scheduled-send. It turns the inbox from a flat queue into a time-aware one without adding a second tool.
- Let recurring obligations live in the calendar. Don't try to unify everything.
- Re-archive aggressively. A backlog you can't face is worse than a backlog you delete.
Open question for the comments
I'd genuinely like to hear how other solo devs and small teams handle this. Has anyone here tried treating their inbox as the single queue and stuck with it? Where did it break for you, and what was the patch?
If you went the opposite direction — committed harder to a structured tracker and got rewarded — I want to hear that too. I'm not religious about this.
I'm a solo dev. The capture rig described above is essentially the iOS app I built — Captio-style Simple Memo — which sends a note to your own email in about 0.3 seconds. I write here every few days about the messy parts of shipping things alone.
Top comments (0)