Unleashing the giants: digitizing automotive incumbents — Part Two

This is the second article in a four-part series exploring digital transformation in the automotive sector. In this article, we focus on ways to improve technical aspects of that domain — mainly ways to decouple hardware and software development. Read Part One, that describes the context of mobile apps for connected cars here.

The automotive sector has undergone significant upheaval change? From an IT perspective, it used to be all around CAD, SAP and similar dealer/sales systems. Today everybody talks about new revenue streams and digital brand experience. But the roots of that change go back to 1982.

Back then, the TV show Knight Rider introduced concepts that the world is now getting dizzy about: a connected car that can drive autonomously and which supports the driver through his daily life. TV scriptwriters did a pretty good job of predicting the future back then. Just 35 years later, like Michael Knight, I can summon a car — in my case an Uber (or any equivalent) — from my smartwatch. And in the not too distant future, that car will drive to me autonomously.

This type of innovation is delivering real value to drivers through the combination of a physical product — the car — with software. But getting this combination right is not always easy.

We believe software is built best in a fast and iterative way, taking into account user feedback and data, while automating repetitive tasks like integration, testing, and deployments. We call that agile software development.

Cars, however, are very complex physical products. Being able to deliver a sub-seven minute lap on the ring takes effort, planning and iterations — things that take time, and are at odds with the timeframe usually associated with digital products. What’s more, the costs of a delay to the production start of such a complex physical product are enormous. And we haven’t yet considered safety and reliability.

The software has much faster time-to-market and much more frequent release cycles, shorter iterations and lesser costs associated to experimentation and iterative improvements (at least if you do it right). There is a conflict in keeping the physical and the digital product development in lockstep.

Figure 1: Conflicting development cycles

To get the best of both worlds, the dependencies must be decoupled. Ideally, software teams work on their digital products, regardless of the development state of the car. They can ideate, deliver and verify features before and after the car launch. In parallel car design, engineering and production planning can follow the strict and proven rules that apply in that domain.

But there are risks in decoupling and parallelizing the development of different aspects of one product and one user experience — particularly the integration at the end when all parts need to work together in a reliable and safe way. To minimize the risk of integration at a late stage, we suggest applying the following concepts right from the beginning:
  1. Mock the hardware
  2. API as a product
  3. End-to-end test automation

While the concepts are not new, their combination is extremely powerful in the domain of automotive and connected cars. They’re also extremely hard to realize in a distributed, siloed organization that spreads across different locations, teams, stakeholders and legal entities.

Mock the car

Mocking the hardware is a lesson-learned from our IoT projects. Refer to talks here and here which explain experiences from other domains. For the domain of connected cars, we suggest adopting the approach from other domains slightly, to address the organizational complexity and distribution of teams.

Start with defining the interface/contract between the software-product and the car and implement it as a test-case and as a mock within one of the teams. You can use the mock as if the physical product was already there — even if the product is still in development. Over time the physical product replaces the mock bit by bit as it’s maturity and availability increases.

Figure 2: Digital twin maturity over time

By simulating a car from the start of the software development, you increase the chances of keeping hardware and software development in lockstep. If you wait to test and verify the interfaces between the architecture layers until the first physical components are available, then the risk of additional work on interfaces is already very high.

In the process of taking over, people will notice immediately, if in the real world the physical product’s behaviour differs from the agreed interface. Tests will fail, and both sides will not work properly. You must expect this to happen: it’s the nature of change and rapid product development. The trick is not to prevent it but to embrace it, and to react to change as early and quickly as possible — before the physical product is released and in mass production.

If the latter happens, most likely there will be many bug-fixes within the software, which make up for errors or changes within the physical car. Over time that becomes a tech dept which is hard to cope with.

With our approach, your simulation (or the digital twin car) will always be available for testing and development. There’s no wasted time in case a hardware prototype isn’t working or if communication infrastructure is incorrectly setup.

Simulating the car should be feasible and quite precise very early in the process because the specification of the hardware and the interface is fixed. The physical hardware will most likely be procured from an OEM. And since it follows the strict rules and lead times of car engineering, the simulation can start right there and early on. The interface should be well described and support the simulation. Overall the hardware engineering, the procurement, and delivery are not very agile — but a nice coincidence and trigger for the simulation and a vital part in decoupling hard- and software-development.

The simulation of a car should, in the end, be available in the cloud. It's complex enough to justify the investment into maintenance and deployment infrastructure. And it enables multiple globally distributed teams to work on smart solutions and features around it.

Once the digital twin is fully independent of a location or physical infrastructure, it can even better support end-to-end testing a lot better and can support more complex test scenarios, for instance, when deployed to a different location or zone on the globe.

Figure 3: Adding a virtual twin/simulation/car to the architecture setup for connected car apps on mobile devices:

We experienced even more challenges within the domain of connected cars:
  • The connected car backends (IT systems encapsulating the secure communication with the car) were hard to access, had limited reliability and were subject to many changes
  • The customers are spread around the world and work with a very large number of end-devices
Both challenges led to us mocking not only the physical product but also to have a digital fake for the connected car backend as well as the customer’s device. This allowed our teams to monitor changes to the connected car backend and react quickly and opened up the possibility to simulate the real user experience in any given market around the world. As a side effect we also mitigated the risk of downtimes of backend infrastructure and increased the productivity of our teams.

Figure 4: Full-fledged setup of digital mocks supporting Agile software development within the connected car domain.

Summary: Decouple hardware and software development

Cars are complex physical products. They require years to develop and are only really available in reality towards the end of the development process. Digital products — such as the connected car applications — can be much faster in development and released much more frequently. We want to parallelize the development on both physical and digital products for connected cars. This requires to mitigate the integrations risk at the end.

A best practice is to mock the hardware as early as possible. For connected cars, we suggest hardware mock in the cloud, that can be made available to distributed teams on a global scale.

Because of the very complex domain and siloed organizational context we also utilize mocks for the connected car backends and the end-device. We work independent of other teams, we monitor changes to the API we call and can react immediately, and we can test the end user experience anywhere in the world.

There are more ways to decouple hard and software development. One is standardized APIs and treating the API itself as a product itself. Another one is to automate end-to-end tests. We will follow up on those in the next article.