1. What Is the Future Airborne Capability Environment (FACE) Approach?
The Future Airborne Capability Environment (FACE) Approach combines an open software architecture standard with business practices designed to make software capabilities more portable and reusable. It is a technical and acquisition approach—not a prioritization matrix or a complete aircraft architecture. Its objectives are greater affordability and faster delivery of new capabilities.
For executives developing avionics and uncrewed systems, the central question is practical: which mission-software functions should become reusable products, and what must change in architecture, procurement, and integration to make that reuse economical? Consultants can structure this decision and its implementation, while specialist engineers retain responsibility for technical assurance.
2. Origin and Background
FACE emerged from a government–industry collaboration rather than a single inventor. The Open Group publicly announced the consortium on July 21, 2010, working with the U.S. Navy Air Combat Electronics Program Office, the Army Aviation and Missile Research and Engineering Center, and avionics suppliers. The initiative addressed expensive, slow capability upgrades and incompatible aircraft computing environments.
The first FACE Technical Standard was released on January 30, 2012. Its original focus was military avionics, and that remains the most relevant context here. Although the approach can apply beyond airborne systems, it should not be treated as a universal architecture prescription for every aerospace business.
3. How the Future Airborne Capability Environment (FACE) Approach Works
FACE separates capability-specific software from computing-environment and platform dependencies through standardized interfaces. This creates opportunities to reuse software without rebuilding every surrounding service. The name indicates its purpose; the letters are not four formal management stages.
- F — Future: accommodate capability evolution.
- A — Airborne: reflects its military-avionics origins.
- C — Capability: emphasizes reusable software functionality.
- E — Environment: establishes a common software computing environment.
The five architectural segments
| Segment | Role and aerospace interpretation |
|---|---|
| Operating System Segment (OSS) | Foundational computing services, including execution and resource management. |
| Input/Output Services Segment (IOSS) | Standardized access to platform input/output services. |
| Platform-Specific Services Segment (PSSS) | Platform-dependent services and data products that isolate aircraft-specific differences. |
| Transport Services Segment (TSS) | Message-based communication between software components. |
| Portable Components Segment (PCS) | Portable applications and common services, such as reusable mission-processing functions. |
These are logical software boundaries, not five physical computers. Their purpose is separation of concerns: aircraft-specific dependencies should not unnecessarily spread into portable capability code.
Data, profiles, and conformance
Interfaces alone are insufficient. The FACE data architecture addresses exchanged data definitions; teams still need to reconcile meaning, units, coordinate frames, and time references. Operating-system profiles—General Purpose, Safety, and Security—tailor the permitted computing environment and interfaces.
Formal conformance applies to a declared Unit of Conformance (UoC) against applicable requirements. Suppliers can claim a product is FACE Conformant only after completing the conformance process. This establishes standards conformance, not aircraft airworthiness; FACE conformance complements rather than replaces airworthiness processes.
The business approach matters equally. An open interface standard does not require suppliers to surrender intellectual property. Contracts must establish the licenses, deliverables, and rights needed for the intended reuse.
4. When to Use the Future Airborne Capability Environment (FACE) Approach
Consider FACE when planning new mission-computing environments, major avionics upgrades, or component replacements where software reuse is a credible objective. The approach explicitly accommodates new designs and upgrades to enduring systems.
Useful executive questions include:
- Can a mission application serve several aircraft programs without maintaining separate codebases?
- Which dependencies prevent a supplier component from moving between computing environments?
- What investment in interfaces, data models, and integration infrastructure would make reuse worthwhile?
Evaluate technical fit and commercial feasibility together. Require architecture documentation, interface definitions, software dependencies, performance budgets, assurance requirements, licenses, and integration-cost estimates. Involve engineering, program management, acquisition, safety, cybersecurity, and suppliers.
FACE is especially compelling when common capabilities recur across platforms. It may be a poor retrofit choice for tightly coupled legacy software with limited remaining upgrade opportunities. Separate an initial management diagnostic from engineering demonstrations and qualification work; documentation quality, laboratory access, and unresolved dependencies determine the effort.
5. How to Apply the Future Airborne Capability Environment (FACE) Approach: Step-by-Step
- Clarify the decision and scope.
Define the capability, aircraft variants, computing environments, and upgrade horizon. Specify whether the decision concerns a reusable application, a shared computing environment, or migration of an existing subsystem. Name the executive sponsor and the decision required.
- Gather technical and commercial inputs.
Collect software inventories, dependency maps, interface specifications, data definitions, processor and memory budgets, timing requirements, assurance artifacts, and supplier agreements. Establish a baseline for integration effort and recurring platform-specific engineering.
- Define the units of analysis.
Assess bounded software capabilities and supporting services—not entire aircraft as supposedly interchangeable products. Distinguish the intended reusable capability from its platform adapters, runtime dependencies, and formal conformance boundary.
- Construct the architecture and evidence map.
Map components to the five FACE segments. Record interfaces, exchanged data, dependencies, suppliers, and ownership. Specify the applicable standard edition, profile, and programming environment. Maintain separate views of standards conformance and platform acceptance.
- Test the proposed reuse.
Demonstrate a representative capability on a second intended computing environment. Examine functional behavior, message meaning, timing, resource consumption, and integration effort. Treat successful interface testing as evidence—not proof of complete mission suitability.
- Translate findings into acquisition and implementation choices.
Decide what to retain, refactor, buy, or develop. Define supplier deliverables, conformance expectations, interface documentation, data models, and licensing arrangements. Use the FACE Contract Guide to help express requirements rather than relying on an ambiguous “FACE compliant” statement.
- Test sensitivities and alternatives.
Challenge expected reuse volumes, adapter effort, qualification costs, license charges, and migration timing. Compare selective modularization with broader replacement. Reassess the business case if a second aircraft program is delayed or changes its computing environment.
- Align owners and iterate.
Agree who funds shared components, controls interface changes, maintains evidence, and accepts platform-specific risk. Review the analysis jointly with engineering, acquisition, assurance specialists, and suppliers. Refine the architecture after demonstrations expose hidden dependencies.
A natural follow-on project is engineering productivity improvement: establishing shared component ownership, reusable test infrastructure, and integration workflows that convert architectural portability into less duplicated engineering. Track actual integration effort, defects, and release lead time—not merely components labeled reusable.
6. Example: the Future Airborne Capability Environment (FACE) Approach in Action
Consider Meridian Mission Systems, a fictional defense systems integrator upgrading a crewed maritime-patrol aircraft and an uncrewed surveillance aircraft. Both require maritime-track correlation, but their sensor feeds, operating environments, and release schedules differ.
Meridian selects FACE to examine whether correlation logic can become one maintained product rather than two aircraft-specific implementations. The team reviews source dependencies, sensor interfaces, timing budgets, data definitions, assurance requirements, and contractual reuse rights.
Its proposed architecture places correlation logic in the Portable Components Segment and isolates aircraft-specific sensor normalization in platform-specific services. The analysis reveals inconsistent timestamp definitions and a hidden dependency on one vendor’s runtime library. Interface similarity alone therefore overstates readiness.
Management funds a bounded pilot rather than wholesale migration. The team removes the runtime dependency, agrees common data definitions, and demonstrates the capability on both intended computing environments. It assigns a shared component owner and plans formal conformance and platform-specific assurance activities separately.
The illustrative outcome is a credible reuse path with explicit remaining work—not a claim that either aircraft is automatically qualified or that a standard guarantees savings.
7. Strengths and Limitations
Strengths
- Clear architectural boundaries: standardization helps distinguish portable capability software from platform dependencies.
- Lifecycle flexibility: component reuse and replacement support the objective of affordable capability evolution.
- Technical–commercial alignment: the approach connects architecture, conformance, and acquisition practices rather than treating software portability as an engineering issue alone.
Limitations
FACE does not define the complete mission architecture or guarantee that two conformant products meet a particular system’s operational needs. Platform integration, data compatibility, and performance remain substantive concerns.
Nor does conformance automatically establish airworthiness. Do not interpret the Safety profile as an aircraft approval or assume architecture standardization eliminates assurance work.
For investment decisions, explicitly account for refactoring, adapters, qualification, shared-product maintenance, and contractual restrictions. Reuse should be an evidenced economic proposition, not an assumed benefit.
8. Common Pitfalls and How to Avoid Them
- Buying a label: vague FACE requirements leave acceptance unclear. Specify the edition, applicable requirements, product boundary, and evidence expected.
- Confusing interface compatibility with data compatibility: matching structures can conceal different meanings. Review units, reference frames, timestamps, and invalid-data behavior.
- Drawing artificial component boundaries: hidden runtime dependencies defeat portability. Trace actual software calls and configuration dependencies.
- Double-counting savings: reusable code does not remove every integration or qualification task. Cost the remaining work explicitly.
- Ignoring lifecycle ownership: shared software can fragment into program-specific forks. Establish funding, versioning, and change-control responsibilities before scaling.
When several aircraft programs share components, program management support can maintain the integrated workplan, dependency register, decision log, and stakeholder cadence. Keep technical conformance and assurance decisions with qualified engineering authorities.
9. How the Future Airborne Capability Environment (FACE) Approach Relates to Other Frameworks
Modular Open Systems Approach
Modular Open Systems Approach (MOSA) is the broader business and technical strategy for modular, open acquisition and sustainment. Establish the system-level MOSA objectives first; use FACE where its software architecture addresses the required portability. FACE is not a substitute for the entire system strategy.
Model-Based Systems Engineering
Model-Based Systems Engineering (MBSE) connects requirements, design, and verification through system models. Use it before and alongside FACE to understand mission functions and trace software boundaries to system requirements. Prefer MBSE when the unresolved issue is overall system definition rather than software portability.
Airborne software assurance
DO-178C addresses airborne software development assurance, not portable software interfaces. Where applicable to the program’s assurance basis, plan it alongside FACE. The FAA recognizes it through an acceptable means of compliance; it is not a blanket requirement for every military software acquisition.
10. Key Takeaways
- FACE combines software-interface standardization with business and acquisition practices.
- Apply it to bounded capabilities and computing environments, not entire aircraft as interchangeable units.
- Prove reuse on intended target environments before scaling investment.
- Align interface governance, licenses, supplier deliverables, and lifecycle ownership.
- Conformance supports—but does not replace—airworthiness assurance.
11. FAQs About the Future Airborne Capability Environment (FACE) Approach
Is FACE an open-source requirement?
No. FACE standardizes aspects of the software environment and interfaces. It does not require suppliers to release their source code or relinquish intellectual property. Intended reuse rights must be established commercially.
Does FACE Conformance Certification establish airworthiness?
No. It recognizes conformance to applicable FACE requirements. Aircraft airworthiness involves a separate assurance process; conformance evidence may contribute to that process but does not replace it.
Can a smaller avionics supplier use FACE?
Yes. Start with a bounded capability and a clearly identified customer environment rather than attempting to build an entire computing platform. Public documentation and supplier guidance provide an entry point, but integration and conformance still require deliberate planning.
Does FACE make software plug-and-play?
Not automatically. Portability still depends on compatible environments, data meaning, dependencies, and system requirements. Treat FACE as a way to structure and reduce integration work—not a promise that an unchanged executable will work on every aircraft.
