ArchiMate's core (business/application/technology) can be extended with a Motivation extension (stakeholders, drivers, assessments, goals, requirements, principles) and an Implementation & Migration extension (work packages, deliverables, plateaus, gaps). What architectural questions does each extension let you answer that the core layers alone cannot, and how do the two extensions typically work together in a transformation program?
answer
- motivation = why (stakeholder->driver->goal->requirement)
- implementation/migration = how (baseline/target plateau, gap, work package)
- requirement realized by core element
- work package closes gap, realizes requirement
basics
~20 sMotivation elements capture WHY the architecture looks the way it does (stakeholder concerns, goals, requirements). Implementation & Migration elements capture HOW you get from the current state to a future state (work packages, plateaus, gaps). Together they connect 'why we're changing' to 'the concrete steps of the change'.
solid answer
~40 sThe Motivation extension adds stakeholders, drivers, assessments, goals, outcomes, principles, and requirements, letting you trace every architecture element back to the business rationale that justifies it - e.g. a requirement realized by a specific application component. The Implementation & Migration extension adds work packages, deliverables, plateaus (stable intermediate states of the architecture, including 'current state' and 'target state'), and gaps (the difference between two plateaus). Used together, a transformation program defines current and target plateaus, computes the gap, decomposes the gap into work packages traced back to the goals/requirements from the Motivation extension that justify doing the work at all - giving you a defensible chain from 'why are we spending this budget' to 'exactly what changes'.
go deeper
Recognizes that ArchiMate has elements for 'why' and 'how to get there' as distinct from the core structural layers, without needing to trace full chains.
Can construct a simple requirement-to-realizing-element trace and name baseline/target plateau and gap in a basic migration scenario.
Uses the full motivation chain to answer 'why does this exist' during architecture reviews and decomposes a gap into work packages with explicit requirement traceability.
Designs the governance process ensuring motivation chains stay connected to real stakeholders and that plateaus are actively maintained as transformation programs evolve, preventing stale-target drift.
## What the core layers leave out ArchiMate's core three layers describe what an enterprise IS at a point in time - its structure and behavior. Two extensions address different, equally important questions that a pure structural model cannot answer on its own: - the **Motivation extension** addresses WHY the architecture is shaped the way it is - the **Implementation & Migration extension** addresses HOW you move the architecture from one state to another over time ## Motivation — the chain of justification The Motivation extension's elements form a chain of justification. | Element | What it is | |---|---| | **Stakeholder** | a person, group, or organization with an interest in the architecture (e.g. 'Chief Risk Officer') | | **Driver** | an internal or external condition that motivates change (e.g. 'New data-residency regulation') | | **Assessment** | a finding about a driver, often the outcome of a SWOT-style analysis (e.g. 'Current systems store EU customer data outside the EU') | | **Goal** | a high-level statement of intent | | **Outcome** | the measurable end result | | **Principle** | a normative, generally applicable rule (e.g. 'All customer PII must be stored in-region') | | **Requirement** | a specific, often measurable, statement that architecture elements must satisfy (e.g. 'Customer database must be hosted in an EU data center by Q3') | Requirements are then connected via `realization` relationships to the concrete core-layer elements that satisfy them. This chain lets you answer 'why does this element exist' by walking backward from a technology node, through the requirement it realizes, up to the driver and stakeholder that ultimately justified it - invaluable when a cost-cutting review asks 'can we decommission this expensive EU-region deployment' and the answer requires knowing it exists specifically to satisfy a regulatory requirement, not developer preference. ## Implementation & Migration — the temporal side The Implementation & Migration extension addresses the temporal, transformation side. - A **Plateau** is a relatively stable state of the architecture at a point in time - practitioners typically model at least a 'Baseline' (current state) and 'Target' plateau, sometimes with intermediate transition plateaus for a multi-year program. - A **Gap** is the explicit difference between two plateaus - elements present in the target but not the baseline (to be added), present in the baseline but not the target (to be removed), or changed between the two. - A **Work Package** is a discrete unit of transformation work (e.g. 'Migrate Customer DB to EU Region') that closes some or all of a gap, and can itself be assigned deliverables and realize specific plateau elements. This structure lets a transformation program be decomposed into a coherent, traceable roadmap rather than an unstructured list of project tickets, and lets you ask 'if we only fund half the work packages this year, which parts of the gap remain open, and which target-state capabilities are consequently delayed.' ## Where the two extensions meet The two extensions work together at the point where a Work Package is connected to the Requirement (from Motivation) it fulfills. This produces the complete governance chain that most enterprise-architecture practices actually exist to maintain: 1. **Stakeholder** cares about a **Driver**, 2. which produces an **Assessment**, 3. which motivates a **Goal**, 4. formalized as a **Principle** and a specific **Requirement**, 5. realized by a target-plateau architecture element, 6. reached via a **Work Package** that closes the **Gap** from the baseline plateau. Every dollar spent on a work package can, in principle, be traced back to a named stakeholder's concern. ## The trade-off The trade-off, as with the rest of ArchiMate, is **overhead versus traceability**. - Fully modeling the Motivation chain for every requirement in a large program is labor-intensive and requires access to stakeholders who are often unavailable, so architects frequently fill it in from secondhand documentation, degrading its accuracy. - Plateau/gap modeling for a multi-year transformation, done well, requires maintaining multiple full architecture snapshots, which is a lot of ongoing model-maintenance work as the target itself often shifts mid-program - a common real-world failure is that the 'target' plateau is modeled once at program kickoff and never updated as scope changes, so eighteen months in, the gap analysis is comparing the current baseline against a stale, no-longer-accurate target. ## Where the chain pays off A concrete real-world usage: a large insurer running a multi-year core-systems modernization defines a Baseline plateau (legacy mainframe policy admin), a Target plateau (cloud-native policy platform), computes the Gap, and decomposes it into roughly thirty Work Packages, each explicitly realizing one or more Requirements traced back to Drivers like 'reduce time-to-market for new insurance products' and 'meet updated solvency-reporting regulation'. When the program board later asks 'why are we still funding the claims-migration work package in year three', the architecture team pulls up the Motivation chain and shows it's the only remaining work package realizing the solvency-reporting requirement, settling the funding debate with a documented, traceable justification rather than an argument from memory.
- How would you trace, in an ArchiMate model, from a specific application component back to the business reason it was built?Follow the realization relationship from the component up to the requirement it satisfies, then follow the requirement's connections up through the motivation chain - typically requirement traces to a goal, the goal to a driver, and the driver to the stakeholder whose concern it addresses. This backward walk is exactly what audits or budget-justification requests need.
- What's the difference between a 'gap' and a 'work package' in the Implementation & Migration extension?A gap is a descriptive, analytical element - it's the delta between the baseline and target plateaus, essentially a diagnosis of what's missing, extra, or changed. A work package is prescriptive - it's the unit of actual transformation work someone is doing to close some or all of that gap. You can have a documented gap with no work package yet assigned to it, which is itself a useful signal of unfunded scope.
- Why might modeling only a single 'target' plateau for a three-year transformation program be risky?A single distant target gives no visibility into intermediate states, so you can't reason about what capabilities exist at, say, the 18-month mark, which matters for planning coexistence of old and new systems during migration. It also tends to go stale as scope evolves, since there's no natural checkpoint prompting a review, so gap analysis silently drifts away from what the program is actually building.
Motivation elements are like the case a lawyer builds for why a law is needed (stakeholder harmed, evidence, goal, the actual statute text); Implementation & Migration elements are like the project plan for enacting and rolling out that law (current rules, target rules, the gap between them, and the specific legislative work packages to close it).
saying these in an interview costs you the question
- Cannot explain what a 'plateau' is or confuses it with a single point-in-time snapshot with no relation to gap analysis
- Treats motivation elements as optional documentation rather than something traced via real relationships to core-layer elements
- Doesn't distinguish a gap (diagnosis) from a work package (the work that closes it)
- Assumes a target plateau, once modeled, doesn't need revisiting as a program's scope changes