Position: An architecture estate should be managed as versioned knowledge, not an accumulation of disconnected snapshots.
Executive summary
Enterprise architecture is often maintained as a collection of documents, diagrams and project deliverables. That practice is useful for communicating a design at a point in time, but it struggles to answer a more demanding question: what is true of the estate now, what is proposed to change, and how did we arrive here?
Our position is that enterprise architecture should be managed as a connected, governed and evolving body of knowledge. The point is not to centralise every document or force every team into a single modelling tool. It is to give important architectural elements a durable identity, preserve the relationships and decisions that give those elements meaning, and make changes explicit until they are ready to be accepted into the authoritative view.
This paper sets out a practical operating model: a minimal authoritative core, multiple useful projections, project-scoped proposed changes, and proportional governance. It concludes with a fictional worked example and questions organisations can use to test their own practice.
1. The problem with snapshots
A diagram, spreadsheet or solution design is a snapshot. It can communicate an architectural decision exceptionally well. The weakness appears when another project creates a new snapshot without reconciling the first. An application may be renamed, an API endpoint moved, or a dependency retired, yet the documents continue to disagree because they do not share a stable underlying identity.
Requiring every team to keep every document perfectly synchronised is not a credible control. Documents serve distinct purposes: a high-level design explains intent, a deployment diagram explains hosting, and an interface specification explains the contract. They need not be replaced. They do, however, need a common basis for identity and relationships if cross-estate impact analysis is expected to work.
The value of a living repository is therefore not the number of diagrams it stores. Its value is whether a person can navigate from one question to the authoritative facts that answer it, irrespective of which visualisation first introduced the element.
2. Separate things, connections and views
The first discipline is semantic: distinguish the things we are describing from the views used to present them. An application is not the same as its hosting resource. A service is not the same as the API through which consumers access it. A connection between applications is not the same as the OpenAPI document describing one contract. These distinctions may feel academic until a hosting migration, interface version change or decomposition exercise requires different owners, lifecycles and dependencies.
Assign each significant architectural element a durable identifier. Names and descriptions can change; the identifier should continue to refer to the same element. Give relationships equally deliberate meaning. “Composes”, “depends on”, “provides”, “consumes” and “realises” answer different questions and should not be collapsed into a generic “connected to”.
Views can then be generated for the audience: a business capability map for strategic discussion, an application dependency network for impact assessment, a C4-style structure view for engineering, or an ArchiMate projection for cross-domain analysis. The projection is tailored; the underlying records remain coherent.
3. Give every fact an authoritative home
An architecture repository becomes unreliable when two catalogues independently claim to own the same fact. Consider an integration between a customer portal and an address service. The integration record can be authoritative for the producer, consumer, direction and integration type. The API record can be authoritative for the interface identity and OpenAPI reference. The versioned contract remains authoritative for schemas and operations. An event record may similarly describe the event contract while relationships identify its publishers and consumers.
These records should link rather than repeat one another. Derived presentation fields can be convenient, but they should be clearly derived rather than separately editable. This reduces drift and makes validation understandable: a missing contract is not the same quality problem as a missing consumer association.
External sources should remain external where that is more appropriate. A standards catalogue can govern an authoritative URL, owner and applicability without copying an entire standard. The same principle applies to patterns, technical specifications and delivery work items. Good integration of knowledge is not indiscriminate duplication.
4. Treat change as an architectural first-class concern
Many repositories record an element as “current” or “future”. That is not enough for simultaneous delivery. Two projects may both propose different changes to the same application, while architects and operational stakeholders still need a trustworthy view of the accepted estate. Simply editing the shared record destroys the distinction between what exists and what is proposed.
Our preferred model maintains an authoritative accepted state and explicit project-scoped proposed revisions. Projects can work independently and reference the accepted revision on which their proposal was based. When another change becomes accepted first, the later project must reconcile its proposal against the new baseline rather than silently replacing somebody else’s work.
Conflict detection and reconciliation are not merely software conveniences. They are governance mechanisms. They reveal whether two architectural decisions are compatible, whether a dependency changed unexpectedly, and whether a proposed design still satisfies the constraints originally reviewed. Acceptance then becomes a controlled event that moves a validated proposal into the authoritative estate while preserving previous revisions for audit and learning.
5. Make governance proportional and testable
Architecture governance often fails in one of two ways: it is too informal to preserve consequential decisions, or too heavy to be followed in ordinary delivery. A practical repository should establish the minimum evidence needed to give an architectural record meaning, then ask for greater completeness as the risk and decision significance increase.
A lightweight decision record might require the problem, options considered, decision, rationale, owner and date. A standard that applies across an enterprise needs something different: unambiguous requirements, applicability, how compliance is demonstrated, and how exceptions are considered. A reusable pattern needs a clear intent, context, structure and consequences. These are different artefacts and should not be treated as interchangeable.
The measure of success is not how many fields are mandatory. It is whether the information is sufficiently reliable to support a decision, and whether evidence survives long enough for the next programme to use it. Approvals should identify what was approved, against which revision and under which assumptions.
6. Worked example: replacing an address capability
Consider a fictional enterprise whose customer application calls a legacy address lookup interface. The organisation wants to introduce a mediation component and a new external address provider. A diagram-only approach might produce three separate pictures: the current integration, the target integration and the deployment topology. Each may be correct in isolation while leaving ownership and transition status unclear.
A connected model begins with the logical applications: Customer Management, Address Lookup and External Address Provider. It then records two API-type integrations: Customer Management to Address Lookup, and Address Lookup to the external provider. Each integration references its relevant API contract; the contracts identify the supported operations and versions. A separate technology view associates the Address Lookup application with hosting, gateway and network controls. Those platform resources do not become the application's business identity.
A delivery project proposes the new component and revised integration relationships without altering the accepted current state. Reviewers can examine the proposed dependency path and identify affected consumers. If the external provider changes its contract during delivery, the project revises its contract reference and records the resulting impact. Once tested and approved, the new revisions can become authoritative, while the previous state remains available for historical context.
Nothing in this example requires every technical detail to live in a single database. The contracts may remain in source control, delivery tickets in a work-tracking service and runtime configuration in the cloud platform. The architectural repository supplies the enduring identities and connections needed to navigate between them.
7. An operating model, not another document silo
Putting every form of documentation into a repository is unlikely to improve adoption. We recommend separating responsibilities. The architecture catalogue is authoritative for architectural elements, governed relationships, revisions and decisions. Source control remains authoritative for software implementation and many interface specifications. The delivery platform owns tasks and workflow states. Service management tools own operational incidents and asset-specific runtime information where appropriate.
The boundaries matter most where systems overlap. An architecture record can reference a source-control repository, the contract at a particular version, a delivery epic and an approved decision. It need not claim to own the contents of any of those systems. This model reduces competing truths while allowing role-specific workbenches to present a focused experience to enterprise, solution, data, integration and security architects.
The repository should remain usable even when complete cross-system automation is not yet available. A trusted link, explicit version and named owner are often more valuable than a fragile synchronisation that nobody fully understands.
8. Practical adoption sequence
Start with a narrow use case that matters. Select a bounded architecture area, such as an application and its external interfaces, and agree which architectural questions the information must answer. Define durable IDs and a small set of relationship meanings. Populate the accepted current state, link existing authoritative artefacts, and test whether a new architect can navigate it without specialist knowledge of the original project.
Next, introduce a proposed change without overwriting current records. Record who owns the proposal, which accepted revision it was based on and what changed. Test a conflicting second proposal deliberately. That exercise often exposes missing governance decisions more effectively than another lengthy data model workshop.
Finally, introduce derived views and publication. Each diagram, report or document should make its purpose clear and, wherever practicable, be traceable to the catalogue records and revision from which it was generated. Use search, relationship exploration and concise narrative to meet users where they are rather than insisting everyone become an expert repository modeller.
9. Questions for architecture leaders
- Can we identify the authoritative record for a critical application and distinguish it from duplicates in documents?
- Can we answer what depends on that application and explain what each relationship means?
- Can multiple projects propose changes to the same element without corrupting the accepted state?
- Can reviewers see the reasons for a decision and the evidence on which it was approved?
- Can an architect trace a public-facing interface to its versioned contract and known consumers?
- Can our different stakeholder views be reconciled to a consistent underlying model?
- Can we show the architecture at a particular point in time without reconstructing it from old slide decks?
A repository need not answer every question on its first day. These questions provide a useful direction for incremental improvement, with the most valuable relationships and decisions captured before elaborate reporting or automation is attempted.
Conclusion
The future of enterprise architecture is not a choice between diagrams and databases, or between formal governance and agile delivery. It is a discipline of maintaining trustworthy architectural knowledge through change. Identity, semantics, authority, revision history and proportional governance create the foundation. Visualisation and publication make that foundation accessible.
For MétiArch, this is the central proposition: understand today’s architecture without losing the ability to architect tomorrow’s. Build a connected model that endures beyond the project that first described it, and let architecture evolve deliberately rather than by accumulation of disconnected snapshots.
References and further reading
This paper expresses the MétiArch perspective. The following sources provide context on architecture descriptions and modelling approaches; they do not imply endorsement of MétiArch.
- ISO/IEC/IEEE 42010:2022, Software, systems and enterprise — Architecture description. The standard distinguishes architecture descriptions and provides a framework for related concepts.
- The Open Group, ArchiMate. An open modelling language for describing enterprise architecture relationships.
- The C4 model, Diagrams. A set of abstraction levels for communicating software architecture.
Explore related papers and shorter architectural insights as part of our connected reading path.