Key Considerations for a Software-Defined Vehicle Development Platform

As vehicles transition into software-defined platforms, the need for a robust development and deployment environment becomes increasingly clear. The shift from distributed ECUs to centralized, Linux-based computers fundamentally changes how automotive software is built, tested, and delivered. A modern SDV development platform must support continuous delivery, modular software, and safe over-the-air updates, all while meeting the strict safety and reliability expectations of the automotive industry.

Keep reading: Automotive Edge Computing Explained: From SDVs to Dealership Edge Sites

This article outlines key requirements for such a platform and describes where mature, production-ready technologies like the Avassa Edge Platform can help. It is important to note that the Avassa Edge Platform does not aim to provide a full SDV stack. Instead, it addresses a specific but essential capability: the reliable management, orchestration, and lifecycle handling of containerized applications across distributed compute environments.

This article focuses primarily on software-defined capabilities in commercial vehicles rather than consumer cars, where operational requirements and deployment challenges tend to differ substantially.

Hardware–Software Abstraction in SDVs

Vehicle platforms differ widely in hardware configuration, yet developers need a consistent abstraction layer so applications can run without depending on low-level details. Modern automotive compute units increasingly rely on Linux as the common foundation, providing a stable and well-proven API surface for application development.

This trend reduces fragmentation: instead of bespoke vendor-specific interfaces, developers can build on standard Linux and POSIX APIs for networking, process lifecycle, monitoring, and device interaction. These interfaces are mature, well understood, and backed by decades of real-world production use.

In this context, the Avassa Edge Platform fits naturally into the environment. It relies on standard Linux POSIX APIs for runtime monitoring, system interfacing, and device discovery. By using existing Linux primitives rather than custom layers, the Avassa Edge Platform remains portable across hardware variants while avoiding lock-in and minimizing additional integration work.

Vehicle functions are becoming portable software workloads rather than ECU-bound.

Source: Texas Instruments

Integrating CI/CD Pipelines into SDV Development

SDV development depends on continuous integration and automated validation, but the SDV platform itself should not attempt to replace or reinvent CI/CD tooling. Instead, it must integrate cleanly with the leading CI/CD systems already used across the software industry.

A modern SDV platform should accept artifacts produced by established pipelines while providing the interfaces needed to connect testing and deployment stages. This includes:

• Compatibility with containerized build environments
• Straightforward packaging of deployable artifacts produced by existing CI/CD tools
• Hooks for test benches, hardware-in-the-loop setups, and virtual simulation environments
• A clear interface for delivering validated updates into pre-production or virtualized vehicles

This approach allows teams to continue using mature, proven CI/CD tools while the SDV platform focuses on its role: safely distributing, validating, and running the resulting software across the vehicle fleet.

SDV development requires cloud-native thinking deployed into highly constrained embedded environments

Source: Red Hat

OTA updates for SDVs

Remote software delivery is fundamental to SDVs, and OTA mechanisms must be designed to function reliably even over unstable or intermittent network connections. Updates need to resume gracefully, verify integrity at every step, and avoid leaving the system in an inconsistent state if connectivity drops.

A robust OTA system should support:

• Delta-based updates to minimize bandwidth
• Staged rollouts and safe rollbacks
• Strong authentication and integrity verification
• Resilient transfer models that tolerate poor or intermittent connectivity

While traditional automotive OTA approaches focused on delivering full operating system images, the industry is moving toward a more granular model. Increasingly, updates target individual applications — each with its own lifecycle, versioning, and deployment cadence — rather than replacing entire system images. This modular approach aligns with containerized architectures and enables faster, safer, and more targeted updates across the vehicle fleet.

Containerization and virtualization for SDVs

Centralized vehicle computers are trending toward Linux-based, container-capable environments. Containers provide isolation, predictable packaging, and small, incremental updates, highly aligned with the needs of modern vehicle software.

Virtualization (including hypervisors supporting mixed-criticality workloads) allows safety-critical functions to run side-by-side with more dynamic, feature-oriented applications.

A practical SDV platform should support both container-native and mixed-virtualization setups, enabling automotive developers to adopt cloud-proven technologies without compromising safety.

Cybersecurity in Software-Defined Vehicles

Security is non-negotiable. An SDV development platform must include:

• On-vehicle secure identity and secrets management
• Data protection
• Minimized risk exposure: vehicle-local encryption keys and distributed secrets to reduce security risks and blast radius. Secrets are distributed on a need-to-know basis.
• Zero-trust communication models
• Fine-grained policy control across distributed systems

Automotive software lifecycles require security controls that span development, deployment, and runtime.

