Aircraft safety analysis software,
integrated.

One workspace for AFHA, PSSA, SSA, fault tree analysis, and DO-178C/DO-254 traceability. Built by an aerospace engineer for the people who actually have to certify aircraft.

For safety and certification teams on active Part 25, Part 23 and SC-VTOL programs.

Mac download is Apple Silicon · Intel Mac version · Windows updates itself · Mac: Help → Check for Updates

The full safety spine

AFHA → PASA → SFHA → PSSA → SSA → ASA, in one workspace.

The complete ARP 4761A spine lives together, with every artifact connected to every other one. State stays consistent across the workflow without manual reconciliation between documents.

AFHAAircraft FHA
PASAPrelim. AC Safety
SFHASystem FHAs
PSSAPrelim. System Safety
SSASystem Safety Assess.
ASAAircraft Safety Assess.

Plus Common Cause Analysis (PRA, ZSA, CMA) as a parallel track, the way ARP 4761A actually describes it.

The golden thread · live

“Integrated” isn’t a layout. It’s one connected thread.

The promise at the top of this page is a single model, not a bundle of tools. One aircraft function flows down to its systems, its STPA hazards, a failure condition, a fault tree, the common-cause analyses (PRA, ZSA, CMA) that test its independence, the safety requirements that control it, and the verification that closes each one. Reliability and human factors run beneath as feeder lanes, wired into the exact artifact they inform rather than parked in a separate tool. That unbroken line is the golden thread, and it’s what “integrated” actually buys you: move the design and the whole thread moves with it, because there is only one source of truth to drift from.

Function AF-2.1 · Thrust ▾ One function, one thread. There is no all-functions firehose.
FUNCTION SYSTEM STPA FAILURE CONDITION FAULT TREE COMMON CAUSE REQUIREMENT VERIFICATION RAM HUMAN FACTORS Compromised Stale Human AI Engine
This is live. Drag it. Pan the thread, hover a card to isolate it, click any card to open its trace.

That is the workspace’s own renderer above, running on a worked example. On your project it runs on your data: every card carries who authored it (engineer, AI, or a deterministic engine), and every stale, compromised or obsolete artifact is surfaced as a named finding rather than a silent gap. Click any card to lay out its ecosystem, then generate its full trace report in one click.

The deterministic MBSA core

The model doesn’t illustrate the analyses. It produces them.

This is where the golden thread stops being a filing discipline and becomes an engine. One behavioral model of the aircraft (functions, systems, resources, zones, typed deviations, operating modes) compiles into the analyses, proves the safety claims, and answers what-if questions live. Built on the ARP4754A / 4761A methodology. No sampling, no heuristics, no AI in the loop: a deterministic MBSA core: same model in, same analyses and verdicts out, on any machine, every time.

⚙️

The model compiles the analyses

Availability rules compile into fault trees, and every compile is proven equivalent to the model it came from, automatically. Hand-built trees stay first-class; compiled ones can never quietly disagree with the model.

✅

Safety claims, machine-checked

No single failure reaches a Catastrophic condition. No single zonal event does either. Dispatch relief never stands alone. Model covers every Cat/Haz condition. Twenty-plus live checks prove these on the model itself, and every exception carries a signed engineering basis that reopens if the design moves.

⚡

Fault injection you can watch

Click a system, a shared resource, or a whole zone failed. The dependency cascade lights up, the availability arithmetic shows its work, and the tripped failure conditions appear with their severities: a read-only lens for design reviews and what-if sessions.

⚖️

Two engines, forced to agree

Every evaluation runs twice, once as clause arithmetic and once as compiled model logic, and the two are cross-checked on every run. Disagreement renders as a named finding. Corroboration isn’t a claim here; it’s a mechanism.

🔀

Failures are typed. Reconfiguration is real.

Loss, erroneous, and inadvertent behavior propagate as distinct lanes, so every claimed monitor or blocking path becomes a claim the common-mode analysis must own. Fallback modes are first-class, and the switchover itself is a named failure mode, corroborated by seeded Monte Carlo. Functional FMEAs generate from the model and enter your analysis only with an engineer’s signature.

