The Undercurrent That Breaks Automotive Programmes

A few days ago, I wrote that automotive doesn’t have an innovation problem.

That usually gets a nod.
Sometimes even agreement.

But it also leaves an obvious question hanging.

If innovation isn’t the issue, then what is?

It’s not one big failure.
It’s what sits underneath everything we track.

Where programmes actually start slipping

Most programmes don’t slip at milestones.
They slip long before that.

Not in a way that shows up in reports.
Not in a way that gets escalated.

But in small, disconnected signals that never meet each other.

A status shows green.
The team knows it isn’t.
But that doubt never gets recorded anywhere.

A supplier delay comes in.
Engineering adjusts locally.
No one sees what that does three steps downstream.

Everyone is working to a timeline.
Just not the same one.

So in reviews, everything looks aligned.
On the ground, it isn’t even close.

The system isn’t wrong. It’s incomplete.

Most systems today are very good at tracking what is reported.

Milestones.
Actions.
Gateways.
Status.

But programmes don’t fail inside those structures.
They fail in the gaps between them.

Where:

• Confidence doesn’t match status
• Dependencies don’t propagate
• Timelines don’t align
• Risks don’t translate

That layer doesn’t exist anywhere.

So people compensate.

Issues get softened to avoid noise.
Or amplified to force attention.

Either way, what reaches the top is rarely the real signal.

The illusion of progress

Tickets close.
Gateways pass.
Reports move forward.

From the outside, the programme looks like it’s progressing.

But underneath, something else is happening.

Problems aren’t always resolved.
They’re just no longer visible.

And once that happens, the programme starts building confidence on top of uncertainty.

That’s when it becomes dangerous.

Because now you’re not just late.
You’re convinced you’re not.

Why “unexpected” keeps happening

By the time something turns red, it feels sudden.

A delay.
A failure.
A missed milestone.

It gets labelled as unexpected.

It rarely is.

In most cases, the signal existed much earlier.

It just didn’t connect to anything else.

No cascade.
No propagation.
No visibility beyond the local context.

So it stayed contained…
Until it couldn’t.

The uncomfortable truth

Execution doesn’t fail at the point of decision.

It fails much earlier—quietly—
when information should have met, but didn’t.

Not because people didn’t know.

But because what they knew had nowhere to go.

And that’s the undercurrent

Not visible in dashboards.
Not captured in status reports.
Not escalated in time.

But always there.

Shaping outcomes long before we recognise them.

If you read this and thought, “yeah… I’ve seen this happen”—
that’s exactly the point.

This isn’t a rare edge case.
It’s how most programmes operate today.