If you are new to ArchiMate and need to start using it in Sparx EA this week, this is the article. ArchiMate 3.0 is a layered notation with three core layers (Business, Application, Technology) plus a Motivation layer above and Implementation layer below — the 3+1+1 structure. You do not need to master all 50+ element types before you start. The practitioners who build effective ArchiMate models quickly focus on a core set: around 15 element types that cover the most common modeling scenarios, and 4 relationship types that account for 80% of the connections you will draw. Set up the ArchiMate 3 MDG in Sparx EA, create a structured package hierarchy, and build your first capability map. That is day one. Everything else is refinement.
Key Takeaways
- Start with the 3 core layers: Business, Application, Technology. Add Motivation and Strategy as practice matures.
- Learn 15 element types first — the rest can wait
- Master 4 relationship types first: Assignment, Serving, Realization, and Triggering. They cover 80% of cases.
- MDG Technology is the prerequisite in Sparx EA — confirm it is enabled before creating your first ArchiMate diagram
- Build bottom-up for your first model: start with the application portfolio, then add the business layer, then the technology layer
The 3+1 Layer Structure in 60 Seconds
ArchiMate 3.0 has six layers. You do not need to use all of them on day one. Here is what each layer answers:
| Layer | Question Answered | Start Here? |
|---|---|---|
| Motivation | Why does the organization do what it does? Drivers, Goals, Requirements | Later (after core layers) |
| Strategy | What capabilities does the organization have? | Later |
| Business | What does the organization do? Roles, processes, services | Yes |
| Application | What software supports the business? | Yes — start here |
| Technology | What infrastructure runs the applications? | Yes |
| Physical / Implementation | What physical assets and transformation work exist? | Much later |
Day-one recommendation: Start with the Application layer. Build your application portfolio. Then add the Business layer to show what the applications support. Then add the Technology layer to show what the applications run on. Add Motivation and Strategy once you are comfortable with the core layers.
The 15 Element Types to Learn First
You do not need to memorize all ArchiMate element types before you start. This subset covers the vast majority of what practitioners model in their first six months.
Business Layer (5):
- Business Actor — a named person, team, or organization (the “who”)
- Business Role — a responsibility or capacity (what the who does)
- Business Process — a triggered sequence of activities producing a result
- Business Service — the externally visible function the business delivers
- Business Object — a meaningful information concept (Customer, Invoice, Policy)
Application Layer (4):
- Application Component — a software application or system
- Application Service — what the application offers externally
- Application Interface — the access point (API endpoint, UI)
- Data Object — information managed by the application
Technology Layer (3):
- Node — a computing resource (server, VM, cloud service)
- System Software — the execution environment (OS, database, middleware)
- Communication Network — the network fabric (LAN, VPN, VNet)
Strategy Layer (1):
- Capability — what the organization can do, independent of how
Motivation Layer (2):
- Goal — what the organization is trying to achieve
- Requirement — what the architecture must provide
Everything else in ArchiMate builds on these. Learn them, use them, then expand your repertoire as specific modeling needs arise.
The 4 Relationship Types for 80% of Your Diagrams
ArchiMate has 12 relationship types. These 4 cover the vast majority of connections in standard EA models:
1. Assignment
“Who is responsible for this / where does this run”
Links an active structure element to what it performs or where it runs:
- Business Actor assigned to Business Role
- Business Role assigned to Business Process
- Node assigned to Application Component (hosting)
2. Serving
“This element supports / provides to that element”
The support relationship — source provides to target:
- Application Service serves Business Process
- Application Component serves another Application Component (dependency)
- Technology Service serves Application Component
3. Realization
“This concrete element fulfills what that abstract element specifies”
The fulfillment relationship — concrete realizes abstract:
- Business Process realizes Business Service
- Application Component realizes Capability
- Application Component realizes Business Service
4. Triggering
“This event or process causes that process to begin”
The causal activation relationship:
- Business Event triggers Business Process
- Business Process triggers Application Process
- Technology Event triggers Technology Process
If you can use these four correctly, you can build coherent ArchiMate models. Add the other eight relationship types (Flow, Access, Influence, Association, Composition, Aggregation, Specialisation, Junction) as your practice develops.
Setting Up ArchiMate in Sparx EA
Before you create your first ArchiMate diagram, confirm the MDG is in place.
Step 1 — Confirm the ArchiMate 3 MDG is active: In Sparx EA, go to Specialize → Technologies → Manage-Tech. Confirm “ArchiMate 3” is listed and enabled. If it is not visible, you may need to import it via Specialize → Technologies → Import MDG Technology. The ArchiMate 3 MDG ships with current versions of Sparx EA (Corporate and above).
Step 2 — Create your package structure: Before creating any elements, set up a package structure that matches the ArchiMate layers. A minimal starting structure:
“ ArchitectureRepository/ 01Motivation/ ← Add later 02Strategy/ ← Add later 03Business/ 04Application/ ← Start here 05Technology/ “
Create these as model packages in Sparx EA. Right-click the root node → Add Package → name it.
Step 3 — Create your first ArchiMate diagram: In the Application package, right-click → Add Diagram → select “ArchiMate 3” from the diagram type list → choose “Application Layer Diagram.” The ArchiMate 3 toolbox will appear with the application layer element types.
Step 4 — Use the toolbox, not custom elements: The ArchiMate 3 toolbox in Sparx EA provides all standard element types. Drag from the toolbox. Do not use the generic element creation tools (which create UML elements) for ArchiMate work. Confirm element types by checking the stereotype in the element properties — an Application Component should show stereotype «ApplicationComponent» from the ArchiMate 3 MDG.
What to Model First: The Bottom-Up Sequence
The most effective approach for ArchiMate beginners is bottom-up:
Stage 1 — Application Portfolio (Application Layer) Start by inventorying your application portfolio. Create one Application Component for each significant application in your environment. Add tagged values: owner, lifecycle status, hosting model. This gives you a foundation that is immediately useful and immediately recognizable to your stakeholders.
Stage 2 — Application Services and Interfaces For each Application Component, add the Application Services it provides (what it offers externally) and the Application Interfaces that expose those services (how they are accessed). This starts making your integration architecture visible.
Stage 3 — Business Layer Add Business Service elements for the business-level services your organization delivers. Draw Realization connectors from Application Components to the Business Services they enable. Add Business Process elements for the key processes. Draw Serving connectors from Application Services to Business Processes.
Stage 4 — Technology Layer Add Node elements for your infrastructure — servers, VMs, cloud services. Draw Assignment connectors from Application Components to the Nodes they run on. This makes infrastructure impact analysis possible.
Stage 5 — Capability Map (Strategy Layer) Add Capability elements for your organizational capabilities. Draw Realization connectors from Application Components to the Capabilities they enable. Add Assessment data (tagged values) to create a heatmap.
Stage 6 — Motivation Layer Add Goals and Drivers. Connect Capabilities to Goals. Connect Requirements to Architecture elements. This is where the model starts connecting to organizational intent.
Most teams reach Stage 3 in the first month and Stage 5 within six months of starting. Stages 5 and 6 are where the model becomes a strategic tool.
Common First Mistakes and How to Avoid Them
Mistake 1: Creating elements without using the ArchiMate 3 toolbox. If you create elements using the standard Sparx EA element creation dialog instead of the ArchiMate toolbox, you will create UML elements, not ArchiMate elements. They will look similar on a diagram but will have no ArchiMate typing. EA GraphLink and governance queries will not recognize them as ArchiMate elements. Always use the ArchiMate 3 toolbox for ArchiMate work.
Mistake 2: Modeling everything at the wrong granularity. A common first-model mistake is creating highly detailed models immediately — 200 process steps, every field in every application. ArchiMate is most effective at a higher level of abstraction. Start with the major applications, the primary business services, the key processes. Detail can be added selectively where it is needed for specific decisions.
Mistake 3: Skipping the relationship types. A model of boxes with no connectors is not an ArchiMate model — it is a list. The relationships are where the architectural value lives: which applications support which business services, which infrastructure hosts which applications. Spend as much effort on the connections as on the elements.
Mistake 4: Building diagrams, not a repository. The goal of ArchiMate in Sparx EA is to build a repository of reusable, queryable elements — not a collection of diagrams. An element (Application Component) should appear in multiple diagrams across the repository, the same element reused across different views. When you create a new diagram, drag existing elements from the repository onto it rather than creating new elements. This is what makes the model coherent and queryable.
Mistake 5: Naming with verbs instead of nouns. ArchiMate element names should be noun phrases: “Customer Onboarding Process” not “Onboard Customers.” “Loan Assessment Capability” not “Assess Loans.” Noun naming keeps elements stable across context changes and aligns with how the organization refers to its capabilities and processes.
Where to Go Next
Once you are comfortable with the basics:
- ArchiMate Motivation Layer — add the strategic intent layer to your practice. See ArchiMate Motivation Layer: Drivers, Assessments, Goals and Principles in Sparx EA
- ArchiMate Business Layer — deepen your business layer practice. See ArchiMate Business Layer: Actors, Roles, Business Processes and Services in Sparx EA
- ArchiMate Relationships — master all 12 relationship types. See ArchiMate Relationships: Association, Realisation, Serving, Triggering — Which to Use When
- ArchiMate vs UML — understand how the two notations work together. See ArchiMate vs UML: Full Comparison for Enterprise Architects Using Sparx EA
- The Open Group ArchiMate 3.2 Specification — the authoritative reference. Freely available at opengroup.org.
FAQ
How long does it take to learn ArchiMate? Most practitioners are producing useful ArchiMate models within two to four weeks of starting, using the core element set (15 elements, 4 relationships) described in this guide. Reaching genuine proficiency — correct use of all 12 relationship types, all layers, MDG governance, and cross-layer analysis — typically takes three to six months of consistent practice. Structured development through a program like Amplify accelerates this timeline significantly.
Do I need to buy the ArchiMate specification to use it? No. The Open Group’s ArchiMate specification is freely available at opengroup.org. You do not need to purchase it. The current version is ArchiMate 3.2, which is backward compatible with ArchiMate 3.0. The specification is the authoritative reference for element types, relationship types, and viewpoint definitions.
Is the ArchiMate MDG included with Sparx EA? Yes. The ArchiMate 3 MDG ships with Sparx EA Corporate and Ultimate editions. It may need to be activated if not already enabled. Go to Specialize → Technologies → Manage-Tech to confirm it is listed and active. If you are using Sparx EA Professional edition, check your specific version — MDG availability varies.
What is the difference between a diagram and a model in Sparx EA? A diagram in Sparx EA is a view — a visual representation of elements in the repository. The model is the underlying repository of elements and their relationships. The same Application Component can appear on multiple diagrams. When you delete an element from a diagram, it remains in the repository. When you delete an element from the repository (via the Project Browser), it is removed from all diagrams. Building a model means building the repository of typed elements with correct relationships — the diagrams are views over that repository.
What is the first diagram I should build in ArchiMate? An application layer diagram showing your application portfolio — one Application Component per significant application with Application Services connecting them. This is immediately useful, immediately recognizable to stakeholders, and provides the foundation for every subsequent ArchiMate view. Once you have the application portfolio modeled, add the business layer above and the technology layer below to complete the vertical stack.
Do I need TOGAF certification to use ArchiMate? No. ArchiMate and TOGAF are separate standards. You can use ArchiMate without any TOGAF knowledge, and vice versa. They are frequently used together — TOGAF provides the process governance, ArchiMate provides the notation — but neither requires the other. If you are choosing between learning ArchiMate and TOGAF first, for most practitioners ArchiMate first is the right sequence.
Get to Practice-Ready Faster with Structured Development
Self-study gets you to the basics. Structured development gets you to genuine ArchiMate proficiency — with the right habits, governance discipline, and repository quality standards built in from the start.
Sparx Services’ Amplify Architect Development program takes practitioners from ArchiMate foundations through to advanced practice: MDG governance, cross-layer modeling, motivation layer design, AI-ready repository structure. Work with practitioners who use ArchiMate in production EA environments every day.