Fleet-Wide Management Through Cloud and Automotive Edge Integration

The move toward centralized computing in vehicles mirrors the trend in large IoT and edge fleets. Developers need:

• A central management plane for software lifecycle management
• Site-level autonomy so vehicles can operate offline, including access to essential edge services such as a distributed secrets manager and local policy enforcement, ensuring the vehicle remains fully functional even without cloud connectivity
• Monitoring, logging, and telemetry aggregation
• Targeted deployments across heterogeneous fleets

Vehicles are essentially mobile edge sites — and benefit from the same operational patterns used in industrial IoT and distributed retail compute.

This is where mature edge management systems provide strong value.

SDV Application Availability and Reliability Requirements

In an SDV architecture, many applications must remain available even when individual components fail or the vehicle is offline. This requires on-board clustering capabilities that allow services to be replicated locally across multiple compute units or containers. If one instance fails, another can seamlessly take over without relying on cloud connectivity.

A modern SDV platform should support:

• Local service replication and clustering within the vehicle
• Health checks and automatic failover between on-board instances
• Restart policies and controlled rollback mechanisms
• Self-healing behavior that does not depend on the cloud

Even non-safety-critical applications benefit from these patterns. Local redundancy ensures predictable behavior, stable user experience, and continued operation under varying conditions all with minimal reliance on external infrastructure.

Efficient, Low-Footprint Software for Automotive Edge Computing

Vehicle compute units must optimize for power, memory, and storage. SDV platforms need lightweight orchestration layers and efficient runtimes that avoid excessive overhead. The industry trend toward smaller, more modular stacks reflects exactly this need.

Why Centralized Kubernetes Is Not a Fit for Distributed Automotive Edge Sites

When discussing automotive edge computing, it is helpful to separate the on-vehicle and off-vehicle domains. Inside vehicles, constraints are extremely tight on footprint, performance, and safety, and the industry is moving toward automotive Linux and dedicated real-time platforms rather than container-orchestrated clusters. In simple terms, Kubernetes is not designed for use in vehicles and is unlikely to ever be an onboard orchestrator.

Off-vehicle automotive edge environments look very different from cloud datacenters. Service centers, dealerships, charging stations, and industrial operational sites that host commercial vehicles are typically small, decentralized installations with limited connectivity and local operational requirements. They need to run critical software autonomously even when the network is unstable, and they often process sensor data locally rather than pushing everything to the cloud.

This means the automotive edge behaves like a large number of tiny, distributed sites rather than a few centralized clusters. Instead of scaling a single Kubernetes control plane across datacenter-style resources, the challenge is the opposite: running and managing lightweight applications across hundreds or thousands of independent sites that operate under edge conditions rather than datacenter assumptions.

How the Avassa Edge Platform fits in

The Avassa Edge Platform is not a full SDV platform, nor does it aim to be. The SDV ecosystem includes real-time operating systems, safety-certified virtualization layers, sensor interfaces, automotive middleware, fleet management, and compliance frameworks, all of which sit far outside the scope of general-purpose edge orchestration.

However, one part of the SDV challenge aligns directly with the Avassa Edge Platform’s strengths: the reliable, secure, and automated management of containerized applications across a large fleet of distributed compute nodes.

As central vehicle computers increasingly adopt Linux and containers, manufacturers need a proven fleet manager that can:

• Deploy and update containerized applications across thousands of distributed endpoints
• Operate reliably even when nodes are offline or intermittently connected
• Provide built-in secrets management, identity, and secure communication
• Support small, controlled application updates
• Enable versioning, staging, and canary rollouts
• Manage multiple applications per vehicle cleanly and predictably
• Run with a lightweight footprint suitable for constrained hardware

In other words, while the Avassa Edge Platform does not claim to be the entire SDV stack, it offers a mature, production-proven capability that directly addresses a key requirement: a central application fleet manager for containerized vehicle software.

Compared with early-stage efforts such as Ankaios within Eclipse SDV, the Avassa Edge Platform provides a more complete and operationally ready solution that can be adopted today and integrated into broader SDV architectures.

“SDVs blur the boundary between the automotive and software industries.”

Source: Siemens

Closing reflection

The automotive industry is moving quickly toward software-centric architectures, but the supporting tooling landscape is still emerging. Rather than waiting for a single standardized stack to appear, many teams will benefit from combining proven technologies with domain-specific components. In this landscape, the Avassa Edge Platform provides a practical and immediately available solution for managing containerized applications across a large fleet of distributed compute units, an important piece of the broader SDV puzzle.