Title: Software in ISO 26262: A Fault With No Failure Rate
URL: https://iso26262.academy/blog/software-in-iso-26262-a-fault-with-no-failure-rate
Description: Why ISO 26262 treats software faults as systematic, how software both detects and causes faults, and what Part 6 asks of the software architecture.

---
[Technical](https://iso26262.academy/blog/category/technical)

# Software in ISO 26262: A Fault With No Failure Rate

![An engineer at a desk writing an AUTOSAR-style CAN driver in C for an ECU, with a cross-compiler build finishing with zero errors and a laptop showing ECU software domains and CAN traffic.](https://iso26262.academy/edge-media/p/blog/images/2026/10/6d99d4b3-855e-4602-9bea-d367d9c6454f-1448.webp)

Software has no failure rate, so ISO 26262 cannot count it. What the standard asks for instead, why software is both the safety net for hardware faults and a source of its own, and why Part 6 converges on the software architecture.

![ISO 26262 Academy](https://iso26262.academy/logo.png) ISO 26262 Academy

By [Paul Danci](https://iso26262.academy/about) 1 October 2026 7 min read

Share

Text size

Ask a hardware engineer how often a component fails and you get a number, in FIT, with a mission profile behind it. Ask the same question about the software in a brake controller and there is no number to give. ISO 26262 does not pretend otherwise. That one gap shapes how the standard treats software, and it explains most of what Part 6 asks a team to produce.

## A fault that is already there

![Timeline split at start of production. On the hardware rail, random faults appear only in the field, scattered over the years, and are counted in FIT against the Part 5 hardware metrics. On the software rail, a defect is written in during design, passes review, unit test, integration and vehicle test, ships in every vehicle of the build, and fails across the whole fleet at once when a rare input or late interrupt triggers it.](https://iso26262.academy/edge-media/p/blog/diagrams/2026/10/078fdea1-0b10-408e-a660-7e6974ec62f5.svg)

Hardware faults arrive at a rate. A software defect is present from the day it is written.

A software fault is written in, not worn in. It arrives with a requirement that was read two ways, a boundary case nobody specified, or an interrupt that runs later than the design assumed. From that commit on, it ships in every vehicle that carries the build. It does nothing until the input or timing that triggers it turns up, possibly years after start of production, and then it can turn up across a whole fleet at once.

That is why the standard classes software faults as systematic. Hardware gets two treatments: process measures for its systematic faults, and quantitative targets for its random ones, the single-point and latent fault metrics and the probabilistic metric for random hardware failures in Part 5. Software gets only the first. With no failure rate for a function, there is no software row in an FMEDA, and the safety argument has to rest on something else: requirements that can be verified, a structure that contains faults, and verification evidence whose depth rises with the ASIL.

## Software plays two parts in the same safety case

![A microcontroller containing two software blocks: safety mechanisms such as a memory test, a sensor plausibility check and program flow monitoring, and the application software they protect. On the left, random hardware faults (a RAM bit flip, an ADC stuck at a value, a slow clock) are caught by the mechanisms and credited as diagnostic coverage. On the right, the same mechanisms bring systematic faults of their own: a wrong threshold, a check never scheduled, an unhandled boundary value.](https://iso26262.academy/edge-media/p/blog/diagrams/2026/10/20f1e6a2-7083-427c-b927-c8d87403f169.svg)

The code that detects hardware faults is itself subject to Part 6.

This is where software stops being one discipline among several and becomes central. Many of the diagnostics that give hardware its coverage are executed by software. A memory test, a plausibility check between two sensors, a check that the control task ran in the expected order: the hardware metrics credit them, and they are code.

So the same lines do two jobs. They are the mechanism that detects random hardware faults, and they are a possible source of systematic faults of their own. A plausibility check with the wrong threshold is a systematic fault that quietly removes coverage the hardware analysis has already counted. Whoever writes a safety mechanism is carrying two sets of obligations at once: the coverage the hardware analysis assumed, and the Part 6 rigor that comes with the ASIL of the function being protected.

Keep learning

[Free course preview Software Architectural & Unit Design](https://iso26262.academy/features/concepts/software-architectural-unit-design) [Or test yourself with the 7-question demo exam](https://iso26262.academy/demo-exam)

## One controller, many criticalities

![Floor plan of one microcontroller hosting an ASIL D function, an ASIL B function and a QM diagnostic logger, all sharing RAM, processor time and messages. Three numbered arrows from the QM room to the ASIL D room show memory, timing and execution, and exchange of information interference. Below, ISO 26262-6 7.4.8 forks into developing everything to the highest ASIL or showing coexistence through freedom from interference.](https://iso26262.academy/edge-media/p/blog/diagrams/2026/10/2d45e1b3-7138-456a-99cd-7d0b842e6131.svg)

Sharing a controller is a software decision with a safety price.

The second shift is consolidation. A function used to own its ECU. Domain and zonal controllers now run a braking-related function, a comfort feature and a diagnostic logger on one microcontroller, sometimes on one core. Software is what makes that sharing possible, and software is what makes it risky.

ISO 26262-6, 7.4.8 sets the rule. Put components of different ASILs, or QM code and safety-related code, into one software build and the default is harsh: the whole build inherits the strictest ASIL in it. The escape route is an argument that they can safely share the build, built on the coexistence criteria of ISO 26262-9, Clause 6. Nobody wants to develop a logging task to ASIL D, so in practice the work becomes an argument for freedom from interference. Annex D of Part 6 frames that argument in three dimensions: memory, timing and execution, and exchange of information. The QM task must not be able to write into the ASIL task's data, starve it of processor time, or hand it a stale or corrupted message that it then trusts.

Naming the three dimensions is the easy part. Showing that the memory protection covers every write path, that the timing budget holds under worst-case load, and that the communication protection detects the faults it claims to, is where architecture reviews spend most of their time.

## Part 6 converges on the software architecture

![Metro map of ISO 26262-6. The main line runs through Clause 6 software safety requirements, Clause 7 software architectural design, Clause 8 unit design and implementation, Clause 9 unit verification, Clause 10 integration and verification and Clause 11 testing of the embedded software. Annex C, Annex D and Annex E branch off at Clause 7, and a dotted line for tool confidence under Part 8, Clause 11 runs alongside Clauses 8 to 11.](https://iso26262.academy/edge-media/p/blog/diagrams/2026/10/fe26d526-5849-4f27-aa30-b5a83e71752b.svg)

Most of the branch lines meet at Clause 7.

Read Part 6 in order and it looks like a development process: software safety requirements in Clause 6, architectural design in Clause 7, unit design and implementation in Clause 8, unit verification in Clause 9, integration and verification in Clause 10, and testing of the embedded software in Clause 11. Read it for where the decisions are made and the weight moves to Clause 7. The architecture is where a requirement is allocated to a component, where the partitioning that carries the interference argument is chosen, and where the safety analyses and dependent failure analyses described in Annex E are run against the design rather than against finished code.

Unit design works at the other end of the scale. Its job is to keep each unit small, simple and precisely defined at its interfaces, so that the verification Clause 9 asks for is actually achievable. The method tables leave no doubt that expected rigor rises with the ASIL. A unit that is awkward to test at ASIL A becomes a schedule problem at ASIL D.

## The code is not the only software

Some of the safety weight sits in places that do not look like code. Configuration and calibration data are covered by Annex C of Part 6, which is normative: a parameter that can switch a monitor off or move a threshold carries the ASIL of the software it configures. The compiler, code generator and static analyser that turn a design into a binary need their own confidence argument under ISO 26262-8, Clause 11, because an error they introduce is a systematic fault that nobody wrote.

And software keeps changing after the vehicle is sold. Every update reopens the question the original release answered: what does this change touch, and what has to be verified again? A team answers that in days only if the traceability from safety goal to unit was built in from the start rather than reconstructed for the assessment.

## Where to go from here

This article stops at the shape of each problem. The [Software Architectural & Unit Design](https://iso26262.academy/features/concepts/software-architectural-unit-design) concept page goes the rest of the way. Across eleven chapters it derives software safety requirements and traces them down to units, sets out the design principles and patterns the standard expects, shows how an AUTOSAR stack carries the safety mechanisms, argues freedom from interference on multicore controllers, applies dependent failure analysis to mixed-criticality software, and works through unit design rules and case studies on real automotive functions.

Related on the Platform

[Software Architectural & Unit Design Concept](https://iso26262.academy/features/concepts/software-architectural-unit-design)

Last updated: 12 November 2026

Tags [freedom-from-interference](https://iso26262.academy/blog/tag/freedom-from-interference) [systematic-faults](https://iso26262.academy/blog/tag/systematic-faults) [iso-26262-part-6](https://iso26262.academy/blog/tag/iso-26262-part-6) [software-architecture](https://iso26262.academy/blog/tag/software-architecture) [iso-26262](https://iso26262.academy/blog/tag/iso-26262) [automotive-software](https://iso26262.academy/blog/tag/automotive-software) [unit-design](https://iso26262.academy/blog/tag/unit-design)

Share this article

## Comments

## Read the full Software Architectural & Unit Design concept

From HARA to Safety Mechanisms - master every concept with clear, practical explanations and real-world examples.

[Browse Concepts](https://iso26262.academy/features/concepts/software-architectural-unit-design)

## Writing this for a real project?

Have an engineer check your document before the assessor does, or help you write it.

From **$790** with a written quote before any charge

[See how we can help](https://iso26262.academy/features/consulting?service=work_product#sample)

Keep learning

## Guides on this topic.

The guide this article draws on, and where the topic leads next.

[Browse all guides](https://iso26262.academy/features/concepts#library)

- Software [Software Architectural & Unit Design](https://iso26262.academy/features/concepts/software-architectural-unit-design) Learn architecture patterns for fault isolation, testability, and diagnostic coverage in safety-critical software. Covers modularity, design-by-contract, complexity metrics, and structural coverage requirements per ASIL. [Pro](https://iso26262.academy/pricing#plan-basic) [Expert](https://iso26262.academy/pricing#plan-advanced) 11 chapters
- Software [Software Coding Guidelines](https://iso26262.academy/features/concepts/software-coding-guidelines) Learn how to select and enforce coding standards like MISRA C/C++, CERT C, and AUTOSAR C++ for safety compliance. Covers rule tailoring, static analysis, deviation management, and memory/timing/concurrency safety patterns. [Expert](https://iso26262.academy/pricing#plan-advanced) 16 chapters
- Software [Model-Based Development](https://iso26262.academy/features/concepts/model-based-development) Your ASIL D torque limiter was never typed by a human; a code generator produced it from a Simulink model. Learn how ISO 26262-6 accepts autocoded production C through modeling guidelines, the xIL ladder, back-to-back testing, and a tool confidence argument. [Expert](https://iso26262.academy/pricing#plan-advanced) 12 chapters

## Related Articles

[![Close-up of a car's drilled brake disc and caliper on the hub, with sensor wiring running behind it.](https://iso26262.academy/edge-media/p/blog/images/2026/10/96a3fbf9-6e9a-4408-995b-0ba2a9e65e30-1920.webp) Technical

### Freedom from Interference: When QM Code Shares an ECU with ASIL D

6 min Nov 1](https://iso26262.academy/blog/freedom-from-interference-qm-code-shares-an-ecu-with-asil-d) [![Engine bay of a modern car seen from the front, with wiring harnesses, connectors and control units routed around the engine.](https://iso26262.academy/edge-media/p/blog/images/2026/10/3f64cc94-70d0-47a0-bd50-c5adcc433f66-1920.webp) Technical

### The Black Channel: Moving Network Safety to the Sender and Receiver

6 min Oct 30](https://iso26262.academy/blog/black-channel-in-vehicle-network-safety) [![An automotive driver-assistance controller board with two identical processor packages side by side, next to a larger processor, memory, power components and a row of connectors, all on one PCB.](https://iso26262.academy/edge-media/p/blog/images/2026/10/d0792939-6e66-418e-935b-485f4dc3db35-1200.webp) Technical

### The Core Concept of Dependent Failure Analysis in ISO 26262

7 min Oct 2](https://iso26262.academy/blog/the-core-concept-of-dependent-failure-analysis-in-iso-26262)
