On the data sheet of a flight control computer, the software’s design assurance level is written before the first line of code exists. It comes neither from the supplier nor from a design-office arbitration: it falls out of a safety analysis that has classified the consequences of the function’s failure conditions. What remains is the question that decides a program’s budget: what happens when the architecture allows this level to be lowered by one notch?
A Design Assurance Level Is Not a Reliability Figure
The most costly misreading is to treat this level as a reliability rating, as if level A software failed ten times less often than level B software. Hardware, for its part, fails at random: a rate is assigned to it, composed into a fault tree, and a probability with physical meaning results. Software does not wear out. A software failure is a design error present from the very first flight, latent until the combination of inputs and timing that reveals it occurs.
Its rate of occurrence is therefore a property of the demand placed on it, not of the component, and no test campaign of reasonable duration can measure it at the orders of magnitude that matter for certification. Hence the deliberate renunciation in the texts: no probability is credited to a software item in a fault tree, and it is replaced by a requirement for rigor in producing evidence. The design assurance level measures an effort of specification, verification, traceability and independence — never a quality of the binary delivered. Complex electronic hardware falls under the same scale, under its own design standard.
The design assurance level isn’t about how often software fails, but how carefully it was designed and tested. Unlike hardware, software doesn’t wear out—its failures come from mistakes made during development, which can only be caught through rigorous testing and review.
On an Airbus A350, the flight control software operates at design assurance level A for critical functions like pitch control. This means every line of code must be exhaustively tested, reviewed by independent teams, and verified down to the machine code level—even though the software itself doesn’t “fail” in the way a mechanical part might.
From Function to Item: The Chain That Sets the Level
Everything starts from the functional hazard analysis, carried out at aircraft level and then by system. For each function, the failure conditions are enumerated: total loss, partial loss, detected error, undetected error. The latter is almost always the most severe, and it is what drives the level: a computer that lies without saying so deprives the crew of its only defense.
Severity is classified by the effect on the aircraft, on the crew’s task and on the occupants, in a given context of flight phase and configuration. It is the most penalizing case that sets the requirement, the same loss of function being able to be major in cruise and hazardous on final approach. Severity then triggers two requirements of a different nature — a quantitative objective on random hardware failures and a design assurance level on systematic errors — which rise together and never offset one another.
The preliminary system safety assessment then descends into the architecture, fault tree in hand. An item’s level is set neither by its perceived importance nor by its size, but by the worst failure condition it can contribute to: a module of a few hundred lines that shares a memory space, a scheduler or a bus with a critical function inherits that function’s level, unless partitioning has been demonstrated.
| Severity class | Characteristic effect | Random-failure objective | Design assurance level |
|---|---|---|---|
| No effect | No operational consequence | None | E |
| Minor | Nuisance, slightly increased workload | No numerical objective | D |
| Major | Significantly reduced margins, penalizing workload | On the order of 10-5 per flight hour | C |
| Hazardous | Large reduction in margins, crew task compromised | On the order of 10-7 per flight hour | B |
| Catastrophic | Loss of the aircraft, multiple fatalities | On the order of 10-9 per flight hour | A |
What a Single Notch Really Changes
Moving from one level to the next is not simply a matter of working more carefully: named objectives appear, with evidence to be archived. The two structuring levers are structural coverage and the independence of verification activities. Coverage answers a precise question: did the requirements-based tests exercise the code as written, and is any unexercised code justified or dead?
Independence, for its part, is not a posture: the activity is carried out by someone other than the author, with a visible separation in the plans, the qualifications and the records. A review signed by the designer themselves, however excellent, does not count as independence — it is one of the points where audits find the most nonconformities, since separation is costly in a small team.
| Level | Structural coverage | Independence | Dominant cost item |
|---|---|---|---|
| A | Modified condition/decision, plus object code if the compiler produces non-traceable code | Extensive | Analysis of generated code, tool qualification |
| B | Decision | Broad | Systematic cross-review, traceability |
| C | Statement | Limited | Justification of derived requirements |
| D | None | Marginal | Configuration control |
| E | Not applicable | Not applicable | Demonstrating the genuine absence of effect |
Cost does not increase linearly. The first notch brings in structural coverage and the justification of derived requirements, which reawakens the safety analysis: any requirement not traceable to a higher tier must be sent back to it, to check that it does not introduce an unevaluated effect. The last notch is of a different nature — demonstrating that each condition in a Boolean expression independently influences the outcome, and going down to object code as soon as the compiler departs from the source. This is where budgets run away, on work that advances no functionality.
Lowering a Notch Through the Architecture
The mechanism is legitimate and framed: if the higher-level failure condition requires the joint failure of several independent members, each may carry a level lower than that of the function, since a design error in a single member no longer suffices to produce the dreaded effect. Two standardized allocations exist. In the first, one member retains the top level and the other drops markedly: this is the case of a rich primary channel monitored by a simple channel. In the second, both members drop by a single notch, which suits two symmetrical channels of comparable complexity. The exact grid appears in the systems development guide; what matters here is that this choice shapes the program’s entire industrial organization.
The same logic governs monitored architectures: a command channel, and a monitor channel that compares and trips the output. The downgrade is only earned if the monitoring genuinely covers the failure modes considered, within timeframes compatible with the exposure time adopted, and if tripping leads to a safe state. Monitoring that is blind to the case where both channels read the same erroneous sensor does not do what it is believed to do.
The most tempting lever remains: reclassifying severity by relying on an alarm and a crew procedure. This is only acceptable if the alarm itself carries a design assurance level consistent with the credit given to it, if the procedure appears in approved documentation and is trained, and if the workload has been assessed in the most penalizing flight phase. Otherwise, the design assurance level obtained is borrowed from the crew.
The Price of Independence
As soon as a level has been lowered through the architecture, the document that carries the case is no longer the software development plan: it is the common-mode analysis. It must establish that no single event, no shared cause, no identically repeated error can bring down both members.

