You’ve given the work to someone else. You’ve provided context. You’ve explained what good looks like. And three weeks later, the same category of decision is back at your desk, just routed through a different person.
This isn’t delegation failure. It’s structural misdirection.
When delegation doesn’t stick, the assumption is that you delegated wrong. You didn’t communicate clearly. You didn’t set expectations. You chose the wrong person. So you try again — more detail, clearer rubrics, more frequent check-ins. And the work still returns.
The reason is that you’ve been solving at the instance level while the problem lives at the category level.
Here’s the difference. Instance-level delegation is “Sarah handles this vendor contract.” Sarah gets the work. She processes it. The contract gets done. But three weeks later, another vendor contract arrives. At your desk. Because nothing changed about the routing rule. The unwritten rule still says that vendor contracts route to you. You manually redirected one instance. The system remains unchanged.
Category-level delegation is different. “All vendor decisions flow through Sarah’s role.” That includes her authority to decide without escalation. It includes the formal escalation rule if something exceeds her scope. It includes the context transfer — how she learns what she needs to know when she takes the role. It includes who fills in when she’s unavailable. It’s not one decision reassigned. It’s a routing change embedded in how the structure operates.
Instance-level delegation is temporary work. Category-level delegation is permanent structure. One is a favor you’re doing right now. The other is a rule that persists whether you’re thinking about it or not.
Most organizations operate almost entirely at the instance level. A manager assigns projects. A leader redirects questions. A senior person mentors a junior person through a decision. Each instance works. But nothing sticks. The structure hasn’t changed. Only the coordination has — and coordination requires someone to keep making it, indefinitely.
This is why hiring doesn’t solve the problem either, even though everyone assumes it does.
Hiring is the most expensive way to not solve a structural problem. You add a person to carry capacity. But that person enters a system with undefined authority, context held by you, and informal decision-making. They ask you for guidance. They need you to explain the context. They make a decision and you reverse it because they missed something only you know. Your load increases, because now you’re managing the new person on top of everything else. You’re not scaling. You’re multiplying the coordination layer.
The same thing happens with boundary-setting. You say no to something. The work doesn’t disappear. It stalls, gets worse, or someone else does it badly. Then someone asks you to step in, just this once. And you do. Because the system never changed. You just interrupted the flow for a while. Saying no doesn’t change who the structure routes to. It just introduces a delay before the routing happens anyway.
Instance-level solutions — delegation, hiring, boundaries — operate below the threshold that actually changes how work flows. They rearrange the immediate load. They don’t change the level at which the bottleneck operates.
The mechanism is always the same.
Competence became routing. You were good at something, so people brought it to you. You were responsive, so they kept bringing it to you. You were present, so the structure learned to route through you. Not because you chose it. Because you were available and capable, and systems do what systems do — they optimize toward the easiest path.
Routing became accumulation. Every instance of that category of decision now flows through you. Every question, every vendor interaction, every hiring decision on that dimension.
Accumulation became lock. Now you can’t step away. Too much depends on your presence. Too much context lives in your head. Too much decision-making authority has collapsed into one person.
The structure is holding you in place. Not deliberately. Not maliciously. Just functionally. You are where the problem shows up. But you are not the problem.
The problem is that the category-level routing was never formalized. Decision authority was never transferred to a role — it was only ever delegated as tasks. Escalation rules were never established. Context was never extracted and made transferable. The structure was never built, and so it continues to find the person most available to carry it.
When delegation fails, the instinct is to look at the person you delegated to. Maybe they weren’t ready. Maybe they misunderstood. Maybe they need more support. But if the category-level routing hasn’t changed, that person is in the same structural position you are. They inherit your bottleneck. They become the node. They need guidance for the next decision that looks similar but not identical. They need context that only exists in someone’s head. They need authority that was never formally transferred.
They’re not failing at the role. They’re occupying a structural position that was never properly built.
Instance-level delegation without category-level routing is paying someone else to be confused on your behalf while you remain the final routing point. It looks like delegation. It feels like progress. But nothing structural has changed.
The work that should have been made into a formal role — with clear authority, escalation paths, and knowledge transfer — is still a series of manual redirections, now flowing through one more person before it comes back to you.
You are not the problem. The structure that keeps routing everything through you is the problem. And structures don’t change because one person says no harder or delegates more carefully. They change when the routing rule itself changes — when authority moves from person to role, when decision-making is formalized once instead of remade indefinitely, when knowledge is extracted from heads and placed into something others can access.
That’s when the work actually goes somewhere else. Not because someone is better at it. But because the system stops routing it back to you.
---
Steven Rudolph is the author of Renergence and Multiple Natures. These articles look at why some situations work and others don’t — and what’s actually going on underneath.
