Holarch

Article

Most Systems Fail at the Interfaces

· Published by Holarch

  • Interfaces
  • Systems engineering
  • MBSE
Illustration: two electronic units joined by a cable with a glowing connector between them, in front of the planet Mars and a small orbiting spacecraft
On this page
  1. Components get attention. Interfaces get assumptions.
  2. What good interface practice looks like
  3. Where models help
  4. The bottom line
  5. References

On September 23, 1999, NASA's Mars Climate Orbiter fired its engine to enter orbit around Mars and was never heard from again. The spacecraft worked. The navigation team was skilled. The software did what it was written to do.

The problem was between them. NASA's investigation board found that a ground software file, "Small Forces," reported thruster impulse in English units, pound-force seconds, when the interface specification called for metric newton-seconds. Every small trajectory correction was off by a factor of about 4.45. Over months of cruise the error built up, and the spacecraft arrived far lower than planned.

What makes the story instructive is not the unit mix-up itself. It's that the requirement was written down. The interface specification said metric. Nobody verified that both sides actually honored it.

Components get attention. Interfaces get assumptions.

Every component in a system has an owner. Someone designs the power supply, someone writes the flight software, someone builds the antenna. Each owner tests their piece against their own understanding of what it must do.

Interfaces are different. They belong to two teams at once, which often means they belong to no one. Each side assumes the other side's view matches its own:

  • One team sends data at 10 Hz; the other expects 1 Hz.
  • One connector is wired for 28 V; the mating board assumes 12 V.
  • One message carries a timestamp in UTC; the receiver treats it as local time.
  • One mechanical drawing is updated; the mating part still uses the old revision.

None of these shows up when each component is tested alone. They show up at integration, when schedule margin is gone and every fix touches two teams.

What good interface practice looks like

1. Find every interface early. An N² diagram, a simple grid with subsystems on the diagonal and their exchanges in the off-diagonal cells, turns "I think that's everything" into a checklist. Empty cells are questions worth asking.

2. Define each interface completely. For each one: what crosses it (data, power, force, heat, signals), in what form, with what units, ranges, rates and tolerances, and what happens at the limits. If a value has units, write the units. Every time.

3. Give every interface an owner. One person responsible for keeping the definition current and for getting both sides to agree to changes. An interface with two owners has none.

4. Control changes. When one side changes, the other side must know before the change lands, not after the next integration test. That's what an interface control document, and its change process, is for.

5. Verify the interface, not just the components. Test each side against the written definition, then test them together. The Mars Climate Orbiter had a specification; what it lacked was a check that both sides honored it.

Where models help

In a document-based project, an interface lives in an ICD, and the two components that use it live in other documents. Keeping them in step is manual.

In a model, the interface is a connected item: the two components, the items that flow between them, the requirements that constrain them, and the tests that verify them are linked. Change a unit or a rate, and the model shows every component, requirement and test that depends on it. That's the question that matters most at an interface: who else does this change affect?

The bottom line

Systems rarely fail because one part is badly built. They fail because two good parts disagree about what passes between them. Write interfaces down, give them owners, control their changes and verify them on both sides. It is some of the cheapest insurance in engineering.

For a worked example of an interface control document, its contents and its change control, see our guide: Interface control document (ICD): contents and change control.

References

  1. NASA Mars Climate Orbiter Mishap Investigation Board, "Mars Climate Orbiter Mishap Investigation Board Phase I Report," November 10, 1999.
  2. NASA Science, "Mars Climate Orbiter."
  3. Holarch, "Interface control document (ICD): contents and change control."

Holarch is a model-based systems engineering tool built on LML and SysML v2, for teams of any size.