ArchiMate Field Course
ArchiMate 3.2 · Business & Application layers · for modelling in Sparx EA

Model the business and the applications behind it

A crash course for keeping the architecture repository current. It starts with the grammar of the language, builds up to cross-layer views, and ends with four banking examples and a capstone on conversational banking. Every diagram below uses real ArchiMate notation, so you can copy the patterns straight into Sparx.

Business layerApplication layer StrategyTechnologyMotivationImplementation & Migration
01Basics

The idea in one picture

ArchiMate is an open modelling language from The Open Group (current version 3.2, 2022). It gives you a fixed vocabulary of elements (boxes) and relationships (lines) with agreed meanings, so anyone who reads ArchiMate reads your diagram the same way.

Model, view, viewpoint

  • Model: the repository in Sparx. Every element exists there once, with its relationships.
  • View: one diagram. It shows a selection of model elements to answer a question for a stakeholder. The same element can appear in many views.
  • Viewpoint: a recipe for a view. It fixes which element and relationship types are allowed and which concern it addresses. Application Cooperation and Business Process Cooperation are viewpoints.

The grammar is the same in every layer

Read every ArchiMate layer like a sentence: who (active structure) does what (behaviour) to what (passive structure). Then split it into the outside that others see (interface, service) and the inside that realises it (process, function, role). Learn this once and both layers you work in become predictable.

The generic metamodel, filled in with business-layer elementspattern
The application layer uses the same shape: application interface, application service, application component, application function or process, and data object.
Remember
  • Square corners = structure (actors, roles, components, objects). Rounded corners = behaviour (processes, functions, events). Pill shape = service. A header band = information (business object, data object).
  • Yellow is business, blue is application. The icon in the top-right corner tells you the element type.
  • A view answers one question for one audience. If you can't state the question, the view will sprawl.
02Basics

Business layer vocabulary

These ten elements cover almost every business view you will draw. The examples come from retail banking.

Who existsA person, team, department or external organisation that can act.Customer · Mortgage desk · BKR
Which hat they wearA responsibility that an actor is assigned to. Prefer roles in process views: they outlive reorganisations.Account holder · Credit underwriter
Roles working togetherTwo or more roles that jointly perform behaviour.Advisor + customer meeting
The channelWhere a business service is offered to its users.Mobile app · Branch · Phone
Steps toward a resultAn ordered sequence with a start (often an event) and an end result. Name it verb + noun.Block card · Assess credit risk
Ongoing area of workBehaviour grouped by skills or resources, with no start or end. Use it for the "what we do", not the "in what order".Payments · Customer management
Behaviour done togetherPerformed by a collaboration; no single role owns it.Sign mortgage deed
Something that happensTriggers or results from a process. Name it in the past tense.Card reported lost
What the user getsValue exposed to the outside, named from the consumer's point of view, not how it is done.Card blocking · Mortgage advice
Information the business talks aboutA concept, independent of where it is stored.Mortgage application · Payment order
Process or function?

If you can draw an arrow from "first" to "next", it is a process. If it is a long-lived area that groups capabilities and people ("Payments operations"), it is a function. Process views use processes; functions mostly appear in overviews.

03Basics

Application layer vocabulary

The same grammar, now for software. Two traps to avoid from day one. An application component is a logical, replaceable unit (a system, a module), not a server or a container. An application service is behaviour a component exposes, not a "web service" endpoint.

The systemA modular, replaceable unit of software with its own functionality. This is the box people mean by "the application".Payment Hub · CRM · Agent panel
Point of accessWhere an application's services are offered, to users (a UI) or other applications (an API).Card API (REST) · Advisor UI
What the system doesAutomated behaviour grouped by what it does.Validate IBAN · Score fraud risk
Automated sequenceOrdered automated steps, typically used when an application automates (realises) a business process.Straight-through onboarding
Joint automated behaviourPerformed by two or more components together. Use it sparingly.Reconcile ledger positions
A state change in softwareOften what goes on an event stream. Use past tense.Payment booked · Customer onboarded
Exposed automated behaviourWhat a component offers to a business process or another application.Customer 360 lookup · Sanctions screening
Data for processingStructured data an application reads or writes. It can realise a business object.Customer record · pain.001 message
Remember
  • An application cooperation view is mostly components + flows. Add interfaces when how they connect matters, and services when what one offers to another matters.
  • Middleware such as an ESB, API gateway or event broker belongs to the technology layer. In an application view, draw the flow from the producer to the consumer and write the channel in the label ("via event stream").
