Would you build a car without knowing what's in it?
Car makers trace every part. Software teams should hold their supply chain to the same standard.
TL;DR: Car makers track every part because one defective component can stop the whole system. Software assembled from open source behaves the same way, yet many SBOMs list only declared dependencies. Supply chain thinking means SBOMs that also cover transitive, undeclared and copied code.
When building a car, manufacturers obsess over every component: the engine and transmission, and also every screw, chip, sensor and subassembly. Even a single defective part can bring the whole system to a halt, create a safety hazard or trigger a massive recall.
That's grounded in well-established principles such as the Theory of Constraints (Goldratt, 1984) and reliability engineering. In any interconnected system, the weakest part, or the most constrained resource, determines the performance and reliability of the whole. So if the car industry treats every part as a potential point of failure, why has software accepted a lower standard?
Software is assembled from a supply chain you can't see
Modern applications are assembled more than they're written. We install a few packages, import some code and instantly inherit a large, complex supply chain of open source components. A typical project can have hundreds or thousands of transitive dependencies, many of them never declared or visible to developers.
Reliability engineering calls this a series system, where every part has to work for the whole to work. Overall reliability is limited by the least reliable component. Yet many teams believe they're covered because they've generated a software bill of materials (SBOM), and that confidence is often misplaced.
Most SBOMs only list what was declared
Many SBOMs are generated from declared dependencies: those listed in package manifests, build files and configuration scripts. That approach misses dependencies that aren't declared anywhere. It struggles with ecosystems such as C and C++, where dependencies often aren't declared at all. And it overlooks copied files and code fragments, including those introduced by AI coding assistants.
The result is like a car maker tracking only the parts it sourced directly, while ignoring what its suppliers and subcontractors included upstream. It gives the appearance of control without real assurance.
I see this gap as one of the most under-recognised risks in modern software development. We talk about shifting left and DevSecOps, but without full transparency into the code we deliver, those efforts rest on shaky ground. Back to the Theory of Constraints: an organisation's ability to manage software risk is limited by the visibility its tooling provides.
Log4Shell showed the cost of unknown components
Log4Shell didn't hit because people had declared Log4j as a dependency. It hit because many didn't know it was in their stack at all. It arrived as a transitive dependency, buried inside another package, and shipped silently into production across thousands of systems.
The weakest link was an unknown vulnerable library. This is the core principle of systems thinking: in a complex system, failure often comes from what you don't know.
Software can learn from automotive traceability
In the automotive world, traceability is a requirement. Every screw and chip is accounted for in the bill of materials, because when a defect is found, manufacturers need to know which vehicles used it, how many are affected and how to recall them precisely. Standards such as IATF 16949 demand it.
Software faces similar stakes in safety, security and accountability, and it's time to hold it to the same standard. That means SBOMs that cover transitive, undeclared and embedded code as well as declared dependencies. It means analysing all code, including C, C++ and hand-written or AI-generated fragments, to find third-party code. And it means applying reliability engineering to software architecture: model the system as a chain and find the weakest link before it fails.
Know what you're shipping
We would never accept a vehicle built from unknown parts, and we shouldn't accept software built that way either. If software systems are series systems, and reliability is limited by the least visible component, the responsible path is to evolve our tools and practices to match the complexity of what we build.
Earnie inspects the code itself, finding components and fragments that were never declared, and builds the SBOM from what it finds. Traceability, trust and transparency are the fundamentals of any safe and secure supply chain, in cars and in code.
