Think about the last three things you delegated. Honestly, not theoretically. Now answer two questions about each of them. Where, right now, can you see the current state of that work without asking the person you gave it to? And what is the goal that work is supposed to be moving?
If you had to think for more than a few seconds, you didn't delegate those things. You assigned them. Assignment and delegation look identical at the moment of handoff. They diverge over the following days, and by the time you notice the difference, it's usually the day the work was supposed to be done.
This is the accountability gap. It is the structural distance between "I gave it to you" and "I can see that you have it, I can see what you're doing about it, and I can see the goal it serves." Most delegation in most companies lives in that gap. Most of it doesn't make it across.
Why delegation actually fails
The standard diagnosis of delegation failure focuses on the person. They weren't ready. They didn't prioritise it. They needed more support. They needed clearer instructions. Sometimes that's true. Most of the time, it's a comforting story we tell ourselves because the alternative — that we delegated badly, into a system with no memory — is harder to fix and more uncomfortable to admit.
When a task gets delegated verbally, in a one-to-one, in a Slack DM, or in the hallway, it exists in exactly one place: the recipient's understanding of what was asked. There is no shared artefact. There is no record of the goal context, the expected timeline, the deliverable shape, or the priority it has relative to everything else on their plate. The delegating manager's next interaction with the work is either a status update request — "hey, how's that going?" — or a miss.
That isn't delegation. That's a verbal commitment with a deadline neither side wrote down, and it depends entirely on the recipient remembering, prioritising, and self-reporting correctly. Why would we expect that to scale?
What "the work disappears" actually means
The minute work leaves your mouth and enters someone else's inbox, several things happen that you can't see.
It gets weighed against everything else that person already has. Not against the priority you said it had, but against the priorities they've internalised from every other source — their manager, their roadmap, the most recent fire, their own ambitions. If your delegated task doesn't come with explicit context for why it matters relative to those, it loses, quietly.
It enters a queue you can't observe. You won't see them deprioritise it. You won't see them attempt and get blocked. You won't see them get pulled into something more urgent that consumes the time you were assuming. You will see, at some point in the future, that the thing isn't done. The story between those two moments is invisible to you.
It separates from its goal. The reason you delegated it is in your head. The thing itself is now in their hands. As soon as a new piece of information arrives that should change how the work gets done — a customer signal, a competitive move, a related decision in another team — they don't have the context to update it correctly, because the goal-to-work connection lives in your memory, not in the system.
Three things that make delegation stick
There are exactly three properties that turn assignment into actual delegation. None of them require heroic management. All of them require infrastructure.
The first is a single, explicit, named owner. Shared ownership isn't delegation; it's diffusion. The moment more than one name is attached to a piece of work, accountability becomes negotiable in everybody's head, and the work becomes the responsibility of whoever has the most slack capacity this week — which is rarely the person who should be doing it.
The second is visible progress rather than status reports. Status reports are retrospective by construction; they describe what already happened. Visible progress is real-time; it shows what's moving now, what's stuck, what's been touched and what hasn't. When the work is visible, the manager doesn't need to ask for updates — they can see drift early enough to intervene, instead of getting surprised on the deadline.
The third is the goal context, stated at the moment of delegation and persistent afterwards. The most common reason people quietly deprioritise delegated work is that they don't know why it matters relative to everything else competing for their attention. When delegation includes a sentence like "this moves objective X, which is our top quarterly priority, ahead of objective Y on your current plate," the recipient has the information to make the right prioritisation call without escalating to you every time.
What this requires
Delegation that sticks requires a system where the handoff is visible, the goal connection is explicit, and progress is observable without anyone having to be asked. That isn't a management style you can train. It's infrastructure you have to build.
When work is created inside a goal context — when it carries the objective it serves as a structural attribute, not a footnote — and assigned to a named owner whose performance the goal touches, the delegation becomes structural rather than conversational. Accountability stops depending on either party's memory of what was agreed. It lives in the system, where the next person who looks can see exactly what was asked, who owns it, what it's supposed to move, and where it stands today.
The Vindaris view
We didn't build Vindaris because managers are bad at delegating. We built it because the delegation conversation is doing work that the conversation alone can't carry. Most delegated work doesn't fail at the moment of handoff; it fails in the silent days afterwards, when there is no shared surface that holds what was asked, why, by when, and against which goal.
The fix isn't more 1:1s. The fix is a system where delegation is, by default, traceable — where "I gave it to you" produces a structural artefact, not a memory both parties hope they share. That's not management discipline. That's plumbing. And plumbing is the kind of thing that, when it works, you stop noticing it's there.