Common causes fall into known families. The first, by far the most formidable, is the shared requirement: if both channels execute the same specification and that specification is wrong, dissimilarity of code, language, processor and team is of no use — and experience feedback from the field regularly places the requirements error at the top of the causes of software defects. Next come shared resources — power supply, clock, bus, a single upstream sensor — then the shared installation zone, which the zonal analysis and particular risks assessment must sweep.
A more discreet family deserves attention: maintenance. Two channels independent by construction become dependent again if the same technician applies the same erroneous procedure to both, or if the same faulty configuration data is loaded on both sides. Parameter tables and onboard databases carry the design assurance level of the software that uses them, precisely because they form a very short common-mode path between otherwise dissimilar channels.
Integrated modular avionics adds its own pitfall. Hosting a low-level application alongside a high-level one lowers nothing: the partitioning mechanism carries the highest level among the hosted applications, and so-called robust partitioning must be demonstrated in space, in time and in access to shared resources. There is no free space in a high-level computer.
The burden, finally, is permanent. An independence argument is not a deliverable that gets archived; it is an assumption that every modification puts back in play: a sensor becoming shared between the two channels, two buses merged to save weight, the same code generator used on both sides. Any one of these industrial decisions can bring the software back to the top level, with the entire verification to redo.
The trap. A downgrade is rarely lost at initial certification, where it is closely examined. It is lost afterward, through the accumulation of seemingly harmless modifications that reintroduce a shared resource, team, tool or piece of data. The case file still shows a lowered level while the assumption that justified it is no longer true, for lack of having folded the common-mode analysis into the change-control loop.
The right reflex. Keep an explicit list of the downgrades obtained through architecture, each with the precise independence assumption it rests on, and make it a mandatory checkpoint of change control. Any change touching a resource, tool, piece of data or team cited in an assumption reopens the analysis — not just a note in the file.
What the Design Assurance Level Changes in Operation
A crew never sees a design assurance level, but they feel its consequences: departure conditions requiring two channels available, a technical tolerance refusing deferral of a monitoring computer that seems useless since the function works, automatic inhibition of certain modes in a degraded configuration. A failed monitor is not one function fewer — it is a downgrade collapsing.
On the maintenance and certifying-staff side, the sensitive point is the software configuration: loadable items carry a part reference and a status, and compliance is judged on the approved status, not on observed behavior. Loading an identical standard on two channels that the case file declares dissimilar, or letting two channels diverge after a partial intervention, produces an aircraft outside its approved definition without any functional test revealing it.
For anyone preparing a type qualification, the useful angle is that of the reversionary modes: knowing that a control law degrades to a simpler mode is not enough — one must know what that mode retains, what it gives up, and why it was judged sufficient. The answer lies in the limitations and abnormal procedures, often the most discriminating material of a technical oral exam — usefully complemented by feedback from the FL330 technical forum.
What to Check in Your Own Documentation
In a design office, the most cost-effective verification does not concern the code but the traceability of the assumptions. Each lowered level must connect, on a single page, to the failure condition that generated it, to the allocation adopted, and to the itemized list of resources whose independence is claimed. Without that page, the downgrade rests on the memory of a few people, and that memory retires.
On the operator and continuing-airworthiness side, scrutiny bears on the ability of tracking to detect a configuration divergence between redundant channels, and on the justification of entries in the minimum equipment list touching on monitoring. An entry whose rationale no one can explain any more signals an architecture argument lost between the type certificate holder and the operation.
A gray area remains, and it is growing. Model-based development and automatic code generation shift human error toward modeling and toward the tool: the burden of proof shifts to that tool’s qualification, and the dissimilarity of two channels produced by the same workshop becomes illusory. In the same movement, the share of configuration data within the certified perimeter increases, even as it remains held to less rigor than the code that reads it. It is the most frequent blind spot for anyone coming from software and discovering safety analysis — for instance through the FL330 technical programs.
This article sets out a general mechanism and does not substitute for any binding document: the applicable certification specifications, the means of compliance accepted by the authority, and the approved documentation of the type certificate holder and of the operator take precedence over what is written here.
Questions fréquentes
Is a level A software more reliable than a level C software?
Nothing guarantees that. The design assurance level describes the rigor with which the development and verification evidence was produced, not a failure rate of the delivered product. A software failure is a design error, present from the very first entry into service and revealed by a particular combination of inputs. That is why no probability is credited to a software item in a fault tree.
How is the level required for a computer chosen at the outset?
It follows from the functional hazard analysis. The function’s failure conditions are enumerated, and the severity of each is classified by its effect on the aircraft, on the crew and on the occupants, in the most penalizing flight phase. The severity class simultaneously sets a quantitative objective on random hardware failures and a development assurance level for systematic errors.
Why doesn’t a downgrade obtained through architecture always save money?
Because the effort shifts elsewhere instead of disappearing. What is no longer spent on structural coverage and independent verification must be spent on common-mode analysis, on demonstrating partitioning, on zonal analysis, and on maintaining that argument through every modification. On an architecture already constrained in shared resources, the analysis cost can exceed that of the level one was trying to avoid.
Are two channels written in different languages by two teams independent?
Not necessarily. Dissimilarity of implementation does not protect against a requirements error, which experience feedback regularly places at the top of the causes of software defects: if both channels implement the same wrong specification, they fail together. Add to that shared resources, a common installation zone, identical code-generation tools, and configuration data loaded on both sides.
Why does a technical tolerance sometimes forbid departure with a failed monitor even though the function remains available?
Because the monitor is the member that justifies the reduced design assurance level of the command channel. Without it, the architecture argument collapses and the remaining software is no longer developed to the level required by the severity of the failure condition. The function appears intact, but the safety demonstration no longer is.
Does configuration data fall under the same level as the software?
Yes, when it influences the function’s behavior. Parameter tables and onboard databases carry the design assurance level of the software that uses them, along with the corresponding configuration-control requirements. They also form a very short common-mode path between two otherwise dissimilar channels, which makes them a priority point of examination.

Leave a Reply
You must be logged in to post a comment.