Written by: Tommy and Zach
When we're designing an aviation display, we often know what information is available before we've settled on the best way to show it.
An interface may look clear in a mockup but reveal problems once it's responding to changing system data. For example, an approach display must respond to updated guidance, while a taxi display might need to show a revised ATC clearance or a runway alert. We need to know whether the display handles those changes clearly, not just whether the initial layout looks right.
We need a way to try those situations before committing to a production implementation.
At VTI Aerospace, we often start in a web browser. It lets us connect an interface to system data, try different approaches, and get feedback while changes are still easy to make.
Separating Interface Design From Implementation
Production aviation interfaces often involve specialized graphics frameworks, embedded hardware, and tightly integrated software components. Developing and modifying interfaces in these environments can require substantial engineering effort, especially when the design is still evolving.
That investment makes more sense once we know what we're building.
Early on, the questions are more basic.
Can a pilot find the important information at a glance? Are mode changes obvious? What should the display show when guidance is no longer valid?
It's faster to try a few options in a prototype than to discover a problem after the interface is integrated with the rest of the system.
The Right Tool for the Job
Browser-based prototypes are easy to share and review. With a compatible browser, we can run the same interface on a laptop, tablet, or larger monitor and get feedback without setting up a separate application for each device.
Hot reload lets us try layout changes without rebuilding the whole application. Browser automation can replay common interactions after each change and help us catch regressions.
React and TypeScript give us access to libraries for charts, graphics, UI controls, and state management. We don't need to build those components from scratch before finding out whether the display makes sense.
With an appropriate interface to our autonomy software, a browser can display recorded or live data in a development environment. We can replay a scenario without deploying to final hardware, then share a link with colleagues for review.
Testing the Display with Flight Data
A moving display tells us things a screenshot can't.
Take lateral and vertical guidance during an approach.
We can make the indicators look right in a mockup, but that doesn't tell us how they behave when the aircraft drifts off course or when the localization system stops reporting valid guidance.
With recorded flight data, we can replay the approach through the prototype and see what the display would have shown.
Then we can deliberately test the awkward cases: stale measurements, a mode change, or guidance that needs to be flagged as unavailable. Those transitions are often more revealing than normal operation.
We can do the same for surface operations by stepping through taxi clearances, runway crossings, traffic alerts, or a revised ATC instruction.
That forces us to think about timing, information priority, and what the interface should do with incomplete data.
Replaying data helps us check the software's behavior. To find out whether the display is understandable and useful, we still need to evaluate it with representative pilots or operators.
Human Factors in Early Design
Human factors matter long before a product reaches the certification stage.
For normal-category airplanes, 14 CFR § 23.2600 addresses flightcrew interfaces. FAA Advisory Circular AC 25.1302-1 covers human-factors considerations for flightcrew controls and displays on transport-category airplanes.
Which requirements apply depends on the aircraft and the system's intended function. Still, issues like workload, display clarity, and error handling are worth considering while the design is easy to change.
A prototype lets us compare visual cues and alerting behavior without building the full production software first.
None of that replaces formal human-factors evaluation, safety analysis, or verification and validation. It gives those efforts a better starting point.
Moving From Prototype to Product
Some interfaces may stay in a web stack. Others will need a different implementation for the aircraft or ground station where they'll run.
Depending on the application, that could mean native graphics running on embedded hardware or integration with an existing avionics display system. The choice depends on the target system, not on what happened to be easiest for prototyping.
Depending on the certification context, airborne software may need to address development assurance objectives such as those in RTCA DO-178C. A working browser prototype doesn't satisfy those objectives by itself.
What we want to carry forward is the behavior we've decided the interface needs.
Keeping system data separate from visualization helps us experiment with the display without rewriting the perception or autonomy components that feed it.
The scenarios we exercise during prototyping can become inputs to requirements, interface specifications, and tests.
The prototype code doesn't necessarily need to carry over into production. What matters is that the design decisions, requirements, and lessons learned carry forward.
Finding Problems Earlier
Prototyping in a browser lets us test interface behavior and get feedback from pilots and operators while changes are still relatively inexpensive. That feedback helps us identify usability issues and turn early design choices into clearer requirements and test cases.
By the time we build for the production platform, we have a much better idea of what the interface needs to do.
