The Hidden Cost of SDV Architecture: Why Integration Drives Long-Term Costs

Software integration costs extend far beyond vehicle development. Discover how centralized SDV architecture can reduce integration complexity, recurring engineering effort, and long-term costs for automotive OEMs.

For automotive OEMs, the most economical software architecture may not be the one with the lowest implementation cost, but the one that requires less engineering effort every time the vehicle evolves. A vehicle platform can meet its initial software development budget and still become expensive to maintain.

The reason is straightforward: developing software is only part of the investment. The other part is making software from different suppliers, operating environments and vehicle domains work together, and keeping those interactions reliable as the platform changes.

That work is substantial. McKinsey has estimated that 30 to 50 percent of the development effort for modern infotainment systems can be devoted to integration, in part because OEMs must bring together software from broad supplier networks. The same analysis notes that changes to an individual module can require extensive rework when interfaces and software versions are not compatible.

For automotive CTOs, this raises a more useful question than the price of the initial implementation:

What will this architectural decision cost across the vehicle platform’s lifecycle?

As vehicles receive new functionality, software updates and cross-domain capabilities after start of production, architecture increasingly determines not only how a vehicle is launched, but how much engineering effort is required every time it changes. UN Regulation No. 156 – applied in 58, including the European Union, the United Kingdom, Japan and South Korea – places software updates within a formal lifecycle-management framework, reinforcing that, for manufacturers who update their vehicles after production, managing those changes is now a regulated, ongoing process rather than an exceptional event.

Integration is not a one-time development expense

Traditional vehicle development could treat integration largely as a major milestone on the path toward the start of production. 

SDVs make that view increasingly incomplete because modern vehicles combine software delivered by internal teams and suppliers across domains such as powertrain, ADAS, cockpit, body and connectivity. Those functions may rely on different operating systems, middleware layers, APIs, communication protocols and release schedules.

Middleware illustrates why this work persists with a valuable purpose: abstracting underlying hardware and providing standardized services can allow applications to communicate without being tightly coupled to individual ECUs or hardware implementations.

AUTOSAR Adaptive, for example, uses service-oriented mechanisms that allow applications to discover and consume services dynamically and supports software updates and reconfiguration.

But abstraction does not eliminate dependencies.

A vehicle function may depend on a specific API, service contract, communication signal, middleware version, library or timing behavior. When one element changes, engineers need to determine whether every dependent function still behaves correctly.

That is where integration becomes recurring engineering work.

A supplier changes a software component. An API evolves. A network signal is modified. A new feature introduces a dependency on an existing service. A security update changes a shared library.

Each event can trigger another cycle of integration, troubleshooting and validation.

McKinsey also reports that, in some conventional OEM environments, stabilizing existing functionality after changes to communication signals between ECUs and networks such as CAN and LIN can require more than 20 weeks. It also notes that weak CI/CD environments can cause OEMs to spend more resources on release management and manual integration than on developing the software itself.

Integration, in other words, becomes part of the operating cost of the architecture.

Want to understand how architecture influences software integration?

Explore our article Software-Defined Vehicle Architecture: Components and Trade-Offs to learn about the key components and trade-offs shaping modern vehicles.

Why the lowest initial cost may not be the lowest total cost

Consider two architectural decisions:

The first allows an OEM to assemble a vehicle platform from established domain systems and supplier solutions. Individual elements may be familiar, commercially attractive and relatively straightforward to source.

The second asks for a greater commitment to a common architectural foundation intended to reduce the number of independent software environments and interfaces that must be coordinated.

At the procurement or implementation stage, the first option may appear less expensive.

But that comparison captures only the first part of the economics.

Each independent environment introduces relationships that must be maintained, with interfaces having versions, services having consumers, suppliers having release schedules and software components having dependencies.

These costs accumulate in engineering hours rather than appearing as a single line item.

Supplier coordination is one example: conventional OEMs still depend significantly on external engineering organizations, and when suppliers deliver software without source-code transparency, OEMs can have limited visibility into the effort required for updates, releases and bug fixing.

Another example is the regression testing:

When a software component changes, engineers need confidence not only that the new code works, but that previously validated functionality still behaves correctly. Automotive continuous-integration research therefore treats system-level regression testing as an essential part of fast software release processes. As architectures gain more possible combinations of hardware and software configurations, the validation space becomes increasingly difficult to cover exhaustively.

This means that implementation cost alone is an incomplete measure of architectural economics, with a more relevant comparison being the engineering work each architecture generates over years of releases, updates and vehicle variants.

The cost that multiplies across vehicle programs

The economics become even more important when an OEM manages multiple models, trims, regions and generations, because a software change rarely exists in only one context.

