Why Cars Are Not Microservices

(Published February 15th, updated February 16th)

Cars aren’t microservices because physical systems can’t be decoupled the way software can. 

For the last decade, the tech world has lived inside a very particular mental model: everything is a microservice.  
If something moves, containerize it.  
If something breaks, restart it.  
If something misbehaves, rotate its credentials and try again.

This mindset works beautifully in the cloud. It is the backbone of modern software engineering. But as soon as we step into the world of autonomous cars, robots, and other real‑time physical systems, the metaphor collapses. A self‑driving car is not a stateless API. A robot arm is not a Kubernetes pod. And treating them as if they were is not just a conceptual mistake—it’s a safety risk.

This is the core message of the new article Collapse Anticipation: Why Cars Are Not Microservices. What follows is a guided tour of the idea, written for an audience that wants to understand the stakes without wading through equations or formal models.


1. Microservices Handle Requests. Cars Handle Trajectories.

Cloud systems live in a world of discrete events: a request comes in, a response goes out. If something goes wrong, you retry. If a service crashes, you restart it. Nothing irreversible happens.

Cars don’t get that luxury.

A self‑driving car is always in motion—literally. It follows a continuous trajectory through space and time. If it misses a deadline, you don’t get a “retry.” If it freezes for 200 milliseconds, that’s not a performance issue; that’s a collision.

This is the first and most important mismatch: microservices can fail safely. Cars cannot.


2. Why Today’s Security Models Don’t Fit Autonomous Systems

Modern identity and access management (IAM)—Zero Trust, SPIFFE/SPIRE, OPA—was built for cloud workloads. These systems assume:

- identity is a credential  
- credentials can be checked at runtime  
- credentials can be revoked instantly  
- failures are acceptable because services can restart  

All of this makes sense for cloud software. None of it makes sense for a moving vehicle.

A car cannot “fail fast.”  
A car cannot “restart cleanly.”  
A car cannot wait for a policy engine to decide whether it’s allowed to brake.

Autonomous systems need something different: identity that persists across time, remains coherent under stress, and can be evaluated continuously—not just at the moment of access.


3. The Real Problem: Identity Drift

The article introduces a key idea from the substrate‑rooted identity doctrine: identity is not a credential; it is a trajectory.

A system’s identity evolves over time as its hardware, software, behavior, and attestation signals shift. Small deviations are normal. Large deviations are dangerous. When drift crosses a threshold, the system enters a collapse mode—perception failure, control instability, behavioral incoherence, or attestation mismatch.

This is not a security event.  
It is an identity event.

And it is predictable.


4. Collapse Anticipation: The Missing Primitive

If collapse is predictable, then safety depends on detecting drift before it crosses the threshold.

This is collapse anticipation.

Instead of asking “Is the system allowed to act right now?”—the microservice question—we ask:

“Is the system drifting toward a state where it will no longer be safe?”

This shift is profound. It means:

- monitoring drift continuously  
- watching not just the amount of drift, but the rate  
- intervening early, before collapse becomes inevitable  

In a car, this might look like:

- detecting sensor degradation before perception fails  
- noticing timing jitter before the control loop destabilizes  
- spotting behavioral incoherence before the vehicle makes a dangerous decision  

When drift accelerates, the system transitions into a safe mode—controlled stop, limp‑home behavior, or constrained operation—rather than trying to compute its way out of a corrupted trajectory.


5. So Why Aren’t Cars Microservices?

Because the metaphor breaks at every structural level.

Cars:
- operate on continuous trajectories  
- cannot be restarted safely  
- require identity that persists across time  
- must detect drift before collapse  
- need anticipatory governance, not reactive IAM  

Microservices:
- operate on discrete requests  
- can fail and restart without consequence  
- rely on credentials that can be rotated at will  
- evaluate identity only at the moment of access  
- assume failure is acceptable  

Treating cars like microservices is not just wrong—it is a category error.


6. The Bigger Picture

As autonomy spreads—from cars to drones to industrial robots—we need identity models that match the physics of the world, not the abstractions of the cloud. Collapse anticipation is the missing piece: the governance layer that keeps real‑time systems safe by detecting drift before it becomes collapse.

The cloud taught us how to scale.  
Autonomy will teach us how to anticipate.

And the sooner we stop treating cars like microservices, the safer the future will be.

Popular posts from this blog

The Second Silicon Winter Is Coming

Silicon Winter: The Final Chapter

MANAGEMENT SPEECH 101: RADEON EDITION