LLI Wiki — My Digital Knowledge Base

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:

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.

  1. 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.
  2. 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.
  3. 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

Mastodon LLIMastodon SocialFosstodon