The Requirements Operating Model

Four workflows,
one operating model.

The same architecture serves four fundamentally different engineering organizations. Different presenting problems. Same underlying model.

The model

Outputs Layer
Governance Layer
Transformations Layer
Inputs Layer
Knowledge Substrate

Every organization rests on the same Knowledge Substrate. What differs is which process layer does the sharpest work for their workflow.

The four archetypes further down show where each one gets the most acute value from the framework, and one question further down helps place you among them.

The shared spine

In the workflows we have mapped, the same spine appears whatever the tools and however many steps. What changes between organizations is what fills each box, and how far it splits, since authoring and review are rarely one step each.

Feeds in Elicit, draft, decompose, or author to a template
The check Evaluation, held separate from generation The requirement is judged against a standard, the same way twice
Follows Peer review, approval gate, verification, metrics

This is the box the operating model makes explicit. The rest of this page is about why that matters.

Why separation, and why now

The principle

Generation and evaluation cannot be the same system.

Something writes the requirement. Something else has to judge it. When one engine does both, the judgment inherits the author’s mistakes, and all that’s left to inspect is how confident the output sounds.

The operating model keeps them apart. Generation belongs to the Transformations Layer. Evaluation is a separate step, working from rules that live in the substrate rather than inside the generator, so the standard survives a change of author, a change of tool, and a change of model.

Rules in the substrate can be read, argued with, and versioned. Rules inside a generator can only be inferred from their output.

That evaluation belongs to a deterministic engine. Engineers stay in the loop deciding what the results mean. They stop absorbing the check itself.

“You have the generative aspect to generate requirements, but then you also have the judge to actually measure the quality. Those two should be two different things.”

Systems engineer, medical device manufacturer

The pressure

Requirement volume is rising. Review capacity is not.

Generated text reads as credible whether or not it is correct. Three things recur. Requirements get drafted faster than anyone can defend them, downstream tools inherit whatever they were given, and senior engineers become the bottleneck for volume they did not create.

The constraint has moved from writing to judging. That is what makes separation practical rather than philosophical. A distinct, reproducible evaluation step lets volume rise without review capacity rising with it. Evaluation folded into the generator just means more unexamined text.

“What you really need is more of the rules-based quality check. You don’t want it to be random. You don’t want it to be probabilistic.”

Systems engineering consultancy

The same requirement, checked twice, returns the same result.

A judgment that changes between runs is an opinion, and an opinion cannot be filed as evidence. Reproducibility is what makes a check stand up in a design review, an audit, or a customer’s assessment years later.

In the workflows we have looked at, that is how it gets used. The check is re-run on the approved set so its report can be filed with the design record.

Ask your organization

If requirement volume doubled next quarter, what would give first: the writing or the reviewing?

Where do I fit?

One question sorts most organizations: who reads your requirements next, and what do they do with them?

The four archetypes

Which layers do the sharpest work, and why.

All four are set out the same way. What we see in these workflows in practice, then where the model helps, then one question a team can put to itself.

Sharpest value for this archetype Supports the work, but not the reason for it Not where the value sits here Knowledge Substrate, underneath all four

01

Spec and standards issuers

StartsA standard, spec, or program requirement set needs to be authored or revised, driven by regulation, a program, or a house standard.
EndsA baselined, reviewed spec is issued down to the supply chain.
WhyIssue unambiguous, consistent requirements so a supply chain can build to them without rework or repeated clarification loops.

Sharpest value

Outputs
Governance
Transformations
Inputs
Knowledge Substrate
Where ROM helps
  • The Outputs Layer treats the spec as an artifact that must be legible to a downstream reader who was never in the authoring room.
  • The discipline that makes an engineering record defensible to a certifier is the same discipline that makes a spec buildable by a supplier.
  • The Inputs Layer applies Quality of Admission during authoring, so what enters is consistent with everything already there.
  • Configuration Authority is what gives a baseline meaning. One version is the spec suppliers build to, and every revision carries forward from it.
