As AI, cloud services and long product lifecycles redefine embedded systems, security increasingly depends on preserving trust across interconnected hardware, software and operational environments. How?
This article is based on the talk ‘Securing Embedded Systems for AI-Driven IoT and Automotive Platforms: From Silicon to Cloud’ by Nikesh G. Gondchawar, Director of Engineering, Vicon-Industries, at the EFY Expo Pune 2026. It’s been transcribed and curated by Saba Aafreen, Electronics For You.
Embedded systems have quietly undergone one of the most significant transformations in modern engineering.
What were once isolated microcontroller-based devices performing deterministic functions have evolved into connected, software-defined platforms that continuously interact with cloud services, artificial intelligence (AI) models, remote update infrastructure, and distributed ecosystems. From industrial automation and surveillance systems to connected vehicles and consumer electronics, embedded platforms now operate as part of a much larger digital environment.
During his session at EFY Expo Pune 2026, Nikesh G. Gondchawar, director of engineering at Vicon Industries, explored how this transformation has fundamentally changed the security landscape and why traditional security assumptions are no longer sufficient.
His central message challenged a common industry belief:
“Modern systems do not fail because security principles are unknown. They fail because trust assumptions break down at scale, over time, and under increasing software and AI complexity.”
According to him, the industry often focuses on individual controls such as secure boot, encryption, trusted execution environments, or device authentication. While each remains important, security failures increasingly emerge at the layers’ peripheries rather than within. “Security typically breaks at the boundaries between layers, not within a single component,” he noted.
The implication is significant. As systems become more connected and autonomous, security can no longer be treated as a collection of isolated mechanisms. Instead, trust must be established at the silicon layer, propagated through firmware and software, maintained through over-the-air (OTA) update mechanisms, and continuously verified through cloud and operational controls.
The evolution of embedded systems
To explain how security challenges have evolved, Nikesh Gondchawar described four broad generations of embedded architectures.
The first generation consisted of isolated embedded systems. These devices operated with little or no connectivity and relied largely on physical isolation. Security existed, but exposure was limited because the systems themselves were disconnected from external networks.
The second generation introduced networked embedded systems. These architectures were common in industrial facilities and factory environments where devices communicated across local networks. Security became more focused on perimeter protection and network boundaries.
The third generation marked the arrival of cloud-connected and OTA-enabled platforms. Smart appliances, surveillance systems, industrial Internet of Things (IoT) devices, and connected products gained the ability to communicate continuously with cloud services and receive software updates remotely. While this brought unprecedented flexibility, it also dramatically expanded the attack surface. In this generation, security is no longer confined to the device itself. The device, network, and update infrastructure become part of a single trust chain.
The fourth generation is now emerging in the form of AI-driven and software-defined systems. Here, AI becomes part of the decision loop. Systems no longer simply execute instructions; they interpret environments, infer outcomes, adapt behaviour, and continuously optimise operations.
This evolution fundamentally changes how engineers must think about security, as Gondchawar said, “vulnerabilities do not disappear. They evolve.”
What fundamentally changed
Several structural shifts have reshaped embedded security over the past decade.
The first is the growing importance of AI models themselves. These models increasingly represent valuable intellectual property and are becoming central to operational and safety-critical decisions. Protecting these assets from tampering, theft, reverse engineering, and manipulation has become a new security requirement.
The second shift is the rise of OTA updates as foundational infrastructure. These updates are no longer optional conveniences. Instead, they have become operational necessities for products deployed at scale. However, the same mechanism that enables rapid improvement also introduces one of the most powerful attack vectors in modern systems.
The third shift is the industry’s increasing reliance on open source software. While open source accelerates innovation and development, it also introduces dependency management and software supply-chain challenges that require continuous governance.
Finally, operational lifecycles continue to expand. Automotive, industrial, and infrastructure systems routinely remain deployed for 10 to 15 years or more. Security, therefore, becomes a long-term commitment rather than a one-time implementation activity.
Taken together, these trends signal a larger transition: embedded products are evolving into continuously connected ecosystems.
The expanded threat landscape
One of the key themes of the session was understanding security from an attacker’s perspective.
The attacker threat in the embedded landscape
Rather than targeting systems randomly, attackers look for trust boundaries, assumptions, and weaknesses across multiple layers of the architecture.
Gondchawar outlined an expanded threat landscape spanning five critical domains:
• Silicon and hardware
• Firmware and boot processes
• Operating systems and middleware
• AI runtime environments
• Connectivity, cloud, and OTA infrastructure
Failures can occur at any of these layers. More importantly, failures in one layer can undermine protections implemented elsewhere.
At the silicon level, risks include hardware trojans, manufacturing compromises, physical tampering, and side-channel attacks. Supply-chain incidents in recent years have demonstrated that trust assumptions can be violated long before software is ever executed.
“The real focus must be on designing systems so that trust is established at the foundation itself,” he said.
At the firmware layer, attackers target boot sequences, firmware images, update mechanisms, and debug interfaces. Because firmware executes before higher software layers become operational, compromise at this stage often provides extensive control.
The operating system and middleware layer introduce their own challenges. Modern embedded platforms rely heavily on third-party software, open-source components, drivers, libraries, and frameworks. Security, therefore, depends not only on code quality but also on governance and ownership.
When AI becomes part of the attack vector
One of the most thought-provoking sections of the session focused on AI-enabled systems.
Traditional embedded systems operate using deterministic logic. AI-enabled systems introduce probabilistic behaviour, creating entirely new categories of risk.
Drawing from surveillance and computer vision applications, Nikesh Gondchawar explained how object-detection systems may perform reliably under normal conditions while behaving differently when environmental variables change.
A standing person may be correctly identified under ideal conditions. However, changes in posture, lighting, occlusion, perspective, or movement patterns can influence model behaviour.
In some cases, these limitations can be intentionally exploited: “trust becomes probabilistic once AI enters the decision loop,” remarked Gondchawar.
This challenge extends far beyond surveillance. Similar concerns apply to autonomous vehicles, robotics, industrial automation, and other AI-assisted systems where model outputs influence real-world decisions.
The engineering challenge is therefore no longer limited to accuracy. It includes confidence, uncertainty, explainability, resilience, and understanding operational boundaries.
Why siloed security fails
Perhaps the most important message from the session was that security cannot be evaluated component by component.
Organisations frequently deploy secure boot, encrypted storage, trusted execution environments, and device authentication mechanisms, then assume the system as a whole is secure.
According to Gondchawar, this assumption is often incorrect: “secure components do not automatically create a secure system.”
Security failures frequently emerge between components rather than within them. Trust can break at the boundary between silicon and firmware, firmware and operating systems, AI and application logic, or devices and cloud services. This is why security architecture must be viewed as an end-to-end discipline rather than a collection of isolated controls.
Building trust from silicon to cloud
To address these challenges, he proposed a continuous trust model that begins at the silicon layer and extends throughout the system lifecycle.
The foundation is a hardware root of trust: a cryptographically anchored identity established at manufacturing and designed to be immutable and verifiable. Each device should possess a unique identity. Secure boot, measured boot, signed firmware updates, and lifecycle management controls must then extend that trust into higher software layers.
This trust must continue through OTA infrastructure, cloud platforms, operational monitoring, and AI-enabled services.
Partial implementation is not sufficient, as he said, “partial trust is often worse than no trust at all.” Trust must be continuously established, propagated, verified, and maintained.
Why standards are becoming increasingly important
The session also highlighted the growing role of standards and regulatory frameworks.
Drawing from the surveillance industry, Gondchawar discussed how security expectations have evolved in response to increasing concerns around device integrity, firmware security, supply chain assurance, and infrastructure protection.
He cited the emergence of security-focused certification requirements and international regulations as examples of how governments and industries are responding to systemic risks. Importantly, standards do not create security by themselves.
Instead, they establish minimum expectations and help enforce practices that should already exist within engineering processes; “architecture creates trust. Regulation enforces it.” As connected systems become increasingly integrated into critical infrastructure, compliance requirements are likely to expand further across industries.
Security as a lifecycle discipline
A recurring theme throughout the session was that security can no longer be treated as a feature.
Products remain deployed for years. Firmware evolves. Cloud services change. Open source dependencies receive updates. AI models drift. Threat actors adapt. Security, thus, becomes a lifecycle capability.
Organisations must continuously monitor, validate, update, and reassess trust assumptions throughout the operational life of a product. This represents a significant shift from traditional product-centric security approaches.
The road ahead
The future of embedded systems will be increasingly defined by connectivity, software, AI, and long operational lifecycles. These trends create enormous opportunities, but they also introduce new categories of risk. The challenge for engineers is not simply implementing stronger encryption or adding more security controls, but maintaining trust continuously across every layer of the architecture.
Nikesh Gondchawar concluded the session saying: “From silicon to cloud, trust must be continuously engineered at every layer.” In an increasingly connected world, trust is no longer merely a security feature. It is an architectural requirement.
