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.
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.
- 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.
Business layer vocabulary
These ten elements cover almost every business view you will draw. The examples come from retail banking.
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.
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.
- 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").
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.
| Line | Name | Read it as | Typical use in your views |
|---|---|---|---|
| Composition | A consists of B (B can't exist without A) | Component consists of modules or interfaces; a process consists of sub-steps | |
| Aggregation | A groups B (B can live elsewhere too) | A product groups services; a collaboration groups roles | |
| Assignment | A performs / is responsible for B | Role → process, actor → role, component → application function | |
| Realization | A makes B real / implements B | Process → business service, application process → business process, data object → business object | |
| Serving | A is used by B (arrow points at the user) | Application service → business process, business service → customer role | |
| Access | Behaviour reads / writes an object (arrow = direction of data) | Process writes a mortgage application; a function reads a customer record | |
| Triggering | A causes / is followed by B | Event → process, step → next step | |
| Flow | A passes something to B (label what) | Component → component data exchange; a hand-over between processes | |
| Association | A is related to B (unspecified) | Last resort, or to attach a data object to a flow | |
| Specialization | A is a kind of B | "Instant payment" is a kind of "Payment" | |
| Junction | AND (filled) / OR (hollow) split or join | Branching 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.
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.
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.
- 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.
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.
| Viewpoint | Answers | Typical audience | Elements you'll use |
|---|---|---|---|
| Business Process Cooperation | How do our processes connect, who does each step, and what information passes between them? | Process owners, business architects, operations | Events, processes, roles/actors, business objects, services; optionally the application services that support steps |
| Application Cooperation | Which applications exchange what with whom, and through which interfaces? | Domain/solution architects, integration teams, risk | Application components, flows (labelled), interfaces, services, data objects, groupings |
| Application Usage | Which applications support or automate which business steps? | Business and IT together; impact analysis | Business processes/roles/objects plus application services, interfaces, components, data objects |
| Service Realization | What does it take to deliver this business service? | Product owners, service managers | Business service, the processes realising it, and the application services behind those |
- 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.
Lost card: one process, a handful of systems
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.
Making a payment: branching and linking the layers
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.
Mortgage application: several roles, interfaces and groupings
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.
Onboarding with KYC: automation, events and parallel paths
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.
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
- 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).
- 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.
- Who performs each step?
Assign roles to human steps. Leave automated steps without a role: in the application view, application behaviour realises them.
- What information is created or used?
Add business objects with read/write access ("Conversation record", "Handover summary"). They become data objects later.
- 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.
- 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.
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.
Remember, tips and Sparx habits
The ten things to remember
- 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.
- Shape tells type: square = structure, rounded = behaviour, pill = service, header band = information.
- One view, one question, one audience. Write the question in the view's header note.
- Serving points at the user. Realization points at the abstraction. Access points the way the data goes.
- Triggering = order; flow = something moves (label it); serving = static use.
- Processes are verb + noun, events are past tense, services are nouns from the consumer's view.
- Link business to application through application services (support) or application processes (automation).
- Model once, show many times. Duplicate elements are the fastest way to lose a repository's trust.
- Stay at one level of abstraction per view, with roughly 10–25 elements. Split rather than shrink the font.
- 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
| Mistake | Why it hurts | Fix |
|---|---|---|
| Association everywhere | Says nothing; no analysis possible | Pick serving, flow, access, realization or assignment |
| Serving arrow reversed | Dependencies read backwards in impact analysis | Arrow at the consumer: "is used by" |
| Triggering between applications | Implies causality, hides the data exchange | Flow with a label naming the data |
| Functions drawn as process steps | Order and ownership become unclear | Processes for sequence, functions for ongoing areas |
| Two "CRM" elements | Views disagree; queries miss half the links | Merge duplicates, then reuse from the Browser |
| Event broker or ESB as a hop | Everything appears to depend on the broker | Producer → consumer flow, "via event stream" in the label |
| Nesting without a relationship | Looks right but the model is empty | Make sure the composition or assignment exists |
| One giant view | Nobody reads it; nobody maintains it | Overview with groupings, plus one view per question |
Sources this course draws on
- ArchiMate 3.2 Specification, The Open Group. The definitive reference for elements, relationships and cross-layer rules.
- Example Viewpoints (Appendix C), The Open Group. Definitions of Business Process Cooperation, Application Cooperation and Application Usage.
- ArchiMate Cookbook, Eero Hosiaisluoma. Practical patterns and example views, especially cross-layer ones.
- Practical ArchiMate viewpoints for the application layer, Bizzdesign. Static vs dynamic cooperation, flow conventions, labelling interfaces.
- Mastering ArchiMate (Edition 3.1), Gerben Wierda. The deep dive on patterns and modelling discipline.
- Archi Banking Group case study, The Open Group (ArchiMate with BIAN). A worked banking example.
- ArchiMate in Enterprise Architect, Sparx Systems user guide.
- Best practices for using ArchiMate, BOC Group. Conventions, scoping and stakeholder views.
- 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.