In December 2023, General Motors stopped selling one of its flagship electric vehicles — the Chevy Blazer EV — not because the battery caught fire or the brakes failed, but because the software was a mess. Infotainment freezes, charging glitches, a center screen that rebooted itself. This is the same GM that had just announced, with a straight face, that it would phase Apple CarPlay and Android Auto out of its future EVs so it could own the in-car software experience itself. The message to buyers was: trust us with the software. The product on the lot said the opposite.
That gap — between what carmakers say about software and what they ship — is the most honest thing in the industry right now. And almost everyone is reading it wrong.
The narrative everyone repeats
The consensus story goes like this: the car is becoming a computer on wheels. The 'software-defined vehicle' is the future. A modern car carries somewhere north of 100 million lines of code by the most commonly cited estimates — more than a fighter jet, more than the space shuttle. The hard part, the story says, is the staggering complexity of making a two-ton machine think. Master that, and you win the next decade of the automobile.
It's a flattering narrative because it makes the difficulty sound heroic and novel. It is also, in the part that actually breaks for customers, wrong. The complexity is real. But complexity is not where automotive software is failing. The industry has been writing safety-critical embedded code for forty years and it is genuinely good at it.
The part they're good at
Engine management, anti-lock braking, airbag deployment, the controllers behind modern driver assistance — that code lives under a discipline most consumer software has never met. ISO 26262 functional safety. AUTOSAR. The V-model. Requirements traced to tests traced back to requirements. Failure-mode analysis that assumes the worst and budgets for it. It is slow, expensive, paranoid engineering, and it works: the firmware deciding whether your brakes engage almost never ships broken in the way an app does. When was the last time a recall was issued because the ABS controller threw a NullPointerException on the highway? It doesn't happen, because that layer is treated as life-or-death — which it is.
So the heroic, hard, safety-critical layer everyone points at as the frontier? That's the layer the industry has under control. The crisis is somewhere far less glamorous.
The part they ship broken
Look at where automotive software actually disappoints people, and it's never the brake controller. It's the companion app that won't connect to the car you're standing next to. It's the account system that forgets your login. It's the cloud backend that goes down on a cold morning so remote start times out. It's the navigation that can't find a charger. It's the over-the-air update that bricks the infotainment head unit for a weekend. The app stores tell the story without ambiguity: the official apps from some of the largest, proudest automakers in the world sit in a graveyard of one-star reviews, rated below the average food-delivery app, by their own paying customers.
This is not safety-critical code. This is ordinary software product engineering — the exact discipline that consumer SaaS companies mastered a decade ago. Account management, a reliable API, a mobile app that handles a flaky network gracefully, a backend that scales on a Monday morning, a deployment pipeline that ships fixes weekly without drama. None of it is novel. All of it is hard to do well, and continuously, forever. And it is precisely here that the car industry is mediocre.
Why the soft layer rots
The reason is structural, not technical. Carmakers grew up running programs, not products. A program has a start, a launch date, and an end; you assemble suppliers, hit start-of-production, and disband. That model built the safety-critical stack beautifully, because firmware for a brake module genuinely is frozen at launch. But an app is not a program. It needs an owner who is still there in year four, shipping improvements, watching error rates, answering for the one-star reviews. The program model has no slot for that person, so the app gets outsourced to the lowest bidder, delivered, and abandoned the day the car launches.
Volkswagen's experience is the cautionary tale the whole industry watched and mostly failed to learn from. Its in-house software unit, Cariad, was supposed to make VW a software company. Instead it became a byword for software delays — pushing back launches across Audi and Porsche — and posted operating losses reported in the billions of euros. Software trouble was a significant factor in CEO Herbert Diess losing his job in 2022. The lesson the headlines drew was 'software is hard.' The real lesson was narrower and more useful: a 90-year-old company organized around shipping hardware once cannot, by reorganizing a logo, suddenly become a company that ships software continuously. Those are different muscles.
Over-the-air is the tell, not the cure
The industry's current answer to all of this is OTA — over-the-air updates, borrowed wholesale from Tesla, now standard marketing copy. Recalls that once meant a trip to the dealer increasingly get fixed by a download overnight, and a growing share of recalls are now software-related and remedied that way. That sounds like progress, and partly it is. But OTA is not a feature; it is a confession. It only matters because the software shipped wrong in the first place, and it only works if you have the one thing the program model never built: a release pipeline, monitoring, rollback, and a team that owns the consequences of every push. OTA without that discipline is just a faster way to brick a car remotely — which has, in fact, happened. The pipeline is the product. Most automakers bolted on the download mechanism and skipped the discipline.
What eleven years of building the boring layer teaches you
I won't pretend EltexSoft writes ECU firmware — we don't, and that's not the layer in question. We build the unglamorous layer that carmakers keep getting wrong: the backends, the companion apps, the data pipelines, the cloud infrastructure, the SaaS platforms that have to keep working in year five. And the thing eleven years of that work hammers home is that the soft layer is not a project you finish; it's a relationship you maintain. Our average client engagement runs about four years, and our longest partnerships — like the air-passenger-rights platform we've engineered since 2016, the same one that has since processed over a million claims — run a decade with the same team on it. That continuity is not a sales line; it is the only thing that keeps a product from rotting the moment the launch champagne is poured.
The mechanics are equally boring and equally non-negotiable. Every pull request reviewed by another senior engineer before it merges. Turnover kept under 5% a year against an industry norm well north of 20%, because the person who shipped the bug in March is still around in September to understand why. When a client came to us with a stalled marketplace build and a 90-day go-live, the work that saved it wasn't clever code — it was ruthless scope discipline and a team that doesn't churn. None of this is exotic. It is exactly the operational muscle the program model strips out, and exactly what the in-car app needs and rarely gets.
The definitional piece that anchors all of this: what an MVP in software actually means. And if you're scoping a build, our industry solutions show how we take products from spec to shipped.
The position, stated plainly
Automotive software development does not have a complexity problem. It has an ownership problem. The frontier everyone romanticizes — the safety-critical, 100-million-line embedded stack — is the part the industry has under control. The part that actually decides whether you enjoy your car or curse it every morning is the ordinary product software, and carmakers keep building it like it's still a hardware accessory: spec it, outsource it, launch it, walk away.
The automakers that win the next decade will not be the ones that brag loudest about the software-defined vehicle. They'll be the ones that quietly learn the least glamorous lesson in technology: a software product is never finished, and the team that built it has to still be standing in front of it years later. Until an automaker treats its companion app with a fraction of the seriousness it brings to its brake controller, the one-star reviews are not a software problem. They're an admission that the company never actually decided to be in the software business at all.