One model of your business. Everything else is generated from it.

URDAD is a method, and a tool suite supporting it, for specifying what an organisation’s services must achieve and how they achieve it — in one technology-neutral model. Diagrams, documentation, tests and running processes are all derived from that model, so they cannot drift apart.

Request a trialTry the playground

The URDAD method. Analysis — what is required: 1 Service, identify the required service and its stakeholders; 2 Requirements, as pre- and post-conditions, service inputs and outputs. Design — how it is met: 3 Allocation, each requirement to an activity or a service of the domain that can meet it; 4 Process, orchestrate activities realizing the requirements. 5: the responsible domains repeat the method for the lower-level services.
URDAD — a systematic method: analyse a service, design its realization, and repeat one level down.

Why URDAD?

In most organisations what the business does is written down three times — requirements in documents, designs in diagrams, behaviour in code — and kept in step by hand until they drift apart. URDAD replaces the three copies with one model.

How it works

  1. Capture stakeholder requirements

    The contractfor a required service is allocated to a responsibility domain, its stake holders identified and their functional requirements in the form of

    • (pre-conditions](term:precondition) under which service is refused,
    • post-conditions as the service guarantees.
    In the manual: capture stakeholder requirements
    URDAD Functional Requirements View of Process claim, showing Client; Requested by the policy owner; Policy in force at the incident; Incident has happened; Reported in time; Insurer; Claim recorded against the policy; Outcome recorded; Payout within cover.
    The contract of a motor insurer's Process claim service: what must hold before, and what is guaranteed after.
  2. Design the services

    Each requirement is allocated to a lower-level service that checks or realises it, and the process orchestrates them. Each lower-level service is designed the same way, in its own domain, down to the level of detail you need.

    Entities are defined through and evolve with the business processes which feed them.

    In the manual: design the services
    URDAD Process View of Process claim, showing Start; Check: Policy in force at the incident; Check: Requested by the policy owner; Check: Incident has happened; Check: Reported in time; Record claim; Resp: Report the claim number; on; merge; Update claim; Screen claim; ∀ item ∈ request.damagedItems → repairTotal — while repairTotal <= recorded.vehicleValue; Price damaged item; Def: writtenOff = repairTotal > recorded.vehicleValue; if; Assess and settle claim; Resp: Report the settlement; Resp: Report the decline; Investigate claim; raise Refuse: Policy in force at the incident not met exception and abort; End.
    The process that realises Process claim, from the services its requirements were allocated to.
  3. Verify

    The tool checks each process against its contract’s requirements as the model changes: a requirement no step addresses, or a step that cannot run, is reported before anyone relies on the model.

    Where a project asks for it, verification goes on to testing: a Testing phase runs the project’s processes against cases generated wholly from the model — each on its own, then all together — with the contracts’ own conditions as the oracle, and its test report goes to sign-off. Nobody writes a test, a stub or a data set.

    In the manual: verify
  4. Execute

    The optional execution environment runs the approved processes as the model states them, with people answering human tasks and existing systems answering requests — every answer checked against its contract.

    In the manual: execute
  5. Evolve

    Every change is made in a project, signed off and activated. The diagrams, documentation, tests and running processes follow the model; nothing is redrawn or rewritten by hand.

    In the manual: evolve

The tool suite

  • Model once

    • Three synchronised views — model tree, diagrams and element details — with every diagram generated by the tool's layout engine.
    • Real-time co-editing: every change is committed as a revision and seen by everyone on the branch at once.
    • Formal specifications in URDAD-OCL or URDAD-FEEL, and business rules as decision tables, checked as you write them.
    • Continuous verification of each process against its contract.
    More on model once
  • Govern change

    • Every change is made in a project, taken through phases and phase gates to activation.
    • Roles say who drives each transition and who signs what; regulated projects add the checklists their regimes require.
    • Sign-off on signed test reports, and an audit log of what was done and by whom.
    More on govern change
  • Execute

    • The optional execution environment runs approved processes as modelled, on Temporal's durable workflows.
    • People take part through a task portal whose forms are generated from the contracts.
    • External systems are called over HTTP, Kafka or AMQP, and every answer — a person's, a system's or a process's — is checked against its contract.
    More on execute
  • Share and integrate

    • Documentation generated as HTML, PDF or AsciiDoc, and published to Confluence with review comments flowing back.
    • Processes and decisions exported to and imported from BPMN and DMN for Camunda 8.
    • One vendor-neutral contract per responsibility — CI/CD gating, identity, LLM providers — with each product a thin adapter behind it.
    More on share and integrate
URDAD Scope View of Insurer, showing Assessment; Claims; Claims Management; Client Register; Fraud Investigation; Payments; Repair Network; Underwriting.
A motor insurer's responsibility domains, as the tool draws them from the model.

See it with your own models

Request a trialTry the playground