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 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.
Plus Common Cause Analysis (PRA, ZSA, CMA) as a parallel track, the way ARP 4761A actually describes it.
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.
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.
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.
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.
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.
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.
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.
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.
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 ↓
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.
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
Function → hazard → fault tree → requirement → evidence, every link live and traceable.
When a part or standard goes stale, every artifact it touches lights up at once. No manual sweep.
An upstream change that undermines a requirement is flagged the moment it lands.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 →
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.
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.
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.
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 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.
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.
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Safety Lab doesn’t do safety engineering. It makes your safety engineering executable, checkable, and provable, and then gets out of the way.
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.
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.
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.
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.
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.
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.
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 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.
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.
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.
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.
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.
Air France 4590 and the Concorde tire burst: what the 1979 analysis rested on, why the trend line was not enough, and what a particular risk analysis is for.
The 737 MAX MCAS change from 0.6 to 2.5 degrees, and the seven places it needed to reach but did not. The case for a digital thread in safety assessment.
United 232 lost all three DC-10 hydraulic systems to one fan disk. Why independence is a geometric claim first, and what a particular risks assessment asks.
Aerospace buyers respect transparency. Every tier includes the full safety workspace; what changes is the scale and the support depth.
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.
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
Spin up a free trial: full Pro tier, no credit card for 10 days.
Start free trial ⬇ Download for Mac ⬇ Download for WindowsIntel Mac version · Windows updates itself · Mac: Help → Check for Updates