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, in the requirements specification phase: 1 Service — the service required, the domain responsible for it and its stakeholders; 2 Requirements — pre-conditions as refusals, post-conditions as guarantees, related ones grouped as one, and the request and response data. Related requirements of one domain become one higher-level requirement, decomposed one level down. Design: 3 Allocation, in the responsibility allocation phase — each condition to a service request or an activity; a new service's contract goes to a domain, which accepts it, forwards it to the domain it belongs to, or rejects it so that it stays in your domain; and inputs are augmented as design needs them. 4 Process, in the process orchestration phase — orchestrate the requests and activities, handle every refusal and populate the response. 5 One level down, for each service the process requests: its contract is specified first if it does not yet exist, then it is designed by your own team, which repeats steps 1 to 4, by another domain's team, with URDAD or in its own way, or by an external provider held to the contract. Never locked in: any contract can later be outsourced or automated without its requesters changing.
URDAD — a systematic method: specify what a service must do, allocate each requirement, orchestrate the process — then the same one level down, by whoever provides each service.

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. Specify the requirements

    The contract for a required service is placed in the responsibility domain accountable for it, its stakeholders are identified, and their functional requirements captured:

    Requirements that belong together are grouped into one, to be met by a single lower-level service; then the data the service is told and reports is specified.

    In the manual: specify the 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, or to an activity; a service nobody offers yet is handed to the domain it belongs to. The process then orchestrates them.

    Each lower-level service is designed by whoever provides it: your own team, the same way, one level down; another domain’s team; or an external provider, held to its contract. Who provides a service can change at any time without the processes requesting it changing — the business is never locked in.

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

    In the manual: design the services
    URDAD Responsibility Allocation View of Process claim, showing Policy in force at the incident; Requested by the policy owner; Incident has happened; Reported in time; Check: Policy in force at the incident; Record claim; Check: Requested by the policy owner; Check: Incident has happened; Refer to an investigator?; Check: Reported in time; Claim recorded against the policy; Outcome recorded; Payout within cover.
    Each of Process claim's requirements allocated to what meets it: a check for each pre-condition, and one decision for the outcome and the payout together.
  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