Digitalisation Failed Us (And Why Automation Is Still Broken)

For more than 50 years we've been trying to digitalise society.

The promise was simple: computers would remove friction, automate bureaucracy, and connect everything.

Instead we ended up with something else: thousands of disconnected digital islands.

If you interact with government services in most countries today, the experience feels stuck somewhere between the 1990s web and early 2000s enterprise software.

Ironically, the technology to fix this has existed for decades.

The problem was never computers.

The problem was how we built systems — and how we failed to connect them.

The Long History of Digitalisation Failure

Public sector digital projects have a remarkably consistent failure pattern.

Large programs are launched with enormous ambition. They aim to unify complex systems across ministries, agencies, or healthcare providers.

Then they collapse under their own weight.

Examples are everywhere.

The UK NHS National Programme for IT

One of the most ambitious digital projects ever attempted. It aimed to build a unified electronic health record system for the entire NHS.

After years of development and billions spent, much of the system never delivered its intended functionality.

One component, the Lorenzo electronic health record, was deployed but widely criticised and later replaced in many hospitals.

The Post Office Horizon Scandal

Faulty accounting software incorrectly reported financial losses, leading to over 900 wrongful prosecutions of subpostmasters between 1999 and 2015.

Technology didn't just fail to improve systems — it created one of the largest miscarriages of justice in British history.

Emergency Dispatch Failures

The London Ambulance Service introduced a computer-aided dispatch system in 1992. Poor implementation caused severe delays in assigning ambulances and system collapse shortly after launch.

Payroll Automation Gone Wrong

Canada's Phoenix payroll system attempted to modernize salary management for 290,000 public servants.

The system produced incorrect or missing payments for a majority of employees and ballooned to billions in costs.

The Core Problem: We Digitalised Forms, Not Systems

Most digitalisation projects followed the same flawed strategy:

Take a paper process → build software for it → stop there.

This approach digitises the interface but not the underlying system.

You still have:

separate databases
separate authentication systems
separate teams
separate APIs (if any)

Instead of one cohesive system, you get a collection of software silos.

The result is familiar to anyone who has dealt with modern bureaucracy:

You enter the same data ten times. You upload the same document repeatedly. Nothing talks to anything else.

Digitalisation became PDFs instead of paper.

The Countries That Actually Got It Right

A few countries took a different approach.

They didn't build individual digital services.

They built digital infrastructure.

Estonia: Data as a National Platform

Estonia's government introduced a system called X-Road, which allows different government and private systems to exchange data securely.

Police, tax authorities, healthcare providers, and businesses can access shared data through this infrastructure.

Instead of hundreds of isolated services, Estonia created a data layer connecting everything.

The result:

almost all government services available online
pre-filled forms
minimal manual data entry

Citizens don't move documents around.

The system moves the data.

Denmark: Digital Post and Trust

Denmark introduced a universal system called Digital Post, allowing citizens to receive official communications digitally.

A large majority of citizens report trust in these services.

Trust matters because digital systems only work if people actually use them.

The Other Extreme: The Super-App Model

In the private sector, China accidentally solved the same problem from a completely different angle.

Instead of building a shared government infrastructure, platforms built super-apps.

The most famous example is WeChat.

Originally a messaging app, it evolved into a platform containing thousands of embedded mini-applications.

Users can:

pay bills
order food
book taxis
buy train tickets
access public services

All inside a single app.

Mini-programs act like apps inside the app, allowing third-party services to run without separate downloads.

Today millions of these mini-programs exist inside the ecosystem, handling payments, booking services, and much more.

In practice, this means something radical:

The digital experience feels like one coherent system.

Even though thousands of companies participate.

What Connected Digital Systems Would Actually Look Like

If we connected digital products properly, several things would happen:

Identity becomes universal

You log in once.

Your identity works across:

government
banks
healthcare
education
transport

Data flows automatically

If you change your address:

tax authorities know
healthcare systems know
insurance providers know

You never fill the same form twice.

Services become composable

Instead of standalone apps, we'd have digital building blocks.

For example:

identity
payments
location
documents
notifications

Every service would reuse these components.

In software terms, the digital world would behave like a platform, not a collection of products.

Developers Know This Problem Too Well

The fragmentation problem isn't limited to governments.

Developers face it every day.

Think about a typical project stack ten years ago.

You had to assemble:

hosting
authentication
CI/CD
deployment
analytics
monitoring
edge caching
server infrastructure

Each tool had its own configuration, credentials, and integration headaches.

Automation wasn't hard.

Integration was.

The Platforms That Started Connecting the Dots

Some modern platforms started to reduce this complexity.

Tools like Vercel unified the deployment experience for modern web applications.

Instead of configuring infrastructure manually, developers get:

Git-based deployments
preview environments
serverless infrastructure
integrated edge delivery

What used to require half a dozen tools became one coherent workflow.

The key insight wasn't new technology.

It was integration and opinionated defaults.

AI Is the Latest Attempt to Connect Everything

AI is often presented as a revolutionary technology.

But in many ways it is simply the latest layer attempting to connect fragmented systems.

Large language models can:

read APIs
operate software
automate workflows
generate glue code between systems

They act like dynamic adapters between tools that were never designed to talk to each other.

In other words:

AI is solving a problem that software architecture failed to solve.

And the uncomfortable truth is that we could have done much of this earlier.

With better APIs.

With better platform design.

With fewer silos.

The Real Lesson

Digitalisation did not fail because computers are hard.

It failed because we treated software like projects instead of systems.

Every ministry launched its own platform.

Every company built its own tool.

Every product became another disconnected node.

The future of digital infrastructure isn't just more software.

It's connecting the software we already built.

When the digital dots finally connect, automation won't feel like magic.

It will simply feel like the system is finally working.

#digitalisation #automation #software #engineering #ai