Why 'Soon' Never Happens

"We'll do that soon."

Listen to that sentence again. It sounds like a plan. It isn't. It's the sound of work being set down with nobody assigned to pick it back up. "Soon" is not a time. It's the absence of one — a polite way of saying this matters, and also nothing is going to make it happen.

We treat "soon" as a backlog problem. It isn't. It's a custody problem. The work doesn't die because it was unimportant; it dies because the moment you said "soon," it stopped having an owner for its next step. And anything without an owner drifts.

"Soon" is what work becomes when nothing carries it forward

Watch where a "soon" actually lives. It's a line in a thread. A nod in a meeting. A half-formed task with no date. The decision got made — yes, we'll do this — but the next action was never handed to anything that would carry it. So it sits. Not because anyone decided to drop it. Because there was nothing underneath to hold it up.

This is the quiet mechanic behind every "soon." Work moves only when something owns the next step. In most companies, that something is a person's memory — and a person's memory is busy doing the actual work. So the next step waits for that person to remember it, surface it, chase it. Most of the time, they don't. Not from negligence. From load. That load is the coordination tax: the work doesn't move unless a human pushes it, so it moves only as fast as a human can hold it in their head.

That's the real thing the old advice misses. "Force a now-or-never decision" assumes the problem is indecision. It usually isn't. You did decide. You decided yes. The work still drifted — because the next action lived in the gap between deciding and doing, and nothing was standing in that gap to carry it across.

Give the next step to something that doesn't forget

The fix isn't a harder rule about what's allowed in your backlog. It's removing the reason "soon" exists in the first place: a system that holds the next action instead of leaving it to a tired human to remember.

WorkElate is built on one brain — WAO — sitting above your apps, watching the same work-graph you'd otherwise carry in your head. Every app emits what happened: a card moved, a thread stalled, a deadline neared, a hand-off landed. So the next step isn't a thing someone has to recall — it's a thing the system already knows, because it watched the work create it. When that step is low-stakes and reversible, WAO does it. When it's higher-stakes, it surfaces it and asks: suggest, confirm, execute. Either way, the thread is held.

That's the whole difference. A reminder app still waits for you to set the reminder. A system that owns the next step doesn't wait for you at all — it carries the work forward and only stops to ask when stopping is the right call.

When something is holding the next step, "soon" loses its meaning. There's no limbo to drift into. The work is either moving or it's an explicit, owned decision not to move it — never the third state, the one where everyone agreed and nothing happened.

So here's the question worth sitting with. The last thing you said "soon" to — was it ever unimportant? Or did it just never have anything but you to carry it?

And if a system carried it instead, what would you stop losing?