04Basics

Relationships: the eleven lines that matter

Relationships carry the meaning. ArchiMate groups them as structural (what is part of or realises what), dependency (who uses or accesses what) and dynamic (what happens after what, or what moves where). Read every line aloud as a sentence. If the sentence sounds wrong, the line is wrong.

LineNameRead it asTypical use in your views
CompositionA consists of B (B can't exist without A)Component consists of modules or interfaces; a process consists of sub-steps
AggregationA groups B (B can live elsewhere too)A product groups services; a collaboration groups roles
AssignmentA performs / is responsible for BRole → process, actor → role, component → application function
RealizationA makes B real / implements BProcess → business service, application process → business process, data object → business object
ServingA is used by B (arrow points at the user)Application service → business process, business service → customer role
AccessBehaviour reads / writes an object (arrow = direction of data)Process writes a mortgage application; a function reads a customer record
TriggeringA causes / is followed by BEvent → process, step → next step
FlowA passes something to B (label what)Component → component data exchange; a hand-over between processes
AssociationA is related to B (unspecified)Last resort, or to attach a data object to a flow
SpecializationA is a kind of B"Instant payment" is a kind of "Payment"
JunctionAND (filled) / OR (hollow) split or joinBranching or parallel steps in a process view

Serving vs flow vs triggering

  • Serving is static: "the CRM is used by the advisor process". No timing, no data implied.
  • Triggering is order: "after Verify customer comes Block card". Nothing has to move.
  • Flow is transfer: "Payment Hub sends a booking to the ledger". Always label what flows.

Direction rules people get wrong

  • Serving points from provider to consumer.
  • Realization points from the concrete thing to the abstract thing it implements.
  • Access is drawn from the behaviour to the object. The arrowhead shows which way data goes: at the object for write, at the behaviour for read.
  • Composition and aggregation put the diamond at the whole.
Remember

Seven relationships do 90% of the work in business and application views: serving, realization, assignment, access, triggering, flow, composition. If you reach for association, first ask which of those seven you mean.

05Building up

Connecting business and application

A repository earns its keep when business and application views connect through the same elements, so you can trace a process to the systems behind it. Four relationship patterns do almost all of that work.

The four cross-layer patternsApplication Usage pattern
① An application interface serves a business role (the screen they use). ② An application service serves a business process step (support). ③ An application process realises a business process step (full automation). ④ A data object realises a business object (the stored form of the information).
Rule of thumb
  • A person does the step with system help? Serving from an application service (②).
  • The system does the step on its own? Realization from application behaviour (③), and no business role assigned to that step.
  • Connect at the service level when you can. Business stakeholders care what the system offers, not how its modules are composed.
06Building up

Viewpoints for your day job

The specification lists many example viewpoints. With a business and application focus, four cover nearly all requests. Pick the viewpoint before you draw. In Sparx it limits the toolbox, which keeps you honest.

ViewpointAnswersTypical audienceElements you'll use
Business Process CooperationHow do our processes connect, who does each step, and what information passes between them?Process owners, business architects, operationsEvents, processes, roles/actors, business objects, services; optionally the application services that support steps
Application CooperationWhich applications exchange what with whom, and through which interfaces?Domain/solution architects, integration teams, riskApplication components, flows (labelled), interfaces, services, data objects, groupings
Application UsageWhich applications support or automate which business steps?Business and IT together; impact analysisBusiness processes/roles/objects plus application services, interfaces, components, data objects
Service RealizationWhat does it take to deliver this business service?Product owners, service managersBusiness service, the processes realising it, and the application services behind those
Remember
  • Your organisation's "business process view" maps to Business Process Cooperation, and the "application cooperation view" to Application Cooperation. When the two need linking, add an Application Usage view instead of overloading either.
  • Aim for roughly 10–25 elements per view. Beyond that, split by sub-process or domain, or add a grouping-level overview.
  • Give every view a header note with its question, scope, status (draft/current/target), owner and date.
07Worked example 1 · easy

Lost card: one process, a handful of systems

QuestionWhat happens when a customer reports a lost card, and which systems are involved?
New conceptsEvent, triggering, role assignment, realization of a service, access, labelled flows
ViewsBusiness Process Cooperation + Application Cooperation
Business view: Report a lost cardBusiness Process Cooperation
Read it left to right: an event starts the chain, each step triggers the next, and an event closes it. The middle step realises the service the customer experiences.
Application view: Card blockingApplication Cooperation (dynamic)
Components and labelled flows only. The dashed outline marks an external party. That is a house convention, so explain it in the legend.

What to notice

  • Every process is verb + noun; events are past tense; the service is a noun from the customer's view.
  • The process view has no system boxes. Systems live in the application view and connect later through Application Usage.
  • Each flow says what moves. "Daily file" captures timing without drawing any technology.

Avoid

  • Triggering between applications. Software exchanges are flows.
  • Unlabelled flows. A bare dashed arrow tells the reader nothing.
  • Drawing the actor "Customer" and the role "Customer". Choose one; roles are usually better.
08Worked example 2 · intermediate

Making a payment: branching and linking the layers

QuestionHow is a payment executed, and which application services support each step?
New conceptsComposite process (nesting), OR junction, Application Usage stacking
ViewsBusiness Process Cooperation + Application Usage/Cooperation
Business view: Make a paymentBusiness Process Cooperation
Nesting the steps inside "Make a payment" means composition. The OR junction shows that only one execution path is taken.
Application view: who supports which stepApplication Usage + Cooperation
Three bands: business steps on top, the application services that serve them, and the components that realise those services with their flows. The ISO 20022 message names make the labels precise.

What to notice

  • Business steps connect to application services, never directly to components. When a component is replaced, only one realization line changes.
  • Reuse the same process elements as the business view. In Sparx, drag them from the Browser; don't create new ones with the same name.
  • Keep the bands aligned. Vertical lines read as "supports", horizontal ones as "talks to".

Avoid

  • Splitting with two plain triggers when only one path runs. Use an OR junction so the choice is explicit.
  • Nesting in the diagram without the composition existing in the model. Check the element's relationships after you nest.
  • Showing every API call. This view is about support and the main data exchanges.
09Worked example 3 · intermediate+

Mortgage application: several roles, interfaces and groupings

QuestionHow do customer, advisor and underwriter work together, and how do the mortgage systems connect?
New conceptsRole "lanes" by nesting, flow between processes, interfaces with serving, grouping by domain, external parties
ViewsBusiness Process Cooperation + Application Cooperation (static and dynamic)
Business view: Apply for a mortgageBusiness Process Cooperation
Processes nested in a role mean "assigned to that role", which gives you swimlanes in pure ArchiMate. Hand-overs between roles are flows labelled with what passes; plain sequence is triggering.
Application view: Mortgage origination landscapeApplication Cooperation
Groupings show domain ownership. The interface is composed in the origination system and serves both front-ends: one API, two consumers. Other exchanges are labelled flows.

What to notice

  • Grouping is the right element for "domain", "channel layer" or "external", not a giant component.
  • Model an interface when it is shared or governed (versioned API, contract). Otherwise a flow is enough.
  • The data object is read and written by the system that owns it, which makes the system of record visible.

Avoid

  • Mixing static (serving) and dynamic (flow) lines for the same pair of systems. Pick one per pair.
  • Swimlanes drawn as plain shapes. Use role elements so the assignment is in the model and queryable.
  • Leaving external parties unmarked. Risk and outsourcing reviews look for them first.
10Worked example 4 · advanced

Onboarding with KYC: automation, events and parallel paths

QuestionWhich onboarding steps are automated, by what, and how do downstream systems learn about a new customer?
New conceptsBusiness interface → service, AND junctions, application process realising a business process, application events, data object realising a business object
ViewsBusiness Process Cooperation + layered Application Usage
Business view: Open an account as a new customerBusiness Process Cooperation
The channel (business interface) is assigned to the service it offers. The AND junctions say the account and the card are arranged in parallel and both must finish. The KYC analyst is assigned only to the KYC/CDD step, where they handle exceptions.
Application view: Straight-through onboardingApplication Usage (automation) + Cooperation
Application processes realise business steps (automation) and components are assigned to them. An application event decouples the decision from account opening. The CDD record realises the business object, so a data change can be traced to its business meaning.

What to notice

  • Realization from application behaviour says "this step is automated". Serving says "this step is supported". The difference matters for operational-risk discussions.
  • Events make asynchronous designs readable without drawing the broker.
  • The access line is routed around elements. Spend a minute on line routing; crossings cost the reader more than they cost you.

Avoid

  • Modelling the event broker as an application component between every producer and consumer. It hides the real dependencies.
  • Assigning a business role to a fully automated step.
  • Putting several abstraction levels (domains, microservices, database tables) in one view.
11Apply it

Capstone: conversational banking as an agent panel

A new initiative lands on your desk: customers talk to the bank over chat and voice; an AI agent panel answers or acts, and hands over to a human advisor when needed. Here is a repeatable way to model any new problem, applied to this one.

The mental model: six questions, in this order

  1. Who asks, and what decision does the view support?

    Pick the audience and the viewpoint. Here, business owners need the process (Business Process Cooperation) and the design authority needs the system interplay (Application Cooperation).

  2. What happens, from trigger to result?

    Start with the business event ("Customer asks for help"), list the steps as verb + noun, and end with a result event. Name the business service the customer experiences.

  3. Who performs each step?

    Assign roles to human steps. Leave automated steps without a role: in the application view, application behaviour realises them.

  4. What information is created or used?

    Add business objects with read/write access ("Conversation record", "Handover summary"). They become data objects later.

  5. Which applications support or automate which step?

    Connect the steps to application services (support) or application processes (automation). Reuse existing repository elements before creating new ones.

  6. How do the applications talk?

    Draw components with labelled flows, group them by ownership or domain, and add interfaces only where a contract matters, such as the tool interface between agents and banking systems.

Business view: Handle a customer conversation (tentative)Business Process Cooperation
One service, one channel interface, one composite process. The OR junction is the key business decision: self-serve or hand over. Only the advisor step has a human role. The digital-assistant steps are realised by the agent panel in the application view.
Application view: Agent panel and its neighbours (tentative)Application Cooperation
The agent panel is one component made up of a supervisor agent, domain agents, guardrails and memory. Banking actions go only through the tool gateway's governed interface. The flow to the grouping stands for "to the systems of record in this group", which keeps the view readable.

Modelling choices worth defending

  • AI agents are application components, not business actors. At business level they show up as automated steps, so accountability stays with named human roles.
  • The hand-over is a first-class step and flow, because it is where risk sits (context loss, wrong routing).
  • One tool interface is drawn explicitly because it is the control point that security and risk will ask about.

Open questions before this goes in the repository

  • Does the voice channel reach the agent panel directly, or through the contact-centre platform's own bot?
  • Is conversation memory part of the panel, or a shared customer-context service for other channels?
  • Which application services already exist in the repository for accounts, payments and cards? Reuse them, and replace the grouping-level flow if impact analysis needs per-system detail.
12Apply it

Remember, tips and Sparx habits

The ten things to remember

  1. Who does what to what, split into outside (interface, service) and inside (role or component, process or function). The same grammar holds in both layers.
  2. Shape tells type: square = structure, rounded = behaviour, pill = service, header band = information.
  3. One view, one question, one audience. Write the question in the view's header note.
  4. Serving points at the user. Realization points at the abstraction. Access points the way the data goes.
  5. Triggering = order; flow = something moves (label it); serving = static use.
  6. Processes are verb + noun, events are past tense, services are nouns from the consumer's view.
  7. Link business to application through application services (support) or application processes (automation).
  8. Model once, show many times. Duplicate elements are the fastest way to lose a repository's trust.
  9. Stay at one level of abstraction per view, with roughly 10–25 elements. Split rather than shrink the font.
  10. Leave technology out of application views; carry protocol or timing in flow labels.

Tips and tricks

  • Lay out business on top, applications below, with flow running left to right. Readers learn the layout once.
  • Use groupings for domains, ownership and "external", and say in the legend what they mean.
  • Relationships may point at a grouping. Use this to avoid ten parallel lines, and drop to per-system lines only where impact analysis needs them.
  • Use colour only to encode something (lifecycle: tolerate / invest / retire), and explain it in the legend. Keep the layer colours as they are.
  • Before adding a new element, search the repository by name and synonyms ("CRM", "Customer 360", "Salesforce").
  • Model current and target as separate views with status in the title, not mixed in one diagram.

Sparx EA habits

  • Work in the ArchiMate 3 perspective/toolbox so only ArchiMate elements and relationships are offered.
  • Reuse by dragging existing elements from the Browser onto the diagram as a link instead of creating new ones.
  • Draw lines with the Quick Linker (the arrow on a selected element). It only offers relationships that are valid for that pair, which is a good way to learn the rules.
  • Removing an element from a diagram is not deleting it from the model. Check where an element is used (Find in all Diagrams) before you delete or rename it.
  • Use the Relationship Matrix to check coverage, for example processes × application services, to find steps with no system support.
  • Store owner and lifecycle as tagged values, and add a diagram legend and a header note to every view.

Common mistakes and their fixes

MistakeWhy it hurtsFix
Association everywhereSays nothing; no analysis possiblePick serving, flow, access, realization or assignment
Serving arrow reversedDependencies read backwards in impact analysisArrow at the consumer: "is used by"
Triggering between applicationsImplies causality, hides the data exchangeFlow with a label naming the data
Functions drawn as process stepsOrder and ownership become unclearProcesses for sequence, functions for ongoing areas
Two "CRM" elementsViews disagree; queries miss half the linksMerge duplicates, then reuse from the Browser
Event broker or ESB as a hopEverything appears to depend on the brokerProducer → consumer flow, "via event stream" in the label
Nesting without a relationshipLooks right but the model is emptyMake sure the composition or assignment exists
One giant viewNobody reads it; nobody maintains itOverview with groupings, plus one view per question
··Further reading

Sources this course draws on

  1. ArchiMate 3.2 Specification, The Open Group. The definitive reference for elements, relationships and cross-layer rules.
  2. Example Viewpoints (Appendix C), The Open Group. Definitions of Business Process Cooperation, Application Cooperation and Application Usage.
  3. ArchiMate Cookbook, Eero Hosiaisluoma. Practical patterns and example views, especially cross-layer ones.
  4. Practical ArchiMate viewpoints for the application layer, Bizzdesign. Static vs dynamic cooperation, flow conventions, labelling interfaces.
  5. Mastering ArchiMate (Edition 3.1), Gerben Wierda. The deep dive on patterns and modelling discipline.
  6. Archi Banking Group case study, The Open Group (ArchiMate with BIAN). A worked banking example.
  7. ArchiMate in Enterprise Architect, Sparx Systems user guide.
  8. Best practices for using ArchiMate, BOC Group. Conventions, scoping and stakeholder views.
  9. ArchiMate modelling mistakes, Seppänen & Nurmi (2024). Readability and abstraction errors seen in practice.

The example views are teaching material with simplified, vendor-neutral names. The capstone is a tentative starting point, not a reviewed architecture. Check element reuse and naming against your repository's conventions before adding anything to Sparx.