Model-driven working

For me the model is the holy grail. Not because a diagram is the goal, but because an organisation that has its own core concepts sharp has much less to invent, align and repair afterwards.

Model-driven working means that the model is the source and the rest follows from it: the service interfaces, the database schema, the requirements and the documentation. When reality changes, the model changes first, and then what is derived from it.

In the literature this is called model driven architecture (MDA). I prefer to speak of model-driven working, because it is a way of working and not a product.

Three layers, one direction

flowchart LR
  C["Conceptual model<br/>concepts and their meaning"] --> L["Logical model<br/>data, structure, rules"]
  L --> F1["Service interfaces<br/>OpenAPI, XSD"]
  L --> F2["Database schema<br/>with history"]
  L --> F3["Requirements<br/>use cases, backlog"]
  L --> F4["Documentation<br/>reference and posters"]
The conceptual model says what the organisation means, the logical model how the data fits together. Everything to the right of it is derived.

The holy trinity: data, processes and rules

An organisation can be described along three lines that are closely related but fundamentally different. Together they are the basis of how it functions.

External rules and constraintsVisionGoalsServicesExternal taskDataProcessesRulesread, writeguardsteer
DataUML
What the organisation knows and records.
ProcessesBPMN
What happens, in what order and by whom.
Rules
What is allowed and what is required.

My starting point is that each of the three deserves its own elaboration, and that they reinforce each other when all three are well set up. A process that describes data that is not in the model, or a rule hidden in the code, is a predictable source of errors.

What an organisation further is and wants (its services, its vision and goals) and what is imposed on it from outside (legislation, constraints, the task itself) lies around it. That determines what has to be modelled; the trinity determines whether it works afterwards.

Conceptual, logical, physical

The second separation is the one in layers. The conceptual model describes concepts in the language of the organisation. The logical model describes the data precisely, but independently of technology. The physical level is the implementation: tables, messages, screens.

Keeping those layers apart makes a complex landscape manageable. The logical model decouples the data from the systems it happens to live in, and is therefore an integration step in itself.

Not too deep, not too shallow

A model is finished when it answers the questions it was made for. Too shallow, and everyone reads their own intention into it. Too deep, and nobody maintains it. Where that line lies differs per organisation; what matters is that an organisation takes the steps it can take. Sometimes those are small steps, sometimes big strides.

How I approach an organisation-wide model

  1. Explore

    Map the breadth of the field: which domains are there, who knows what, what documentation already exists. Interviews and reading.

  2. Deepen

    Work out the data, its meaning and its coherence per domain, together with the people who work with it.

  3. Integrate

    Rationalise and abstract across the domains: what is the same, what only looks the same, which data lives in which domain.

  4. Hand over

    Hand the model over to the architects and analysts who will maintain it, so that it stays alive after I leave.

The proof: Omnium

What I advise, I also build. Omnium is my own model workbench: one canonical model, and from it a working register with full history. I use it for proofs of concept, among others for Common Ground components.

Read on: the KVK case, the work for Common Ground and the knowledge base (in Dutch).

Does this fit your question?

Tell me what you are running into; I will tell you honestly whether a model is the answer.

Get in touch