📌

Standing on named assumptions

Model rules cite the assumptions that substantiate them. Invalidate one and every claim resting on it is named on the spot: analyses, dispatch limits, signed acceptances, gates. The model’s schema is versioned and enforced, so it can’t silently drift.

And the core plugs into the tools you already run: architecture in from your MBSE tool over SysML/XMI, requirements flowing both ways with Jama · Polarion · DOORS, with live change tracking on Jama, verification status returning over ReqIF. See the integrations ↓

From the field

“The most complete safety analysis tool I’ve used.”

a safety engineer

And the part nobody forgets is the golden thread: the interconnectedness, and the live flagging of obsolescence and compromised requirements the moment something upstream changes.

Used by DERs on active certification programs
Validated across multiple eVTOL beta programs
Loved by industry veterans
Very powerful and highly visual, better than some of the tools I’ve used with previous clients, including very large aeronautical companies. Its strongest points are document export and full traceability of the whole process, from requirements V&V through to the safety CCAs. Really impressed.
Absolutely love the golden thread.
I’ve worked with three major OEMs, and I haven’t seen anything this comprehensively interconnected. Very impressive.
One of the most complete safety tools I’ve seen.
I love how you can see how everything affects each other, and that there’s a path to qualifying the tool per DO-330 and measuring compliance against ARP4754A. Being able to link PRs to the affected items and track them is a biggie for me on the software side. Seriously well done.
You’re solving a big problem with certification that the big corporate players haven’t figured out, and probably won’t. The hard part is getting them to recognize it and act. Keep it up.
Overall, it is an incredibly robust, modern workspace built specifically for the reality of modern, complex aircraft architecture. It treats safety as a live, evolving system rather than a static stack of paperwork to be filed at the end of a design cycle.

Quotes are the personal views of individual users. A company name shows where the person works; it is not an endorsement by that company.

What people call out most

One connected thread

Function → hazard → fault tree → requirement → evidence, every link live and traceable.

Obsolescence, in real time

When a part or standard goes stale, every artifact it touches lights up at once. No manual sweep.

Compromised requirements, surfaced live

An upstream change that undermines a requirement is flagged the moment it lands.

Autopilots

Plain questions in. Plans and analyses filled in.

The autopilots take your team through the work in order, one plain question at a time. Each question is built from your own project: the functions, the failure conditions, the architecture and the CAD model. Every answer says what it changes before you pick it and is written straight into the analysis, so nobody starts from a blank sheet and nothing is entered twice. The engineering judgment stays with your engineers.

📋

Plan Autopilot

The System Safety Program Plan, Human Factors Plan and Reliability and Maintainability Plan, written from your answers. The certification basis sets the classifications, probability targets and DALs, from the same engine the analyses use. Each assessment is defined by its methods, the inputs it needs and the outputs it must produce, with diagrams in the style of the ARP 4761A and ARP 4754B examples. Cover page, contents and revision history included, with export to Word.

🗺️

ZSA Autopilot

The zonal safety analysis worked out from your CAD model, zone by zone: what sits in each zone and how much losing it matters. It asks only the real questions, each shown on the model: a fluid line above electronics, two lanes of the same function side by side, a hot duct near fuel or hydraulics, and where a leak drains.

💥

PRA Autopilot

Particular risks traced on your CAD model: rotor burst fragments to AC 20-128A, tire burst, fire, bird strike and lightning. It shows what each event can reach and asks only where one event could take out more than one lane of the same job: protect it, move a lane, or accept it with the reason.

🧑‍✈️

HF Autopilot

The human factors work through the design cycle, in order: who does each function, the crew procedures, workload in every flight phase from times you measure or estimate, crew error, alerting, the 25.1302 questions, reach and view, and the minimum flight crew. Each result feeds the HF plan and the safety analysis.

✈️

PASA Autopilot

