The work nobody is assigned

Every business has someone in it who is quietly load bearing. Not the most senior person, and often not the highest paid. The one who notices that the invoice has not gone out, remembers that the client asked for something three weeks ago, works out who should deal with it, and then chases that person until it is done. Take them out for a fortnight and the business does not collapse, exactly. It just stops moving in a way that nobody can point at.

Ask what that person's job is and you will get an answer that has almost nothing to do with what they actually spend their day on. Operations manager. Chief of staff. Founder. Office manager. The title describes the work they were hired for. It does not describe the work that would break first.

Twelve jobs, no owner

Write down what that person is actually doing and it comes to about twelve distinct things. Not twelve tasks, twelve kinds of work:

1. Noticing when something is wrong
2. Remembering what needs to happen
3. Deciding who should act
4. Chasing people for completion
5. Interpreting what the information means
6. Deciding what matters
7. Training themselves
8. Monitoring performance
9. Following up, repeatedly
10. Identifying risk
11. Working out whether it worked
12. Stepping in when execution starts to drift

Now try to find any of those in an employment contract. They are not there. They are not in the org chart either, and they are not on the process map, because processes describe the work rather than the holding of it. Every one of these twelve is unassigned, and every one of them is being done, which means it is being done by whoever notices first.

This is the part that is worth sitting with. The reason your business runs is not that these twelve jobs are handled. It is that a specific person's conscientiousness is quietly covering for the fact that they are not.

Why hiring does not fix it

The instinctive response is to hire. Get someone more organised, or more senior, or give the load bearing person an assistant. This works for a while and then reproduces the problem one level up, because you have not moved the twelve jobs anywhere. You have added a second person who now also has to notice, remember, decide, chase, and check, and you have added the overhead of the two of them staying in sync about which of them is doing it.

The second response is process. Write it down, define the steps, agree the handoffs. This is genuinely useful and it addresses about four of the twelve. Process is excellent at what should happen and completely silent on noticing that it did not. A written procedure has never once observed that step three was skipped. Somebody has to read the procedure, compare it to reality, and raise it. That somebody is job one, four and eleven on the list, and the procedure did not remove them.

The third response is software, and this is where it gets interesting, because software should be exactly the right answer and mostly is not.

Software remembers. It does not notice.

Look at what business software is actually good at. It holds your customer list. It holds the invoice, the ticket, the contract, the project plan, the report. It holds them accurately, indefinitely, and retrieves them instantly. As a memory it is better than any person who has ever lived.

Then look at what it does with that. Nothing, until someone opens it. A CRM does not notice that a deal has gone quiet for eleven days; it faithfully records that the last activity was eleven days ago and waits for a human to draw the conclusion. A ticketing system does not decide that this is the third failure of the same unit and therefore a replacement question rather than a repair question; it stores three tickets. A project tool does not observe that two dependencies are open three days before a launch date and conclude that the date is gone; it shows the date as green because the date has not passed.

Every one of those is job one on the list. Noticing. And the software, which has all the information required to notice, does not, because nobody built it to. It was built to be a filing cabinet with a very good index.

So the loop stays with the person. Software holds the facts and a human holds the loop: observe what is happening, judge what it means, act or route it to whoever should, verify it actually got done, learn from the result. Five steps, and the software participates in exactly none of them except as a place to look things up.

The dependency nobody planned

What makes this expensive is not the labour. It is the concentration of it. Because these twelve jobs are unassigned, they accumulate in whoever is most conscientious, and conscientiousness is not distributed evenly. In most businesses under a few hundred people you can name the individual. Often you can name them instantly, and that instant recognition is the whole problem.

You now have a single point of failure that appears on no risk register, has no documented handover, and is invisible in every system you own. Nobody decided to create it. It formed because twelve necessary jobs had no owner and one person kept picking them up.

And it degrades quietly. As the business grows, the twelve jobs grow with it, but the person carrying them does not scale. What happens instead is that they start triaging: they keep noticing the loud things and stop noticing the slow ones. The pipeline that dries up gradually. The asset that fails a little more often each quarter. The commitment that slips a week at a time. Nobody drops the ball. The ball just stops being watched, in the specific places where watching is least urgent and most valuable.

What the alternative actually looks like

The useful question is not how to help that person. It is which of the twelve jobs should never have been a person's job in the first place.

Look at the list again and it separates cleanly. Noticing is not judgement, it is comparison, and comparison is what software is for. Remembering what needs to happen is not judgement either. Chasing is certainly not. Monitoring, following up, identifying risk from a pattern, checking whether something worked, detecting that execution has started to drift, none of these require a human. They require something that is watching continuously and does not get tired or promoted.

Deciding what matters is different. That is judgement, it should stay with a person, and any system claiming otherwise is overselling. But it is one of twelve.

That is the gap, and it is a software gap rather than a management one. Not software that stores the work more neatly, and not a dashboard that displays the work to a person who then has to interpret it. Software that runs the loop: observes what is happening, judges what it means, acts or escalates, verifies the result, and changes what it does next time because of it.

The distinction between those two things is the difference between a filing cabinet and a system. It is also, in our experience, the difference between a business that depends on a person and one that does not.

Where this leads

Once you accept that framing, the interesting question stops being which tool to buy and becomes which part of your business is most exposed. Different parts fail differently. The pipeline dries up because nobody chased it consistently. Deals are lost by people who were never drilled against a real objection. An operation runs on five employees who each hold a different quarter of the picture. A decision gets approved that the company was never able to carry. And the ones that were possible drift off course quietly enough that nobody notices until the quarter closes.

Those are five different loops, and each one needs closing separately. That is what we build.