As the automotive industry advances toward increasingly software-defined vehicles, the complexity of embedded systems is rising dramatically. From electrified powertrains to autonomous features and over-the-air updates, modern vehicles now function as distributed computing platforms with strict real-time constraints and safety-critical responsibilities.
In this landscape, ensuring software correctness, reliability, and traceability is no longer a late-stage testing concern – it must be a continuous effort. This is where the concept of continuous observability becomes essential.
Continuous observability refers to the ability to monitor and understand the internal state and behaviour of software systems throughout their entire lifecycle. Unlike traditional debugging or post-mortem analysis, observability provides ongoing insight into how embedded software is performing – during development, integration, field testing, and in production.
In safety- and performance-critical applications such as those found in the automotive sector, this visibility supports early detection of timing issues, validation of safety mechanisms, and faster root-cause analysis of anomalous behaviour. It also strengthens compliance efforts with standards like ISO 26262 and helps engineering teams manage the complexity of tightly integrated software-hardware systems.
A real-world example of this in practice comes from the University of Toronto Formula Racing (UTFR) team. Building a competitive electric race car within a one-year design cycle meant that every subsystem – from the high-voltage accumulator to the motor controller and BMS – had to be developed and verified rapidly. For the 2024–2025 season, the UTFR team transitioned their control software to FreeRTOS, driven by significant architectural changes and the need for more robust task scheduling and timing control.
To support this transition, the team adopted Percepio Tracealyzer, a visualization tool that helped them monitor the real-time behaviour of their firmware during development. This integration gave them insight into task execution, state transitions, and inter-task interactions – insight that proved invaluable when debugging timing issues and verifying safety-critical behaviours.
The team reported that Tracealyzer made it easier to verify that fault-handling routines and CAN message processing consistently pre-empted lower-priority tasks, and that their state machines behaved as expected under various operating conditions. They were able to pinpoint and address priority inversions, detect blocking conditions, and improve responsiveness long before the car reached the track.
This level of visibility helped UTFR bring an automotive-grade level of rigor to their firmware, despite the rapid pace and limited resources typical of student competitions. The result was a reliable and competitive race car that successfully participated in events in North America and Europe, showcasing that advanced development practices are not limited to OEMs and Tier 1 suppliers.
As vehicles continue to evolve, observability will only grow in importance. With the shift toward connected and autonomous systems, software issues may appear after deployment – sometimes only under rare operating conditions. A system designed for continuous observability can report unexpected behaviour, help developers reconstruct events leading to faults, and support safe, efficient updates.
In this context, observability is not just a debugging tool – it becomes a foundation for safe and resilient system design. By integrating observability throughout the software lifecycle, automotive developers gain the ability to manage complexity, accelerate validation, and maintain control over increasingly dynamic and distributed systems.
Observability Tools in Practice
Percepio provides observability solutions for embedded systems, including Tracealyzer for development-time visualization, Detect for continuous verification during testing, and DevAlert for anomaly detection in deployed devices. These tools can be used individually or as part of a unified observability pipeline, helping developers maintain visibility across the full embedded software lifecycle.
More information: www.percepio.com