One Preliminary Aircraft Safety Assessment for the aircraft, with an appendix per function. For each failure condition: how the systems feed it, what they share, its fault tree and what it says, the numbers against the objective, and the requirements that close it. It asks whether each system tree is ready to be linked in, and a tree nobody has built yet says so.

🧩

PSSA Autopilot

One Preliminary System Safety Assessment per system. Each failure condition starts from the system FHA and the budget the aircraft hands down, the stricter one where two apply. Then the tree down to items, item assurance levels, hidden failures and their check intervals, independence claims, the requirements and the path to compliance.

🔬

SSA Autopilot

One System Safety Assessment per system, opened once its PSSA is baselined. The trees are worked out again from the bottom up with the real rates from the FMEA, the budget is checked against the design, and every requirement shows its verification method, its evidence and its status.

🏁

ASA Autopilot

One Aircraft Safety Assessment, opened once the PASA and every SSA are baselined. Every aircraft failure condition is sorted: closed by an SSA, needs aircraft-level work, or open. Trees that span several systems are worked out again with the systems’ measured numbers, and the common causes are closed.

🔗

CMA Autopilot

Common mode analysis, one independence claim at a time. It takes each independence the fault trees rely on, asks the questions for that claim, and builds the CMA report from the answers. A concern that needs one raises its requirement.

🕸️

Interdependence Autopilot

Pick a failure condition, add the systems that do the job or cause it by failing, with their functions, and the shared resources that feed them. The interdependence and common resource tables come out in the layout of the ARP 4761A example, showing only what applies. What your own project data says feeds it cannot be left out.

🎛️

MAC Autopilot

The minimum acceptable configuration, found by switching things off. You set how each system is built, at assembly level. The tool switches assemblies off, asks whether the aircraft can still do the job, and works out every mix it can from your answers. The rules come out as named combinations with your reason for each, marked Assumed until they are compared with the system design description.

🧮

CoFFE Autopilot

Combined functional failure effects. The tool writes out every mix of failed, degraded and working, asks only what it cannot work out, and fills the full table, its summary, the gate under the failure condition and the pairs of failures that share one resource.

Every answer records who gave it and when, and the analyses the autopilots fill stay open for your engineers to review and sign. How the autopilots work →

Generated, not typed

Fault trees and requirements, generated.

The engine does this work, not the AI. Same inputs, same results, every number traceable to what drove it. Your engineers review, link and sign; they do not start from a blank sheet.

🌱

A fault tree for every failure condition

Once a failure condition is classified, its tree exists with its top event and its target from your certification basis. Your minimum acceptable configuration compiles into fault trees, and a second engine checks they hold exactly the same combinations. A tree nobody has built yet says so. Nothing is invented under it.

🌐

Multi-system, multi-function trees

One aircraft tree across systems and functions. A system failure condition is one node, shared by every aircraft tree it feeds. It keeps the strictest budget any of them gives it, and its own tree takes that as its target. The aircraft trees and the system trees cannot disagree.

⚖️

Fault trees that rebalance themselves

Hold one input tighter and the rest of the gate takes up the spare at once. The gate is flagged as rebalanced for an engineer to accept or keep tighter, signed and reversible. A gate over its budget is an open item, never a quiet number.

🧾

AutoReq: requirements, generated

AutoReq writes the safety requirements straight from your fault trees and assessments: probability budgets, development assurance levels, shared resources and common-mode concerns. Each one says why it exists and what drove it, and flows down to the systems that feed the failure condition. A shared resource gets one requirement, at the strictest budget any tree gives it. Same analysis in, same requirements out.

What's inside

Where the math is first-class.

Every analysis engine is independently verified against textbook benchmarks. The math is exposed, the references are cited, and you can audit any computation back to the standard it implements.

🌳

Fault Tree Analysis

Quantitative fault tree analysis with minimal cutsets, K-of-N voting gates, dynamic gates (PAND / SPARE / FDEP), and common-cause failure models (β-factor, α-factor, MGL).

