A notification is a tax. A coworker pays it for you.

Two screens, same morning. One lights up with a red badge: “Invoice #4471 is due in 2 days.” You stop what you’re doing, open the billing tool, check whether it was already sent, find the right contact, write the note, hit send. Eleven minutes, gone. The other screen says nothing at all, because the invoice already went out at 6am, and the only trace is a line in your daily summary: “Sent. Marked paid-on-receipt. Nothing for you to do.”

The first screen interrupted you to finish a job it couldn’t. The second finished the job.

We’ve been trained to read a notification as helpfulness. It isn’t. Every alert is unfinished work pushed onto you, the software could not finish the job, so it interrupts you to finish it. The badge is not the system helping. It’s the system handing you the part it gave up on.

The thing we call helpful is actually a confession

Here’s the model everyone accepts: notifications are how good software keeps you informed. It watches things you care about and tells you when they change. The more it tells you, the more on top of things you are. We’ve built an entire interface language around it, badges, banners, chimes, the little red dot, and we treat a busy one as a sign the tool is working hard for us.

Look at what a notification actually is, though, and the story flips.

A notification is the moment software reaches the edge of what it can do and stops. The invoice is due, but it can’t decide whether to send it, so it tells you. The spend doubled overnight, but it can’t decide whether that’s fine, so it tells you. The contract expired, but it can’t draft the renewal, so it tells you. Every one of those is the same event: a job started, hit a wall, and got handed to a human to finish. The chime is the sound of work being transferred to you.

That’s the reframe the whole post turns on. Every alert is unfinished work pushed onto you, the software could not finish the job, so it interrupts you to finish it. Once you see notifications that way, a full inbox stops looking like a system that’s informed and starts looking like a system that quit a hundred times today and billed you for the cleanup.

The tax has two parts, and the second one is worse

Call it what it is: an alert tax. You pay it in two installments.

The first is the obvious one, the work itself. Someone has to actually send the invoice, approve the spend, draft the renewal. The notification didn’t do that; it just relocated it to your plate.

The second installment is the one nobody prices in: the interruption. The alert doesn’t wait for a good moment. It lands mid-sentence, mid-thought, mid-meeting, and it makes you switch contexts to deal with it. The University of California, Irvine researcher Gloria Mark, who has spent years studying how interruptions fragment knowledge work, puts the recovery cost at roughly 23 minutes and 15 seconds to get back to a task after being pulled away (Gloria Mark, in Worker, Interrupted: The Cost of Task Switching, Fast Company). So a thirty-second task, delivered as an alert at the wrong moment, can cost you the better part of half an hour of the focused work you were actually doing.

You don’t get a receipt for that. But you pay it every time.

Naive proactivity just sends the alert sooner

So the obvious fix is “be proactive,” and most products mean something very specific by it: notice the thing earlier and tell you about it earlier. Spot the invoice before it’s overdue. Flag the spend the moment it spikes. Surface the expiring contract a week out instead of the day it dies.

This feels like progress. It isn’t, not really.

Sending the alert sooner doesn’t repeal the tax, it just collects it earlier. You still get interrupted. You still context-switch. You still have to open the thing, understand it, decide, and act. “Proactive” in this sense is a faster confession, not a finished job. The software still hit a wall; it just hit it ahead of schedule and told you about it with more lead time. A notification is unfinished work pushed onto you whether it arrives late or early. Earlier is politer. It is not the same as done.

Worse, naive proactivity makes the tax bigger, because the easiest way to look attentive is to alert about more things. More signals, more badges, more “we noticed this for you.” The product feels smart and the user drowns. Every team has lived the version of this where the tool that promised to keep you on top of things became the single biggest source of being buried by them.

Proactive should mean the work arrives done

Here’s the move. Real proactivity isn’t noticing sooner. It’s not stopping.

The difference is where the system quits. A notification is the software telling you exactly how far it got before it gave up, and the whole game is to make it quit later, or not at all. If it notices the invoice but can’t send it, you get an alert and a full tax. If it notices, drafts, and sends, and only writes you a line in the summary, you get nothing to do and almost no tax. Same event. The bill depends entirely on how far down the job the system was built to go.

There are only two honest endings to a job. One: the system was trusted to finish it, so it finished it, and you read about it later if you read about it at all. Two: there’s a genuine judgment call only a human should make, and then the right output isn’t an alert, it’s one decision. Not “here’s a problem, go deal with it.” Instead: “Here’s the renewal, drafted from the template that worked last time. Send it?” One tap. The work is done; all that’s left is the consent.

That’s the line between an interruption and a decision. An interruption hands you the whole unfinished job and a context-switch. A decision hands you a finished job and a yes/no. One is a tax. The other is you doing the only part that was ever yours to do.

A coworker already works this way, and we never call it remarkable. A good colleague doesn’t ping you that the room is double-booked and walk away. They move the meeting and drop a line: “Conflict on the 3pm, moved it to the small room, everyone’s notified.” The hard cases, they bring you finished: “Two options for the client, I’d go with the second, here’s why, your call.” They don’t transfer their unfinished work to you. They absorb it and hand you, at most, a decision. That’s not them being nice. That’s the definition of a coworker instead of a console.

Why the always-on system can finish what the app can’t

The reason an app can only alert, and a coworker can finish, comes down to two things the app doesn’t have.

The first is that it has to already be running when nobody asked. An app wakes up when you open it; by then the moment to act has usually passed, so the most it can do is tell you what you missed. A system that’s always on reaches the event while it’s still actionable. It can do the thing, not just narrate it.

The second is that it has to see your whole world at once. The reason most software gives up early isn’t that the task is hard, it’s that the next step lives in a different app it can’t reach. The billing tool knows the invoice is due but can’t see the contact in the CRM or the thread in the inbox, so it stops and alerts. A system that holds the calendar, the inbox, the CRM, and the billing tool in one context doesn’t hit that wall. It has everything the job needs to actually close, so it closes it. The alert was never about intelligence. It was about reach.

Put those together and the tax collapses. Always-on means it acts in time. Whole-world context means it has what it needs to finish. What’s left to send you isn’t a pile of unfinished work, it’s a result, or a single decision. The notification, that little confession of incompleteness, mostly stops happening, because the incompleteness mostly stops happening.

The turn: you were never supposed to be the finisher

Step back from the badges and the chimes for a second and look at what they’ve actually made you.

Every notification you’ve ever dismissed conscripted you into being the completion layer for your own software. The tools do the easy 80% and route the hard, judgment-shaped 20% to you, dressed up as “keeping you informed.” So your day fills with the residue of a hundred jobs other systems started and quit, and the work that’s genuinely yours, the deciding what’s worth doing at all, gets whatever attention is left after the tax.

The point of building software that finishes its jobs isn’t a quieter phone, though you’ll get one. It’s that you stop being the place unfinished work goes to die. The system carries what it can carry, brings you the few real decisions as decisions, and gives you back the only thing the chime was ever stealing: uninterrupted attention on the part of the job that needed a human in the first place. A notification is unfinished work pushed onto you. The whole promise here is a smaller and smaller pile of it, until the rare alert that does reach you is one you’re actually glad to get.

---

That’s what we’re building at Apollo Space: not a smarter notification, but a coworker that finishes the job before it ever has to interrupt you. If your day feels like paying off other people’s software, that’s not a discipline problem. It’s a tax, and it finally has someone to pay it for you.