ArchiMate and TOGAF for a DBA platform: three layers, useful elements and three views
Modelling a DBA platform with ArchiMate in Archi: business, application and technology layers, useful elements and relationships, three views and a Mermaid mirror.
As a DBA platform grows (dozens of scripts, shared modules, pipelines, Batch pools, Azure SQL databases), nobody holds all of it in their head any more. An architecture model is not an academic exercise: it is the map that answers "who starts what, on what, with which dependencies?" before you touch anything. I use ArchiMate (the modelling language) in Archi (the free tool), with TOGAF as the way of thinking.
TOGAF and ArchiMate in two sentences
TOGAF is a method: it splits architecture into domains (business, applications, data, technology). ArchiMate is the graphical language that lets you draw them with a fixed vocabulary. For a DBA, three layers are what matters.
| Layer | Question | Generic example |
|---|---|---|
| Business | Who does what, for which goal? | "DBA team" role, "SQL maintenance" process |
| Application | Which software delivers it? | A backup script, a shared PowerShell module |
| Technology | What does it run on? | Batch pool, pipeline, SQL server, secrets vault |
The elements a DBA really uses
ArchiMate has dozens. A handful is enough:
- Application component: a deployable piece of software (an application script, a PowerShell module).
- Application service: what a component offers to others ("run a SQL query", "send a mail").
- Node: an execution or storage resource (Batch pool, pipeline agent, SQL server or elastic pool).
- System software: the software running on a node (PowerShell runtime, SQL engine).
- Artifact: a concrete deliverable (ZIP package, dacpac, configuration file).
- Data object: data being handled (inventory table, config file, log).
And the relationships, chosen with care:
| Relationship | Direction | Typical use |
|---|---|---|
| Assignment | actor -> process | the DBA team performs a process |
| Realization | component -> process or service | an application realizes a process |
| Serving | provider -> consumer | a module serves an application; a node serves an application |
| Triggering | trigger -> target | a pipeline starts a task |
| Flow | source -> target | data moving from one database to another |
| Association | no strong semantics | one module using another |
A trap in the specification: Access from an application component to a node is not allowed. Model access towards a data object; towards infrastructure use Serving or Flow.
Three useful views
I do not draw "everything on one page". Each view answers one question.
- Overview: the team, its processes, the applications that realize them, the modules they rely on. No nodes: you want to read the map in ten seconds.
- Modules: what each module exposes (functions, services) and who depends on it. If one module serves almost everyone, I draw it once and say so in a note instead of tracing twenty lines.
- Batch execution: per way of running (scheduled pipeline, Batch pool, jump host), what starts the run and which resources serve it. A resource is repeated in every lane that uses it, so no line crosses the view.
A Mermaid diagram imitating the overview
The model lives in Archi, but a Mermaid mirror can be read right in the repository or on a wiki page:
flowchart TD
subgraph Business
R["DBA team (role)"]
P1["SQL maintenance (process)"]
P2["Long-term backup (process)"]
end
subgraph Application
A1["Maintenance app"]
A2["Backup app"]
M1["Shared SQL module"]
M2["Shared Batch module"]
end
subgraph Technology
N1["Pipeline"]
N2["Batch pool"]
N3["SQL elastic pool"]
S1["PowerShell 7 runtime"]
end
R --> P1
R --> P2
A1 --> P1
A2 --> P2
M1 --> A1
M1 --> A2
M2 --> A1
M2 --> A2
N1 --> N2
N2 --> A1
N2 --> A2
N3 --> A1
S1 --> N2
Arrows are simplified here: team to its processes (assignment), applications to processes (realization), modules and nodes to applications (serving), pipeline to pool (triggering).
Lessons learned
- Limit crossings. Beyond roughly 25 crossing lines a view is no longer read. Moving relations into a README table beats a plate of spaghetti.
- Name what you do not draw. A note in the view ("managed identities are not drawn; every resource is reached with the identity of the run context") saves questions.
- Stay at the right granularity. A renamed function is none of the enterprise architect's business; a new application is.
- A model that disagrees with the code is a defect to fix, not a source of truth.