📚

Component reliability library

200+ public-domain failure rates from MIL-HDBK-217F, NSWC-11, DOT-FAA-CT-83-49, with π_T (Arrhenius) stress prediction. Bring your own NPRD / EPRD via BYOL if your organization is licensed.

📋

Means of Compliance matrix

Every requirement maps to a 14 CFR / CS-25 / AMC paragraph with the method of compliance (analysis / test / demonstration / inspection / similarity). Filters by your project's cert basis automatically.

📦

Configuration baselines

Snapshot the entire project at each milestone (PDR, CDR, submission) with a SHA-256 hash. Iterate freely in the live project; baselines stay immutable for the audit trail.

📝

Reports your DER actually reads

AFHA, PASA, SFHA, PSSA, SSA, ASA, PRA, ZSA, CMA: all nine ARP 4761A reports generated to Word or PDF, with your own org template if you have one.

Reliability & Maintainability · Pro+

A complete R&M program, on the same golden thread.

Not a bolted-on calculator. The same failure rates that drive your fault trees drive prediction, spares, maintenance intervals and cost. A field finding on a rate a handed-off safety argument used shows up on the dashboard as a challenge to that gate.

📈

Prediction to field data, closed loop

Reliability prediction, MTTR/MDT ledgers, dispatch reliability, and FRACAS with statistical verdicts. A field MTBF is VERIFIED only when the chi-square lower confidence bound clears the prediction, never on a point estimate.

🎲

RBD: exact and Monte Carlo

Exact k-of-N block diagrams with live fault-tree duals, plus seeded Monte Carlo for what product forms can't express: standby redundancy, imperfect switching, warm dormancy, phased missions. Same seed, same number, reproducible for the auditor.

📐

Life data, honestly bounded

Weibull by median-rank regression and maximum likelihood side by side, with Fisher confidence bounds. A wear-out claim needs the whole β interval above 1; a point estimate alone is not evidence. Crow-AMSAA growth with goodness-of-fit.

🛠

MSG-3, all four programs

Systems & powerplant analysis with the full logic cascade, plus structures (AD/ED/FD ratings → derived task sets), zonal derived from your ZSA register, and L/HIRF protection features, all pushing into one maintenance ledger with provenance.

✈️

MMEL & dispatch, computed

Dispatch rulings from exact minimal cut sets: an item whose loss leaves order-1 protection is NO DISPATCH, mechanically. Quantitative exposure via transient recomputation, time-limited dispatch budgets from your safety targets.

💰

Spares, intervals, cost

Poisson spares at your fill rate, PM intervals reconciled against latent-failure not-to-exceed limits, testability rollups, level-of-repair, and life-cycle cost, priced from the λ and MTTR the safety case already carries, so design trades price themselves.

Human Factors

The crew is a component. Model it like one.

Most safety cases credit the pilot in prose (“crew detects and reverts”) and never say how long that takes, whether anyone measured it, or what else the crew was doing at the time. Safety Lab makes the human claim a typed, cited, checkable record on the same golden thread as the fault trees, so an unearned credit fails an invariant instead of surviving review.

📖

298 page-cited reference values

Reaction times, detection thresholds, reach and workload data drawn from the NASA Human Integration Design Handbook, each carrying its section, author-year, the printed page, and a verbatim quote containing the number. Every value is tagged aircraft, spaceflight, or general, because HIDH is a spaceflight handbook and pretending otherwise is how a bad number gets credited. A preset seeds a field; it never fills one, and never marks anything validated.

🔒

Two lanes: credited and uncredited

Every human-factors assumption can carry both the value you hope to credit and the conservative value you must use until someone proves it. The credited lane applies only once the assumption is Validated or Verified. A Catastrophic or Hazardous claim resting on an unvalidated credit is a hard invariant failure, not a comment or a warning.

⏱

Workload saturation, arithmetic not vibes

