Position: Model comprehensively. Capture progressively. Govern proportionately.
Executive summary
Enterprise architecture is frequently criticised for two opposite failures: repositories that demand too much information before they are useful, and repositories that hold so little connected information that they cannot support decisions. These failures share a cause. Organisations confuse the breadth of the architecture information model with the minimum information an individual architect must capture at one moment.
This paper argues for progressive architecture traceability: a model capable of connecting business drivers, goals, requirements, principles, standards, architectural elements, decisions and verification evidence, supported by an authoring experience that asks only for facts justified by the stage and risk of the work. The goal is not to achieve the largest relationship count. It is to preserve enough provenance and semantic meaning to answer meaningful questions throughout architectural change.
The proposal is a MétiArch architectural position, not an assertion that any particular product already implements every mechanism described here. It is intended as a practical decision framework for enterprise architects, solution architects and architecture governance teams.
1. The problem: complete models, incomplete participation
Architecture frameworks encourage disciplined treatment of concerns, stakeholders, decisions and relationships. Real delivery work, however, does not reveal all information at once. A business problem may be understood before the owning application is known. An integration contract may be agreed before its hosting topology is selected. Verification evidence is necessarily unavailable when the solution has not been built.
If the repository makes downstream facts mandatory too early, users enter placeholders, duplicate data, create fictitious relationships or move their work elsewhere. If it imposes no structure at all, the organisation is left with disconnected text fields and diagrams that cannot reliably answer impact or assurance questions.
The wrong question is, “How many fields should be mandatory?” The better question is, “Which architectural assertions are sufficiently known, consequential and reviewable at this stage?”
This distinction matters commercially. Successful repository adoption depends on the usefulness of early entries. It also matters for governance: an explicit “not yet decided” is more trustworthy than a fabricated compliance answer.
2. The central thesis
Model comprehensively. Capture progressively. Govern proportionately.
These are three complementary design principles:
- Model comprehensively: provide distinct governed concepts and relationship semantics, so information can be connected without becoming ambiguous.
- Capture progressively: collect the facts that exist today, keeping unknowns and unresolved relationships visible rather than creating artificial completeness.
- Govern proportionately: strengthen obligations as architectural risk, lifecycle stage and decision consequence increase.
Progressive capture does not mean that every field is optional forever. It means the repository recognises the difference between discovery, design review, delivery assurance and operating-state confirmation.
3. A small but expressive information model
The following entities are a useful starting point. They are conceptual examples, not a mandate for a universal catalogue schema.
| Concept | What it represents | Typical accountable relationship |
|---|---|---|
| Business driver | The reason change is being considered | Motivates a goal or initiative |
| Business goal | An outcome the organisation seeks | Is supported by requirements |
| Requirement | A condition or capability a solution must satisfy | Is addressed by architecture elements or decisions |
| Principle | An enduring architectural rule or preference | Constrains options and decisions |
| Standard | A governed, applicable specification or obligation | Applies to components, designs or interfaces |
| Architecture element | An application, service, data object, technology or integration | Realises or contributes to a requirement |
| Architecture decision | The selected option and reasons for selection | Resolves a design question and affects elements |
| Verification evidence | A reviewed observation, test, acceptance or exception | Demonstrates whether an agreed criterion was met |
Some relationships are direct; others can be derived by traversing intermediate entities. A requirement can support a goal and be addressed by an API, while a decision records why that API approach was chosen. Care is required: a relationship labelled “implements” or “supports” must mean something operationally consistent, not merely that two objects appeared together on a diagram.
The model should record source, owner, scope and revision for important facts. A reviewer's ability to identify which requirement was approved, under which project, is usually more valuable than displaying a long list of disconnected related objects.
4. Treat relationships as assertions, not decorations
A line drawn between two nodes is not enough. A useful relationship has a defined type, directional meaning and relevant context. “Application A depends on Application B” is different from “Application A contains Component B”. “Standard S applies to Interface I” is different from “Decision D cites Standard S”.
Relationship records need not be elaborate, but several properties are commonly useful:
- Source and target: stable identities, not display names that may change.
- Semantic type: clear definition and permitted source/target concepts.
- Scope: enterprise AS-IS, a proposed project change or a particular architectural baseline.
- Provenance: who made the assertion and when, and the authoritative source if externally governed.
- Status: proposed, accepted, superseded or intentionally unverified where such distinctions are necessary.
Avoid inventing types only because the diagram needs another arrow. The semantics should guide the visual representation; the visual representation should not define the semantics.
5. Lifecycle-gated capture
Progressive traceability works best when requirements strengthen at meaningful decision points. A practical example follows.
| Stage | Minimum useful information | Additional assurance expectation |
|---|---|---|
| Discovery | Requirement statement, rationale, accountable owner, context | Record assumptions and unknowns explicitly |
| Option assessment | Candidate architecture elements, key constraints and options | Capture material trade-offs and impacted stakeholders |
| Design approval | Chosen solution, applicable standards, decision rationale | Resolve significant exceptions and review dependencies |
| Delivery assurance | Implementation references, verification criteria, evidence | Record gaps, waivers and their owners |
| Activation or closure | Accepted state, ownership, operational evidence as applicable | Confirm what became authoritative and what was superseded |
These are example gates. A low-risk change can have fewer gates; a regulated or safety-critical change can require stronger evidence earlier. The model supports both without forcing a one-size-fits-all template.
An organisation should document who can approve a transition and what an unresolved exception means. Automatic “green” indicators based solely on populated fields are not evidence that a design is sound.
6. Worked fictional example: a shared customer-reference capability
Consider Northbridge Services, a fictional organisation with three customer-facing applications. Each maintains its own customer identifier. The business observes duplicate records, manual reconciliation and inconsistent customer communications. A programme proposes a shared customer-reference service.
First capture
An architect records requirement REQ-CUST-01: Customer-facing applications must use a governed customer identity when creating or updating customer records. Its initial relationships are deliberately sparse: the requirement supports a data-quality goal, belongs to the Customer Data Modernisation project and has an accountable business owner.
The integration approach is not yet known. No placeholder API reference is entered. The record is valid for discovery but visibly incomplete for design approval.
Option analysis
The team considers three options:
- Synchronous reference API: strong immediate lookup semantics, but introduces availability and latency dependence at the point of use.
- Replicated reference data: enables local reads, but introduces synchronisation lag and reconciliation responsibilities.
- Event-driven publication: supports decoupled updates but requires consumer idempotency and an explicit approach to consistency.
A decision record explains why the chosen approach meets the programme's tolerable latency, resilience and data-consistency needs. These are design trade-offs, not universal verdicts about which integration pattern is superior.
The repository now links REQ-CUST-01 to the selected service, to the decision record, and to standards that actually apply. A standard remains an independently governed reference. Its full text is not copied into the requirement.
Assurance
Before approval, the team records acceptance criteria, such as how conflicting identifiers are handled and what happens when the reference service is unavailable. Later, test results and operational checks become verification evidence attached to the corresponding criteria.
The project has not made the architecture “complete” by filling every field. It has added assertions as they became known and reviewable. After successful adoption, the selected authoritative architecture elements are promoted into the current landscape while rejected options and superseded proposals remain understandable in their historical context.
What can now be answered?
The connected knowledge permits questions that would be difficult to answer from a set of presentations:
- Which customer processes rely on the new reference capability?
- Which decisions were influenced by a particular data-protection constraint?
- Which application integrations are affected if the interface contract changes?
- Which approval-critical requirements lack evidence?
- What changed between the proposed state and the accepted operating state?
Not every answer is available on day one. The model makes the missing evidence visible and gives people a useful path to fill the gaps.
7. The danger of treating standards as text fields
A standard is not simply a URL attached to a record. Governance requires knowing the authoritative source, relevant version, applicability, expected conformance and permitted exception process. The architecture can point to that reference while recording which obligation matters in a particular decision.
Copying a full standard into every design introduces revision drift. Replacing the standard with a generic “compliant” checkbox makes it difficult to know what was actually assessed. A more defensible approach records the applicable requirement, the proposed method of compliance and the evidence used by reviewers.
Where a standard is externally maintained, retain the owner and link to the authoritative edition. Where it is internal, retain approval history and supersession details. In both cases, separate the standard's status from the status of each design's assessment against it.
8. Traceability is not a project management system
Architecture records and delivery work items serve related but different purposes. A delivery task asks who will do work and when. An architecture requirement records a condition to satisfy. A decision explains why one solution was selected. Verification evidence records whether a criterion was demonstrated.
Work management systems should remain authoritative for sprint tasks, defects, delivery schedules and assignments. The architecture repository should retain durable references to relevant work items rather than mirroring every status transition. Otherwise, duplicated data produces reconciliation effort without improving architectural decisions.
A useful test is whether a relationship would still matter after the delivery board is archived. If it would, it probably deserves an enduring place in the architectural model. If it would not, a link may be sufficient.
9. Progressive validation, not weaker validation
Progressive capture needs clear validation rules. For example, an architect should not be able to link a requirement to a non-existent standard, to a retired object without explicit scope or to an architectural element in an unauthorised tenant. The system should prevent contradictions and invalid identities at every stage.
Conversely, it should permit an unknown supplier, an undecided deployment technology or an unselected integration pattern during early discovery. Unknowns should be visible as open questions or assurance gaps, not silently coerced into meaningless default values.
Validation also benefits from distinguishing mandatory data, recommended enrichment, and evidence required by a specific approval gate. That structure creates a predictable route from first capture to defensible assurance.
10. Useful measures of value
The most visible number in a repository may be its total object count. That is rarely the best measure of usefulness. Better questions include:
- How often can architects answer a dependency or impact question without starting a new discovery exercise?
- Can reviewers trace a design decision to the business concern and constraints it addressed?
- Are exceptions easy to find and clearly owned?
- How many approved requirements lack acceptance evidence when the organisation expects it?
- Can the organisation distinguish current accepted facts from project proposals and historical decisions?
These measures should be used carefully. An increase in recorded gaps may initially indicate better transparency, not deterioration. Avoid rewarding users for generating unnecessary relationships simply to improve a dashboard.
11. A practical adoption sequence
Start with the questions. Choose three to five questions decision-makers struggle to answer, such as “What depends on this application?” or “Why was this integration pattern chosen?” Map only the concepts and relationships needed to answer them.
Define a small semantic vocabulary. Agree the meaning of core link types. Keep composition, dependency, realisation, ownership and evidence distinct. Name relationships in plain language when that helps less experienced architects.
Make first capture genuinely easy. A useful new requirement should need a statement, a rationale, an owner and a context — not a dozen unrelated mandatory lookups.
Use risk-based review gates. Require stronger traceability when the decision becomes consequential. Publish the criteria so architects know what good evidence looks like.
Review the experience, not just the model. Watch an architect unfamiliar with the repository complete a real task. Remove needless navigation and confusing terminology while retaining the underlying semantics.
Treat the model as living knowledge. Preserve stable identities, authorised project revisions and clear transitions into accepted architecture. A link's correctness can change when its context changes; plan for review and supersession.
12. Limits and trade-offs
Progressive traceability is not a substitute for architecture judgement. Its effectiveness depends on maintaining a meaningful vocabulary, an accountable ownership model and review discipline. Excessive flexibility can produce ambiguous relationships; excessive control can encourage fabricated completeness.
Repositories also cannot infer authoritative facts merely because a diagram or API specification contains similarly named elements. Imports and suggested relationships should remain subject to identity matching, semantic validation and architect review. Automation can reduce capture effort, but it should not silently convert guesses into governed knowledge.
Regulatory, contractual and sector-specific requirements may impose evidence obligations beyond the illustrative gates described here. Teams must verify those obligations independently and document how they apply.
Conclusion
The test of architecture traceability is not whether every conceivable field is populated. It is whether people can move from an important concern to an architectural response, understand the rationale and examine suitable evidence at the point a decision needs to be made.
MétiArch's position is straightforward: model comprehensively, capture progressively and govern proportionately. That combination can make architectural knowledge both easier to create and more dependable to use.
References and further reading
- ISO, ISO/IEC/IEEE 42010:2022 — Software, systems and enterprise — Architecture description. The standard provides a framework for architecture descriptions, views and viewpoints; it does not prescribe MétiArch's progressive capture model.
- The Open Group, Understanding the TOGAF Standard. Referenced for background on tailoring enterprise architecture practice rather than as endorsement of this paper.
- MétiArch, Architecture Traceability Without the Bureaucracy. Companion shorter Insight.
- MétiArch, Living Architecture: From Diagrams to Governed Evolution. Related MétiArch White Paper 01.
Publication note: Fictional examples are used throughout. This paper presents MétiArch's recommended approach; it does not claim certification or conformance to named standards.