📘 Tutorial: ArchiMate 3.2 — Chapter 2: Definitions

Understanding the Foundational Vocabulary of Enterprise Architecture Modeling

🔍 Introduction: Why Definitions Matter

Before you can draw a useful architecture diagram — whether it’s to align business goals with IT systems or communicate cloud migration plans — you need a shared language. That’s exactly what Chapter 2 of the ArchiMate 3.2 Specification provides: the formal vocabulary of the language.

Think of this chapter as the glossary + grammar primer for ArchiMate. Without precise definitions, two architects might use the same term (“view”, “layer”, “element”) with different meanings — leading to miscommunication, flawed models, or failed implementations.

✅ This tutorial will help you:

• Grasp each term intuitively through analogies and examples
• See how terms interrelate (e.g., viewpoint → view → model → element)
• Avoid common confusions (e.g., view vs. viewpoint, layer vs. aspect)
• Prepare confidently for ArchiMate certification or real-world modeling.

Let’s dive in — one term at a time.

🧱 Key Concepts & In-Depth Explanations (with Examples)

1. ArchiMate Core Framework

“A reference structure used to classify elements of the ArchiMate core language. It consists of three layers and three aspects.”

🔹 Analogy: Think of it like a 3×3 grid in a spreadsheet — rows = layers, columns = aspects — helping you categorize every building block.

📌 Example:

• You’re modeling how customer orders are fulfilled.
  • Business Layer: Customer (Actor), Process Order (Process), Order (Object)
  • Application Layer: Order Management System (Component), Place Order API (Service)
  • Technology Layer: Web Server (Node), Order Database (Artifact)

⚠️ Note: The full grid and metamodel are in Section 3.4, but this framework is the mental map guiding where to place elements.

2. ArchiMate Core Language

“The central part… includes concepts from three layers: Business, Application, and Technology (including Physical).”

🔹 This is the “standard toolbox” — the official set of elements & relationships you’re allowed to use in conformant ArchiMate models.

🚫 Not part of the core language: Motivation, Strategy, Implementation & Migration extensions (covered in later chapters or extensions).

📌 Practical Tip:
If you’re building a TOGAF-aligned EA model at a large org (e.g., Acme Cloud), stick to the Core Language first — it ensures clarity and tool compatibility (e.g., with BiZZdesign, Sparx EA, or Archi).

3. Architecture View vs. Architecture Viewpoint

Commonly confused! Let’s untangle them.

✅ Best Practice: Always document your viewpoint before drawing the view. This ensures stakeholder alignment (e.g., CFO cares about cost flows; CISO cares about data access).

4. Aspect

“Classification based on layer-independent characteristics… related to stakeholder concerns.”

Three aspects:

1. Active Structure → Who/what performs? (e.g., Actor, Role, Component)
2. Behavior → What is done? (e.g., Process, Function, Service)
3. Passive Structure → What is acted upon? (e.g., Object, Data, Artifact)

📌 Example: E-commerce Order Flow

💡 Insight: Aspects let you slice the model horizontally — e.g., “Show me all Passive Structures across layers” to analyze data lineage.

5. Element, Relationship, Relationship Connector, and Concept

6. Composite Element

“An element consisting of other elements from multiple aspects or layers.”

🔹 Most real-world elements are composite!

📌 Examples:

• Online Banking System = Business Service (Transfer Funds) + Application Component (Transaction Engine) + Technology Node (Cloud Cluster)
• Customer Portal = Business Interface (Web UI) + Application Component (Frontend App) + Technology Device (Web Server)

🔧 Modeling Tip: Use composition (black diamond) or aggregation (white diamond) relationships to build composites:

[Customer Portal] ◆── [Frontend App]  
                ◆── [Auth Service]  
                ◆── [Web Server]

7. Attribute

“A property associated with an element or relationship.”

📌 Not drawn directly, but used in tool metadata or model repositories:

• Element: Payment Gateway → attributes: version=3.2, SLA=99.95%, owner=Finance Team
• Relationship: Customer →[accesses]→ DB → attribute: encryption=TLS 1.3

💡 In Archi (free tool), you can add attributes in the “Properties” tab — great for traceability, compliance, or governance.

8. Conformance & Conforming Implementation

“Fulfillment of specified requirements.”
“An implementation that satisfies the conformance clause.”

✅ Critical for:

• Tool vendors (e.g., ensuring Sparx EA exports valid ArchiMate 3.2 XML)
• Certification exams (Open Group ArchiMate® certification)
• Enterprise governance (auditable architecture artifacts)

📌 Example Conformance Check:

• ✅ Valid: Using only standardized names (Business Actor, not Person)
• ❌ Invalid: Inventing a new relationship like magicLink without extension definition

🔗 Reference: Conformance rules are in Section 1.3 — but intent is: Interoperability & consistency across teams/tools.

9. Model

“A collection of concepts in the context of the ArchiMate language structure.”

🔎 Don’t confuse with diagram!

• A model = full repository of elements, relationships, views, viewpoints, metadata (like a database)
• A view = one diagram or report extracted from the model

📌 Analogy:

• Model = Entire movie studio (scripts, sets, actors, cameras)
• View = One scene (shot for marketing, edited for trailer, etc.)

🔧 Tool Tip: In Archi, your .archimate file is the model — containing multiple views (diagrams), grouped by viewpoints.

10. Layer

“An abstraction… at which an enterprise can be modeled.”

Three core layers:

📌 Real-World Traceability (e.g., at Acme Cloud):
Business Goal: Reduce checkout time
→ Business Process: Optimize Payment Flow
→ Application Service: Async Payment Auth
→ Technology: Kafka + Redis Cache

This traceability across layers is where ArchiMate shines.

📊 Summary Table: Chapter 2 Definitions at a Glance

🎯 Conclusion: Putting It All Together

Chapter 2 may seem like “just definitions” — but it’s the semantic foundation of ArchiMate. Mastering these terms enables you to:

✅ Speak precisely with architects, developers, and executives
✅ Model consistently — avoiding ambiguity or tool incompatibility
✅ Scale effectively — from single diagrams to enterprise-wide architecture repositories
✅ Integrate with TOGAF — using ArchiMate for the Architecture Content Framework (e.g., TRM, ABM)

📌 Pro Tip for Practitioners (e.g., Senior PM at Acme Cloud):
When roadmapping cloud modernization, start by:

1. Choosing viewpoints (e.g., Application Migration, Cost Impact)
2. Building views using core elements across layers
3. Tracing dependencies via relationships
4. Documenting attributes (cost, risk, owner) for decision support

➡️ In short: Define → Structure → Model → Communicate

With Chapter 2 internalized, you’re ready to tackle Chapter 3 (Language Structure) and begin drawing — not just talking — architecture.

📘 Next Steps?
Let me know if you’d like:

• A hands-on lab modeling a SaaS product using these definitions
• A comparison: ArchiMate vs. UML vs. BPMN
• A cheat sheet PDF of this tutorial
• Practice questions for Open Group certification

Happy modeling!
— Your EA Learning Partner 🏗️