An interface modified for one feature may behave differently across configurations. A supplier release may need to be validated against several software baselines. A communication change can affect multiple ECUs. A shared component may interact with different hardware or middleware versions depending on the vehicle program.

This produces an important distinction between software reuse and integration reuse.

An OEM may reuse the same application across platforms while still repeating a substantial portion of the work required to connect, configure, validate and release that application in each environment.

The industry is actively trying to reduce exactly this problem. COVESA, for example, develops standardized vehicle service and data interfaces intended to make integration and collaboration across OEMs, suppliers and third parties more consistent. AUTOSAR similarly uses standardized service-oriented interfaces as a foundation for portable and updateable automotive software.

A concrete integration scenario

Imagine an OEM introducing a new energy-management feature across three vehicle programs.

The application itself may represent only one part of the engineering effort.

The feature could consume battery information from one supplier, thermal-management signals from another, communicate through middleware maintained by a third team and influence cockpit information owned by yet another organization.

Now assume one interface changes.

Engineers must first understand which components depend on that interface. The affected suppliers need to align on a compatible release. The software baseline must be rebuilt. Integration tests need to confirm that the new function works. Regression tests must verify that existing behavior has not changed. The process may then need to be repeated across vehicle variants.

Nothing in that scenario is unusual, and the cost comes from repetition.

Continental has described similar integration problems in environments containing software from many suppliers, where manual delivery, testing, correction and redelivery created repeated loops before components could enter the integrated vehicle software baseline. Its response was to automate and standardize more of that workflow.

This is why lifecycle architecture decisions deserve scrutiny at CTO level, with the economic problem being how often the organization must perform substantially similar integration work again.

DrakoTech’s approach: reduce the work of bringing systems together

The DrakoTech’s architectural solution reduces the amount of engineering work required to integrate vehicle functions and maintain their interactions, being one of the biggest business concerns for OEMs.

In a fragmented environment, engineering teams may have to coordinate multiple RTOS instances, middleware stacks, communication layers, gateways, drivers and timing models. DrakoTech’s approach is to reduce the number of those boundaries by bringing functions onto a common execution and communication foundation.

Our single-ECU model is designed to eliminate multiple middleware and isolated-ECU layers and allow OEM or third-party applications to be ported into isolated subsystems on the same underlying platform.

The Drako DriveOS is designed as a unified vehicle software system capable of running mixed-criticality workloads on multicore processors using a separation-kernel architecture. DrakoTech’s Platform Architecture extends that idea into a single-ECU architecture intended to consolidate functions across vehicle control, cockpit, ADAS and AI.

Our core architectural concept has also been described in peer-reviewed research. A 2021 ACM paper from Boston University researchers and DrakoMotors presented DriveOS as a centralized vehicle-management system in which real-time and general-purpose workloads could coexist through partitioned hardware and software resources, and demonstrated the architecture in hardware-in-the-loop experiments.

Discover how DrakoTech’s DriveOS brings vehicle functions onto a unified software foundation designed to simplify integration and reduce architectural complexity.

A different way to evaluate architecture ROI

Instead of comparing only development budgets or platform licensing costs, OEMs can measure the engineering work generated by each architecture across the lifecycle.

Four measures are especially useful:

  1. Integration effort per feature: engineering hours required to connect a new function to the rest of the vehicle.
  2. Change amplification: how many components, interfaces, suppliers and tests are affected when one software element changes.
  3. Regression burden: how much system-level validation must be repeated for each release.
  4. ‍
  5. Integration reuse: how much of the original integration and validation work carries over when the same function is deployed on another vehicle program.

These metrics align with problems of: dependency tracking, cross-supplier interfaces, release management, fragmented toolchains and end-to-end testing.

Architecture is a lifecycle investment

For automotive CTOs, architecture decisions are also investment decisions.  That means distinguishing between an architecture that is inexpensive to start and one that remains economical to evolve.

Software integration takes a significant amount of time and effort. Different systems and suppliers can make integration more complex, especially when software updates and testing continue long after the vehicle is first developed.

Therefore, the objective should not be to eliminate integration, but to avoid paying for the same integration complexity repeatedly.

That is also the economic lens through which DrakoTech’s approach should be evaluated.

Its unified architecture is strategic because it reduces the number of relationships engineering teams need to continuously manage as the vehicle evolves. At DrakoTech, we have designed our platform around a common execution, networking, and I/O foundation to reduce fragmented software stacks and the engineering effort required for integration.

The next SDV architecture decision should ask what the architecture will cost every time the vehicle needs to change. For OEMs evaluating that trade-off, explore how DriveOS approaches software and system integration or speak with DrakoTech about your vehicle architecture.