Software Architecture
Enterprise Architecture and TOGAF: The ADM, Domains and Governance
Intermediate10 min readUpdated
Enterprise architecture exists to connect business strategy to the systems that deliver it, and TOGAF is the most widely used framework for doing that work. This guide explains the four architecture domains, walks the ADM cycle phase by phase with the deliverables that matter, covers building blocks, the content framework and the repository, and is honest about the criticisms and how to use the framework pragmatically.
What you will learn
- Explain what enterprise architecture delivers and how it differs from solution architecture
- Walk the TOGAF ADM cycle and state the purpose and output of each phase
- Distinguish the business, data, application and technology domains and their artefacts
- Use architecture building blocks, the content framework and the repository to keep work reusable
- Apply capability mapping and governance without turning architecture into a bottleneck
Enterprise architecture is the practice of describing an organisation's business capabilities, information, applications and technology as one connected picture, so that investment decisions can be made with knowledge of their consequences. It is not a bigger version of software architecture. A solution architect answers "how should we build this system?"; an enterprise architect answers "should this system exist, what would it duplicate, what would it replace, and how does it move us toward where the business needs to be in three years?"
The practice earns its keep in organisations large enough that nobody can hold the whole landscape in their head — where the same customer data lives in nine systems, where two divisions are separately procuring the same capability, and where a decision to retire a platform has consequences nobody can fully enumerate. It fails, expensively, when it becomes a documentation exercise disconnected from the decisions being made. TOGAF is the most widely adopted framework for doing this work, and like any framework it is a source of structure to draw from rather than a process to follow literally.
What enterprise architecture is for
Strip away the vocabulary and the deliverables serve a handful of recurring decisions.
- Portfolio rationalisation. Which of our 400 applications do the same thing, which are unsupported, which cost more than they return? Answering this requires an application portfolio with owners, lifecycle status, cost and the capabilities each supports.
- Investment prioritisation. Given a strategy — enter a new market, reduce cost to serve, comply with a new regulation — which capabilities must improve, and which systems does that imply changing?
- Impact analysis. If we retire this platform, what breaks? Which interfaces, which processes, which reports?
- Standards and reuse. Which technologies are approved, which are tolerated, which are being exited, so that teams choose deliberately rather than by preference.
- Coherence across change. Twenty programmes running at once, each locally sensible, collectively producing three new integration patterns and a fourth customer master.
Note that each is a question someone with a budget is actually asking. Architecture artefacts that answer no such question are cost without benefit, and the fastest way to judge an EA practice is to ask which decisions in the last year it changed.
The four architecture domains
TOGAF organises the description into four domains, often abbreviated BDAT. They are views of one architecture rather than separate architectures, and the value is in the traceability between them.
| Domain | Describes | Typical artefacts |
|---|---|---|
| Business | Strategy, capabilities, processes, organisation, actors | Capability map, value streams, process models, organisation chart, business services |
| Data | The information the enterprise holds and how it flows | Conceptual and logical data models, data entity to application matrix, data ownership, lineage |
| Application | The applications and the services they provide | Application portfolio, application communication diagram, interface catalogue, functionality matrices |
| Technology | Platforms, infrastructure, networks and standards | Technology standards catalogue, platform decomposition, environment topology |
The traceability is what makes the model useful. When a capability is failing, you can see which applications support it; when an application is retired, you can see which capabilities and processes are affected and which data entities need a new home. A model with four beautifully drawn domains and no relationships between them cannot answer either question.
ArchiMate is the companion modelling language, layered to match the domains, and it is worth using where you model at all because it gives relationships defined meanings — realisation, serving, assignment — rather than arrows whose meaning depends on who drew them.
The ADM cycle
The Architecture Development Method is TOGAF's core: an iterative cycle for producing and governing architecture, with requirements management at the centre feeding every phase.
Preliminary Phase establishes the architecture capability itself — which parts of the organisation are in scope, which frameworks and tools are used, the principles that will guide decisions, and how governance will work. Architecture principles are the most durable output here, and the good ones have teeth: a principle stating "data is captured once, at its source" resolves arguments for years, while "we value quality" resolves nothing.
Phase A — Architecture Vision scopes one cycle. It identifies stakeholders and their concerns, sketches the target at a high level, assesses business value and risk, and produces the Statement of Architecture Work that authorises the effort. The critical output is agreement on scope, because unbounded scope is what turns an EA engagement into an eighteen-month study.
Phase B — Business Architecture describes the baseline and target for capabilities, value streams and processes, and performs a gap analysis between them. Doing this properly is what prevents the architecture from becoming a technology plan wearing a business label.
Phase C — Information Systems Architectures covers data and application together, again baseline, target and gaps. The recurring findings are duplicated data mastership, applications supporting capabilities they were never designed for, an interface catalogue that no API management platform yet fronts, and integration built point to point — the problem SOA and the ESB set out to address.
Phase D — Technology Architecture defines the platforms and infrastructure that realise the application architecture, and the standards that constrain future choices.
Phase E — Opportunities and Solutions turns the gaps from B, C and D into work packages, groups them into candidate projects, and identifies transition architectures — the intermediate states the enterprise passes through, each of which must be a viable place to stand for a while, since no organisation goes from baseline to target in one step.
Phase F — Migration Planning sequences and costs those work packages into an implementation and migration plan, negotiated with the portfolio and finance functions rather than written in isolation.
Phase G — Implementation Governance connects architecture to delivery. Projects are reviewed against the target, deviations are recorded as explicit exceptions with owners and expiry dates, and the architects stay involved rather than handing over a document.
Phase H — Architecture Change Management decides what to do when reality changes: a small change is absorbed, a significant one triggers a new cycle. This is also where the repository is kept current.
Requirements Management sits at the centre, receiving and dispatching requirements throughout, because requirements do not arrive once at the start.
Building blocks and the repository
Architecture Building Blocks (ABBs) describe required capability in implementation-independent terms: "identity and access management providing authentication, authorisation and federation for internal and partner users". Solution Building Blocks (SBBs) are the concrete things that realise them: a specific product, a specific service, a specific in-house component. Keeping the two separate is what allows a product to be replaced without redrawing the architecture, and it is the same instinct as programming to an interface.
The Architecture Content Framework defines what the outputs are and how they relate. Its three levels are worth knowing because they clarify a lot of loose talk about "deliverables":
- Deliverables are contractual outputs, formally reviewed and signed off — the Architecture Definition Document, the migration plan.
- Artefacts are the individual work products inside them, of three kinds: catalogues (lists of things), matrices (relationships between two lists) and diagrams (visual views).
- Building blocks are the reusable components those artefacts describe.
The Architecture Repository is where all of it lives, and the parts that matter in practice are the Architecture Landscape (the baseline and target descriptions at various levels of detail), the Standards Information Base (what is approved, tolerated and being exited), the Reference Library (patterns and reference architectures worth reusing) and the Governance Log (decisions, exceptions and their rationale). The Governance Log is the most undervalued: a searchable record of why a decision was made saves the organisation from relitigating it every eighteen months.
The Enterprise Continuum is the classification scheme that lets you move from generic industry reference models toward organisation-specific solutions. It is more conceptually useful than practically used.
Capability mapping
Of all EA artefacts, the business capability map is the one most likely to be genuinely used, because it gives business and technology stakeholders a shared, stable vocabulary.
A capability is what the organisation is able to do, expressed as a noun phrase and independent of how or by whom: "customer onboarding", "credit decisioning", "claims settlement", "pricing". Capabilities change far more slowly than processes, organisation structures or systems, which is exactly what makes them a useful spine. Typically they are decomposed two or three levels — beyond that the map becomes a process model and loses its stability.
Level 1 Customer Management
L2 Customer Onboarding importance: HIGH health: POOR apps: 4 ← invest
L2 Customer Data Management importance: HIGH health: POOR apps: 9 ← invest
L2 Complaint Handling importance: MED health: GOOD apps: 1
Level 1 Product & Pricing
L2 Product Definition importance: MED health: FAIR apps: 2
L2 Pricing & Discounting importance: HIGH health: FAIR apps: 3
Level 1 Order to Cash
L2 Order Capture importance: HIGH health: GOOD apps: 1
L2 Invoicing & Collections importance: MED health: POOR apps: 5 ← rationalise
The map earns its place through heat mapping: overlay assessments onto it. Which capabilities are strategically important? Which perform poorly today? Which are supported by systems at end of life, or by five overlapping applications, or by none? Where the "strategically critical" and "poorly supported" overlays intersect, you have an investment case that a non-technical executive can read in one slide — and that is a considerably better use of architecture effort than another layered diagram.
Governance that helps
Architecture governance is the mechanism that makes the target real, and it is where EA practices most often become the thing everybody routes around.
What works:
- Principles and standards published where developers already are — in the repository, in project templates, in pipeline checks — rather than in a portal nobody opens.
- A deviation process with a decision record. Teams will need exceptions. Record the exception, its rationale, its owner and its expiry date. An architecture practice that says no by default gets bypassed; one that says "yes, recorded, revisit in twelve months" stays informed.
- Automated conformance where it is possible. Dependency rules, approved base images, mandatory metadata, API linting against the organisation's guidelines. A pipeline check scales to a thousand teams; a review board does not.
- Lightweight, timely review at the points that matter — before a technology is adopted, before an integration pattern is established, before a build-versus-buy decision — rather than a gate on every release.
What does not work: a board reviewing every project after the design is finished, standards without a compliance path, target architectures with no funded route from the baseline, and modelling effort that outruns the organisation's willingness to maintain it. Governance that adds a week of waiting to every change is one of the reasons DevOps practices spread as a reaction.
Criticisms, fairly stated
The framework attracts strong criticism, and much of it is deserved.
It is heavy. The full standard describes far more artefacts than any organisation should produce. Read as a mandate rather than a menu, it generates documents nobody reads.
It can become disconnected from delivery. A target architecture with a three-year horizon, produced by a central team, tends to be overtaken by events and quietly ignored while delivery teams make the real decisions in sprint planning.
Certification substitutes for skill. The examination tests vocabulary, which is easy to test and not what the job requires.
It assumes a degree of central control that no longer matches how software is built. Cloud services are procured with a credit card, product teams choose their own stacks, and an architecture practice whose only instrument is approval has very little influence.
Used well, it still offers real value: a shared vocabulary that stops people arguing past each other, a checklist of concerns that prevents obvious omissions, a repeatable structure for gap analysis, and a governance model that can be dialled up or down. The pragmatic approach is to take the ADM's structure and the content framework's classification, produce the small number of artefacts that answer live questions, automate conformance, embed architects with delivery teams rather than above them, and let the repository be the memory of decisions rather than a museum of diagrams.
Key takeaways
- Enterprise architecture exists to inform decisions about portfolios, investment, impact and standards; artefacts that answer no live question are pure cost.
- The four domains — business, data, application, technology — are views of one model, and the traceability between them is where the value sits.
- The ADM is an iterative cycle from vision through the domain architectures to opportunities, migration, implementation governance and change management, with requirements management at the centre.
- Separate architecture building blocks from the solution building blocks that realise them, and keep catalogues, matrices and diagrams in a repository with a governance log of decisions and exceptions.
- A business capability map with heat overlays is the artefact most likely to change an executive decision, and it stays stable while processes and systems churn.
- Govern with published standards, automated conformance checks and a recorded deviation process rather than review boards that gate every release, and treat TOGAF as a menu — iterate at the scope a decision needs and keep architects close to delivery.
Sources and further reading
Frequently asked questions
- Is TOGAF still relevant in an agile organisation?
- The framework's value is its vocabulary and its checklist of concerns, not its document templates. A team delivering in two-week increments still benefits from a shared capability map, a known target technology set and a governance record of exceptions. What does not survive contact with agile delivery is a two-year up-front architecture phase, and the standard itself explicitly supports iterating the ADM at different scopes and depths.
- What is the difference between enterprise architecture and solution architecture?
- A solution architect designs one system to meet one set of requirements, usually within a project's timeframe. An enterprise architect works across systems and across time: which capabilities the organisation needs, which applications support them, where duplication and gaps exist, and what the target landscape should look like in three years. The two roles fail when either tries to do the other's job.
- Do I need to be TOGAF certified to do enterprise architecture?
- No. Certification demonstrates familiarity with the standard's vocabulary and structure, which helps when joining an organisation that already uses it and in job markets that screen on it. It does not confer the skills the work actually needs — reading a business strategy, negotiating between stakeholders with conflicting incentives, and knowing which technical debt is worth paying down.
- How do you keep architecture documentation from going stale?
- By documenting far less and deriving what you can. Maintain the small set of models that are genuinely used — the capability map, the application portfolio with owners and lifecycle status, the target technology standards — and generate the rest from systems of record such as the service catalogue, the CMDB and repository metadata. Any diagram that requires manual maintenance and is not consulted monthly should be deleted.