Per crewmember, per flight phase, across the five HIDH channels (visual, auditory, cognitive, psychomotor, verbal), declared co-active tasks are summed against the 80% time-occupancy red line. Ledger arithmetic: no solver, no pilot model, no simulation. And an exposure duration is never silently reused as a response window; if the phase declares no window, the check declines to run rather than invent one.

⚖️

Severity reconciled against workload

AC 25.1309 writes severity in workload language, so the two can be compared. A task the model says drives excessive workload sitting under a Minor severity classification is a two-band gap, and the FHA row says so on its face. Advisory only: it flags the contradiction for an engineer to resolve, and never overrides your classification.

🧪

Trials enter as evidence, not as truth

Sim campaigns, flight test, bench trials and literature ingest with metric, value, sample size and a real source, because uncited evidence is rumor, so the source field is mandatory. Measured worse than assumed reads CONTRADICTS; at or better reads SUPPORTS. Nothing self-validates: a human validates in the register, and a Validated assumption whose own evidence contradicts it gets flagged until someone answers for it.

📏

Ergonomics on the standards spine

ISO 9241 and MIL-STD-1472 sit on the spine by designation, title and role: cite-and-point, never a word of licensed text stored. A Fitts’ Law movement-time calculator in the Shannon formulation that requires cited coefficients, because a borrowed coefficient without a citation is a guess wearing a suit. Seven-factor human-performance taxonomy for STPA causal factors, with NASA-HFACS nanocodes as the deep layer.

Connectivity

Your requirements live in an ALM. Ours plug into it.

Polarion, Jama Connect, IBM DOORS: Safety Lab imports the standard ReqIF interchange every major requirements tool exports, so requirements and FHA content arrive with their identifiers, attributes, hierarchy and trace links intact. Not as text to re-type.

🔗

ReqIF from any ALM

OMG-standard ReqIF import with a preview before anything touches your project. Works with Polarion's Round-trip export, Jama Connect Interchange, DOORS, Codebeamer. One importer, every tool.

🔁

Re-import is a sync, not a paste

Rows match on their source identifiers: unchanged rows skip, changed rows update in place and keep their safety traces, deleted rows are flagged for disposition, never silently removed while analyses still reference them.

🛡️

FHA import that refuses to guess

Failure conditions import with severity, phases and effects, and a severity wording the importer can't map unambiguously arrives unclassified with a warning, because a misread classification is worse than a missing one.

📐

Architecture from your MBSE tool

SysML blocks become systems, activities become functions, internal-block connectors become the interfaces and resources the dependency and propagation models run on, imported over standard XMI (Cameo and friends), re-import diffing changes onto the thread. Pilot program: bring a sample export.

📡

Status flows back, live

Your requirements team keeps working in their tool. The live bridge watches your Jama project and stages every change for signed import. Nothing crosses the boundary without an engineer’s signature, and your API token never leaves your machine. Verification status, MoC state, and DAL flow back over ReqIF today; direct API write-back is next. Polarion rides the same connector.

🔒

Your data stays yours

Imports parse entirely in your browser; requirement data never transits our servers. Excel round-trip for tools without ReqIF; live API synchronization with status write-back available as a pilot.

The story

It’s not us. It’s you.

Safety Lab doesn’t do safety engineering. It makes your safety engineering executable, checkable, and provable, and then gets out of the way.

🧠

Your judgment

Every hazard call, severity, independence claim, β, and acceptance carries your signature. The engine derives everything else from those decisions and re-derives it when they change. Computed output never overwrites an engineer’s word.

📌

Your assumptions, load-bearing

Every claim knows what it rests on. Assumptions bind to the analyses, model rules, dispatch limits and dispositions built on them. Invalidate one, and every exposed claim is named on the spot. An assumption nothing rests on gets flagged too.

🖥

Your machine, your data

Analyses parse and compute in your browser. Imports never transit our servers. The engine self-test runs the 25 published-reference benchmarks on your hardware and stamps the result into every evidence package.

🔁

Your tools, not ours