Observed in practice

Issuers author against their own templates and house rules, not a generic standard, and they revise a standing corpus instead of writing once. In the workflows we have looked at, the checks run requirement by requirement, and coherence across the whole set is rarely checked at all.

Ask your team

If two documents in our library contradict each other on the same interface, who finds out first: us, or the supplier building to both?

02

Own-product builders

StartsInternal user needs or a product concept are defined, whether from marketing, clinical, or design input.
EndsDesign outputs are verified and qualified against the requirements, the right-hand bookend of design control.
WhyRun a repeatable, defensible design-control process, so poor requirements do not turn into rework and regulatory risk.

Sharpest value

Outputs
Governance
Transformations
Inputs
Knowledge Substrate
Where ROM helps
  • The Governance Layer establishes Configuration Authority, one source of truth, so design changes propagate without breaking traceability.
  • The Transformations Layer covers the arc from user need to concept to design output that design controls demand.
  • The Outputs Layer turns the quality record into filed evidence, so the file shows what was checked rather than only who approved it.
Observed in practice

Review runs in two tiers: an informal draft review inside the requirements tool, then a formal one exposed to audit. Quality is owned at the point of authoring with no hard gate later, the check is configured differently per requirement level, and it is run a second time on the approved set so the report itself becomes design-file evidence.

Ask your team

When an auditor asks how we knew a requirement was good enough to approve, what do we hand them?

03

Solution suppliers

StartsFlow-down requirements arrive from a customer or prime under contract.
EndsDecomposed requirements are verified and traceable, proving the contract is satisfied in the delivered product.
WhyProve to the customer that every contracted requirement is met and traceable, to win and keep the program.

Sharpest value

Outputs
Governance
Transformations
Inputs
Knowledge Substrate
Where ROM helps
  • The Inputs Layer applies Quality of Admission to flow-down that arrives at varying quality.
  • The Transformations Layer covers decomposition into verifiable lower-level requirements.
  • The Outputs Layer supplies the traceability evidence back to the prime, and a reproducible check is what makes that evidence hold under assessment.
  • Configuration Authority settles which version of the customer’s requirement set the delivery is being proved against.
Observed in practice

Flow-down arrives at whatever quality the prime sent it, so incoming and internally derived requirements are held to different bars, sometimes tiered by mission criticality. Where we have seen customer assessment concentrate is the decomposition to lower-level requirements, which is often the part of the chain with the least written standard behind it.

Ask your team

Can we show what each customer requirement decomposed into, and that every piece of it can be tested?

04

Engineering consultancies

StartsA client hands over an incoming spec, often as PDF or Word, to formalize on their behalf.
EndsBaselined requirements are packaged back to the client or pushed to their supply chain.
WhyProvide an objective, tool-backed quality check across whatever client tools are in play, so deliverables are clear, consistent, and defensible.

Sharpest value

Outputs
Governance
Transformations
Inputs
Knowledge Substrate

Substrate is the primary lever here.

Where ROM helps
  • The value here is the Knowledge Substrate, a representation that sits above whatever client system is in play and stays the same when the system changes.
  • One standard applies across Word, Excel, Polarion, DOORS, Jama, or a client tool nobody on the team has used before.
  • The Inputs Layer handles Quality of Admission when client documents have to be formalized before anything can be done with them.
Observed in practice

The requirements platform belongs to the client and changes with the engagement, so a consultancy cannot standardize on one of them. The incoming artifact is usually a document, not a tool export, so what travels between clients is the representation and the evidence.

Ask your team

If the next client works in a tool none of us has used, how much of our method survives the move?

Read the book, chapter by chapter.

The Requirements Operating Model is being serialized through the Signal. The Prologue and Chapters 1 through 3 are published, with a companion FAQ, a glossary, and the Three-Minute mini-series. Chapter 4, the Transformations Layer, follows in October, and takes up a question we keep hearing across all four. How does a requirement carry through to the test that proves it?