/
All articles

Less good solutions

When the key person leaves and nobody dares touch the code

When critical logic lives only in one person's head, that person becomes a Single Point of Failure. How to remove the dependency with open rules, standards and processes that work manually.

By Jens Fahlén · Published · 4 min read

The chaos monster – when the logic lives only in one person's head

Every organisation has at least one such system: the integration engine nobody dares upgrade, the script that runs at 03:00 and moves personal data between three databases, or the access rules only one person understood. In IT infrastructure we talk about a Single Point of Failure – a single component that brings everything down if it fails. In far too many organisations, that component is a person.

It is often called key-person dependency. In reality it is something more serious: conceptual debt. Over the years, business rules, legal requirements and internal agreements have been built straight into technical solutions. The rule for who may approve an invoice became an if-statement in a script. The definition of a manager became a text field in the HR system. Linking a new hire to the right applications was solved by a script that runs when the account is activated.

As long as the author is still around, it works. When reality changes, a quick fix is made in the code. The logic is written down nowhere but in that person's head and in the source code. Then the person leaves.

Good solution

The model carries the logic

ProcessProcess roleEmployeeApplication
Explanation
The employee holds a process role. The role is performed in the process and uses the application.
Rationale
The links are described as data and rules. When the person leaves, the role is assigned to someone else – the process and the application are unaffected.

Less good solution

A person as Single Point of Failure

ProcessEmployeeApplicationApplication
Explanation
The process and the applications are connected only through one employee's knowledge.
Rationale
Nobody else knows how the parts fit together. When the person disappears, every link breaks at once.

When people become a Single Point of Failure

A server without redundancy is classed as an unacceptable risk in every risk analysis. Yet the most central information flows are allowed to rest on the same fragile ground: a single developer, administrator or architect who alone understands how the code, the exceptions and the data mappings work.

Human SPOFs do not show up in server monitoring. They show up when the person resigns, falls ill or retires. And unlike a hard drive, you cannot buy a spare part and swap it in on Monday morning. Removing the bottleneck is not about replacing people with technology, but about making the logic independent of personal memory.

What happens when nobody understands any more?

The system is frozen in time. Since nobody can see the consequences, nobody dares touch the configuration. Necessary changes are postponed or handled with manual side processes in spreadsheets.

Errors start appearing at the interfaces. When the world changes but the logic stands still, integrations begin to fail. Access is wrong, new hires lack systems in their first week and invoices get stuck.

The automation is switched off. To prevent errors the flow is stopped, and work returns to manual handling and double entry. This often hits the very organisations that invested most in automation – without first creating a shared conceptual model.

AI makes the problem bigger

Putting AI or RPA on top of an undocumented information structure solves nothing – it accelerates the problem. The dependency simply moves from a named person to an opaque algorithm. When the model gets it wrong, there is still nobody who can tell what was actually intended.

Three principles for surviving a generational shift

1. Lift the logic out of the source code into open rules. Business rules should be written in plain language that managers, lawyers and newly hired developers can read. A rule such as “Management responsibility is set by manager code, not by position” needs no archaeology to understand.

2. Build on established standards instead of local inventions. When the model is anchored in standards such as SSYK, UNSPSC and organisation numbers, knowledge moves from individual heads to the outside world. A new administrator can get up to speed in hours instead of months.

3. The process must work manually. Automation is an optimisation on top of a working process, never a life-support system. If the automation is switched off, work goes slower – but it never stops.

A map for the next generation

Information architecture is ultimately about leaving behind a map the next generation can read. When concepts, roles, rules and relationships are clearly defined, it does not matter if the best architect leaves or the supplier is replaced. The model remains, and the work can go on.

Tags

  • #key-person dependency
  • #automation
  • #maintenance

What did you think of this article?