Requirements stay in Polarion, Jama, or DOORS; architecture stays in your MBSE tool. Safety Lab reads them, builds the safety argument on top, and reports status back. No migration, no lock-in, no second source of truth.

🔍

Your proof, re-runnable by anyone

Deterministic end to end: same project file, same trees, same requirements, same verdicts, on any machine, including your DER’s. The hash-chained journal makes the history itself tamper-evident.

✍️

Your name on it, deservedly

When the evidence package goes out, it is your engineering: every derivation traceable to your inputs, every acceptance carrying your basis, every gate signed by your team. The tool just made it impossible to lose the thread.

The discipline

What the tool refuses to do.

Anyone can add features. The reason a DER trusts a workspace is what it will not let slide. These guardrails are not a mode you switch on. They are the design.

🧮

The AI never does the math

The deterministic engine owns every computation. The AI drafts structure and accelerates the busywork, but it never does the math, and nothing it produces enters your analysis until a qualified engineer reviews and accepts it.

✍️

Nothing is approved on trust

An approval is a re-authenticated signature bound to the exact analysis it signs. If the analysis changes after sign-off, the signature no longer matches that state, and the record says so.

⛓️

The record can’t be quietly changed

Saves, sealed revisions, and sign-offs land in an append-only, hash-chained ledger. Any later edit or deletion of a past record is mathematically detectable: the audit trail a certification authority expects.

🔍

The math is never a black box

Every engine is independently verified against textbook benchmarks, the references are cited, and any computation traces back to the standard it implements. You can always check our work.

Articles

When safety assumptions meet the aircraft.

Engineer-to-engineer analyses of accidents from the public record: what the safety analysis assumed, where the assumption stopped being true, and what a connected model asks instead.

All articles →

Pricing

Real numbers. No "contact us" for the basics.

Aerospace buyers respect transparency. Every tier includes the full safety workspace; what changes is the scale and the support depth.

Education
Free / forever
Verified .edu or academic, for individual coursework, thesis work, and research.
  • Full FTA / FMEA / FHA tools
  • Component library
  • Reports in Word and PDF
  • Email support
Sign up free
Pro
$1,500 / seat · month
Working safety engineers: the full classical toolset, no AI assist.
  • Everything in Education
  • End-to-end requirements workflow
  • Verification evidence tracking
  • Configuration baselines
  • Means of Compliance matrix
  • 10-day free trial
Start 10-day trial
Enterprise
Custom
Organizations running certification programs: teams, controlled environments, qualification support.
  • Everything in Pro+, multi-seat
  • Independent review & sign-off chains, gates & evidence packages
  • RM integration: Jama live + ReqIF (DOORS / Polarion / Codebeamer)
  • SSO & user provisioning
  • On-prem / air-gap deployment (ITAR & non-US regimes)
  • DO-330 tool-qualification support · support SLA
Talk to us about your program

Pro and Pro+ are individual licenses, priced per seat and billed monthly. Cancel anytime. Use by an organization on an active type-certification program requires an Enterprise license. Education is free for verified academic use. How your data is handled, including ITAR-aware routing of AI requests, is set out on the trust page and the security page.

About

For safety engineers, by a safety engineer.

Muhammad Waqas Nafees

Founder · Safety Lab Aero

I've spent years inside Part 25 and SC-VTOL programs, running FHAs, building fault trees, allocating DALs, and walking DERs through verification. The classical safety toolset has earned its place; its methods have been refined over decades of certified flight.

What I wanted was a single workspace where every artifact connects to every other one, where the FHAs, fault trees, requirements, and supporting analyses share state automatically, instead of living in separate documents that get reconciled by hand.

Safety Lab Aero is that workspace. It's designed to fit how safety teams already work, and to give them back the time currently spent reconciling.

Questions? waqas.nafees@safetylabaero.com

Stop reconciling. Start certifying.

Spin up a free trial: full Pro tier, no credit card for 10 days.

Start free trial ⬇ Download for Mac ⬇ Download for Windows

Intel Mac version · Windows updates itself · Mac: Help → Check for Updates