Deliverables

The curriculum covers what an architect should know. This covers what an architect actually hands over: 22 artifacts, each with a worked example, a note on when it is worth producing, who reads it, and the ways it usually goes wrong. Filter by the artifact's type, the kind of engagement that calls for it, the stack or industry it is drawn against, or the audience it is written for.

Identify the deliverable → 18 diagrams, shown one at a time with the answer withheld. Nothing to submit.

All 22 deliverables, grouped by what kind of artifact each one is.

Structural View

What the system is made of and how the parts relate.

4
flowchart LR
  sales["Sales<br/><i>quote, opportunity, discount</i>"]
  orders["Ordering<br/><i>order, line, fulfilment</i>"]
  billing["Billing<br/><i>invoice, credit note, dunning</i>"]
  ship["Shipping<br/><i>consignment, manifest</i>"]
  legacy["Legacy Mainframe<br/><i>account master</i>"]

  sales -->|"Customer / Supplier"| orders
  orders -->|"Customer / Supplier"| billing
  orders -->|"Published Language"| ship
  legacy -->|"Anti-Corruption Layer"| orders
  billing -.->|"Shared Kernel — party identity"| sales
Structural View

Bounded Context Map

The domain model's fault lines — which parts of the business have their own language, and what kind of relationship each pair of them has.

flowchart TB
  subgraph core["Customer-Facing"]
    direction LR
    c1["Customer<br/>Management"]
    c2["Product &<br/>Catalogue"]
    c3["Order<br/>Capture"]
    c4["Fulfilment"]
  end
  subgraph enable["Enabling"]
    direction LR
    e1["Pricing &<br/>Promotion"]
    e2["Inventory<br/>Management"]
    e3["Payments &<br/>Settlement"]
    e4["Returns &<br/>Claims"]
  end
  subgraph support["Supporting"]
    direction LR
    s1["Finance &<br/>Accounting"]
    s2["Human<br/>Resources"]
    s3["Procurement"]
    s4["Risk &<br/>Compliance"]
  end
Structural View

Business Capability Map

What the business is able to do, arranged as a stable nested hierarchy of abilities with no processes, systems or org units on it.

Capability Mapping Discovery
flowchart TB
  cust(["Customer"])
  subgraph boundary["Order Management"]
    direction TB
    web["Web Application<br/><i>Next.js</i>"]
    api["Order API<br/><i>Java / Spring Boot</i>"]
    worker["Fulfilment Worker<br/><i>Java / Spring Boot</i>"]
    db[("Order Store<br/><i>PostgreSQL</i>")]
    queue[["Order Events<br/><i>Kafka</i>"]]
    cache[("Session Cache<br/><i>Redis</i>")]
  end
  pay["Payment Gateway"]

  cust -->|"HTTPS"| web
  web -->|"JSON over HTTPS"| api
  api -->|"reads and writes"| db
  api -->|"reads and writes"| cache
  api -->|"publishes"| queue
  queue -->|"consumes"| worker
  worker -->|"reads and writes"| db
  worker -->|"HTTPS"| pay
Structural View

Container Diagram

One level inside the system boundary — the separately deployable and runnable pieces, each named with the technology it is built on.

C4 Model Design
flowchart TB
  cust(["Customer"])
  agent(["Support Agent"])
  sys["Order Management<br/>the system being described"]
  pay["Payment Gateway<br/>external SaaS"]
  erp["ERP<br/>existing on-premises"]
  mail["Email Provider<br/>external SaaS"]
  crm["CRM<br/>external SaaS"]

  cust -->|"places and tracks orders"| sys
  agent -->|"amends and refunds orders"| sys
  sys -->|"authorises and captures"| pay
  sys -->|"posts financial documents"| erp
  sys -->|"sends confirmations"| mail
  sys -->|"reads account and entitlement"| crm
Structural View

System Context Diagram

The single box of your system surrounded by the people and external systems it talks to, and nothing about how it is built inside.

Context Diagrams Discovery

Behavioural View

What happens over time: sequence, state and process flow.

3
flowchart LR
  commit(["commit to main"]) --> build

  subgraph ci["Continuous Integration"]
    direction TB
    build["build<br/><i>pinned deps, hermetic</i>"]
    unit["unit tests<br/><i>&lt; 4 min</i>"]
    scan["SAST + dependency<br/>+ secret scan"]
    sign["sign artifact<br/>+ emit SBOM"]
    build --> unit --> scan --> sign
  end

  sign --> reg[("artifact registry<br/><i>immutable, digest-addressed</i>")]

  subgraph cd["Continuous Delivery"]
    direction TB
    dev["deploy dev<br/><i>auto</i>"]
    ctest["contract tests"]
    stage["deploy staging<br/><i>auto</i>"]
    nft["performance +<br/>resilience suite"]
    dev --> ctest --> stage --> nft
  end

  reg --> dev
  nft --> gate{"release gate<br/><i>automated checks +<br/>change record</i>"}
  gate -->|"pass"| canary["canary 5%<br/><i>15 min bake</i>"]
  gate -->|"fail"| stop(["blocked"])
  canary --> analyse{"error rate and<br/>latency within SLO?"}
  analyse -->|"yes"| full["progressive rollout<br/><i>25% → 50% → 100%</i>"]
  analyse -->|"no"| rollback(["automatic rollback"])
Behavioural View

CI/CD Pipeline Diagram

The path from commit to production as ordered stages, showing what each one proves, what it produces, and where a human is still in the loop.

sequenceDiagram
  autonumber
  participant C as Client
  participant G as API Gateway
  participant O as Order Service
  participant P as Payment Gateway
  participant Q as Event Log

  C->>G: POST /orders (Idempotency-Key)
  G->>O: create order
  O->>O: persist as PENDING
  O->>P: authorise (deadline 3s)
  alt authorised
    P-->>O: approved + auth id
    O->>O: mark CONFIRMED
    O->>Q: OrderConfirmed
    O-->>G: 201 Created
  else declined
    P-->>O: declined
    O->>O: mark REJECTED
    O-->>G: 402 Payment Required
  else timeout
    P--xO: no response by deadline
    O->>O: keep PENDING
    O-->>G: 202 Accepted (poll for status)
    Note over O,P: reconciliation job settles<br/>PENDING against the provider
  end
  G-->>C: response
Behavioural View

Sequence Diagram

One scenario as an ordered exchange of messages between participants, with time on the vertical axis and the failure paths drawn rather than assumed.

stateDiagram-v2
  [*] --> Pending: order placed
  Pending --> Authorised: payment approved
  Pending --> Rejected: payment declined
  Pending --> Expired: no response in 24h
  Authorised --> Picking: stock allocated
  Authorised --> Cancelled: customer cancels
  Picking --> Shipped: consignment handed to carrier
  Picking --> Backordered: stock unavailable
  Backordered --> Picking: stock replenished
  Backordered --> Cancelled: customer cancels
  Shipped --> Delivered: carrier confirms
  Shipped --> Lost: no scan in 14 days
  Delivered --> Returned: return accepted
  Rejected --> [*]
  Expired --> [*]
  Cancelled --> [*]
  Delivered --> [*]
  Returned --> [*]
  Lost --> [*]
Behavioural View

State Machine Diagram

The legal states of one entity and the events that move it between them, which is where illegal transitions become visible.

Data View

The structure, movement, ownership and lineage of data.

3
flowchart LR
  s1[("core_banking.accounts<br/><i>source</i>")]
  s2[("payments.transactions<br/><i>source</i>")]
  s3[("crm.customer<br/><i>source</i>")]

  j1{{"job: cdc_ingest<br/><i>hourly</i>"}}
  j2{{"job: conform_party<br/><i>daily 02:00</i>"}}
  j3{{"job: build_balances<br/><i>daily 03:15</i>"}}
  j4{{"job: reg_extract<br/><i>monthly</i>"}}

  r1[("raw.accounts")]
  r2[("raw.transactions")]
  c1[("clean.party")]
  c2[("clean.balance_daily")]
  o1[("report.capital_adequacy")]
  o2["Dashboard:<br/>Treasury Daily"]

  s1 --> j1 --> r1
  s2 --> j1 --> r2
  s3 --> j2
  r1 --> j2 --> c1
  r1 --> j3
  r2 --> j3 --> c2
  c1 --> j3
  c2 --> j4 --> o1
  c2 --> o2
Data View

Data Lineage Graph

Which dataset was derived from which, through what job — the artifact you produce when someone asks where a number came from.

erDiagram
  CUSTOMER ||--o{ ORDER : places
  CUSTOMER ||--o{ ADDRESS : has
  ORDER ||--|{ ORDER_LINE : contains
  ORDER }o--|| ADDRESS : "ships to"
  ORDER ||--o| PAYMENT : "settled by"
  PRODUCT ||--o{ ORDER_LINE : "appears in"
  PRODUCT }o--|| CATEGORY : "belongs to"

  CUSTOMER {
    uuid id PK
    string email UK
    string status
    timestamp created_at
  }
  ORDER {
    uuid id PK
    uuid customer_id FK
    uuid ship_to_id FK
    string status
    numeric total_minor
    string currency
  }
  ORDER_LINE {
    uuid id PK
    uuid order_id FK
    uuid product_id FK
    int quantity
    numeric unit_price_minor
  }
  PAYMENT {
    uuid id PK
    uuid order_id FK
    string provider_ref UK
    string state
  }
Data View

Entity Relationship Diagram

Entities, their attributes and the cardinality between them — where the notation on the end of each line is the actual content.

flowchart LR
  subgraph src["Sources"]
    direction TB
    oltp[("Operational DBs<br/><i>CDC</i>")]
    saas["SaaS APIs<br/><i>batch pull</i>"]
    events[["Event Stream<br/><i>Kafka</i>"]]
    files["Partner Files<br/><i>SFTP drop</i>"]
  end

  subgraph raw["Raw Zone"]
    direction TB
    r1[("append-only<br/>source schema<br/>no transforms")]
    r2["<i>guarantee:</i><br/>replayable history"]
  end

  subgraph clean["Cleansed Zone"]
    direction TB
    c1[("deduplicated<br/>typed, conformed<br/>quality-tested")]
    c2["<i>guarantee:</i><br/>schema + quality SLA"]
  end

  subgraph curated["Curated Zone"]
    direction TB
    g1[("business entities<br/>modelled, aggregated")]
    g2["<i>guarantee:</i><br/>agreed definitions"]
  end

  subgraph serve["Consumers"]
    direction TB
    bi["BI & Reporting"]
    ml["Feature Store<br/>& Model Training"]
    api["Data API<br/>& Reverse ETL"]
  end

  oltp --> raw
  saas --> raw
  events --> raw
  files --> raw
  raw --> clean
  clean --> curated
  curated --> serve
  clean -.->|"exploration only"| ml
Data View

Layered Data Platform Diagram

Sources landing into progressively refined zones, with the contract each zone offers written down rather than assumed.

Deployment & Infrastructure View

Where it runs, on what, and how it is wired together.

3
flowchart TB
  root["Organisation Root<br/><i>policy: deny unapproved regions</i>"]

  subgraph plat["Platform"]
    direction TB
    ident["Identity<br/><i>directory, privileged access</i>"]
    conn["Connectivity<br/><i>hub VNet/VPC, firewall, DNS, VPN</i>"]
    mgmt["Management<br/><i>logs, backup, monitoring</i>"]
  end

  subgraph land["Landing Zones"]
    direction TB
    subgraph corp["Corporate"]
      p1["Prod A<br/><i>spoke</i>"]
      n1["Non-Prod A<br/><i>spoke</i>"]
    end
    subgraph online["Internet-Facing"]
      p2["Prod B<br/><i>spoke</i>"]
      n2["Non-Prod B<br/><i>spoke</i>"]
    end
  end

  sandbox["Sandbox<br/><i>spend cap, no connectivity, auto-expire</i>"]
  decom["Decommissioned<br/><i>deny all</i>"]

  root --> plat
  root --> land
  root --> sandbox
  root --> decom
  conn --- p1
  conn --- n1
  conn --- p2
  conn --- n2
  mgmt -.->|"diagnostics forwarded"| land
  ident -.->|"roles and groups"| land
Deployment & Infrastructure View

Cloud Landing Zone Diagram

The account, network, identity and policy scaffolding every future workload will be dropped into, drawn before the first workload exists.

Landing Zones Design
flowchart TB
  users(["Users"]) --> dns["Global DNS<br/><i>latency routing + health checks</i>"]

  subgraph r1["Region: primary"]
    direction TB
    lb1["Load Balancer<br/><i>public</i>"]
    subgraph az1["Zone A"]
      n1["Node Pool<br/><i>api ×3, worker ×2</i>"]
    end
    subgraph az2["Zone B"]
      n2["Node Pool<br/><i>api ×3, worker ×2</i>"]
    end
    subgraph az3["Zone C"]
      n3["Node Pool<br/><i>api ×2, worker ×1</i>"]
    end
    db1[("Primary DB<br/><i>synchronous replica in Zone B</i>")]
    lb1 --> n1
    lb1 --> n2
    lb1 --> n3
    n1 --> db1
    n2 --> db1
    n3 --> db1
  end

  subgraph r2["Region: secondary"]
    direction TB
    lb2["Load Balancer<br/><i>warm</i>"]
    n4["Node Pool<br/><i>api ×2, scaled down</i>"]
    db2[("Read Replica<br/><i>asynchronous — RPO 30s</i>")]
    lb2 --> n4 --> db2
  end

  dns --> lb1
  dns -.->|"failover only"| lb2
  db1 -.->|"async replication"| db2
Deployment & Infrastructure View

Deployment Diagram

Which runtime artifact runs on which infrastructure, in which zone and region, and what fails when one of those boundaries fails.

flowchart TB
  inet(["Internet"])
  dc["Corporate Data Centre<br/><i>10.0.0.0/8</i>"]

  subgraph hub["Hub — 10.100.0.0/16"]
    direction TB
    fw["Egress Firewall<br/><i>FQDN allow-list</i>"]
    vpn["VPN / Direct Link<br/><i>BGP</i>"]
    dns["Private DNS Resolver"]
  end

  subgraph spokeA["Spoke: Prod — 10.101.0.0/16"]
    direction TB
    pub["Public Subnet<br/><i>10.101.0.0/24 — ingress LB only</i>"]
    app["App Subnet<br/><i>10.101.10.0/23 — no public IPs</i>"]
    data["Data Subnet<br/><i>10.101.20.0/24 — private endpoints</i>"]
    pub --> app --> data
  end

  subgraph spokeB["Spoke: Non-Prod — 10.102.0.0/16"]
    appn["App Subnet<br/><i>10.102.10.0/23</i>"]
  end

  inet -->|"443 only"| pub
  app -->|"all egress"| fw --> inet
  appn --> fw
  dc <-->|"BGP"| vpn
  vpn --- spokeA
  vpn --- spokeB
  spokeA x--x spokeB
Deployment & Infrastructure View

Network Topology Diagram

Segments, address ranges, routes and the control points between them — the view that says what can reach what at layer three.

Networking Design

Security View

Trust boundaries, threats, controls and blast radius.

2
flowchart LR
  subgraph who["Identities"]
    direction TB
    dev(["Developers<br/><i>group</i>"])
    sre(["SRE<br/><i>group</i>"])
    aud(["Auditors<br/><i>group</i>"])
    wl["Workload Identity<br/><i>order-api</i>"]
    ci["Pipeline Identity<br/><i>deploy-prod</i>"]
  end

  subgraph roles["Roles"]
    direction TB
    r1["Reader<br/><i>standing</i>"]
    r2["Operator<br/><i>standing</i>"]
    r3["Break-Glass Admin<br/><i>JIT — 60 min, approved, logged</i>"]
    r4["Deployer<br/><i>pipeline only</i>"]
    r5["Data Reader — Masked<br/><i>no raw PII</i>"]
  end

  subgraph what["Resources"]
    direction TB
    a1["Prod Compute"]
    a2["Prod Data Store"]
    a3["Key Vault"]
    a4["Audit Logs<br/><i>append-only</i>"]
  end

  dev --> r1 --> a1
  dev --> r5 --> a2
  sre --> r2 --> a1
  sre --> r3
  r3 --> a1
  r3 --> a2
  aud --> r1 --> a4
  wl --> r5
  wl --> a3
  ci --> r4 --> a1
Security View

IAM Role Model

Which identities may do what to which resource, expressed through roles rather than by naming people, so that access can be reviewed.

flowchart LR
  user(["Customer<br/><i>untrusted</i>"])
  admin(["Admin<br/><i>privileged</i>"])

  subgraph edge["Boundary 1 — public edge"]
    cdn["CDN / WAF"]
  end

  subgraph app["Boundary 2 — application tier"]
    direction TB
    api["Order API"]
    auth["Auth Service"]
  end

  subgraph datab["Boundary 3 — data tier"]
    direction TB
    db[("Order Store<br/><i>PII + card token</i>")]
    kms[("Key Vault")]
  end

  ext["Payment Provider<br/><i>third party</i>"]

  user -->|"F1 HTTPS"| cdn
  cdn -->|"F2 HTTPS + mTLS"| api
  admin -->|"F3 admin console"| api
  api -->|"F4 token introspection"| auth
  api -->|"F5 TLS + parameterised"| db
  api -->|"F6 fetch DEK"| kms
  api -->|"F7 HTTPS outbound"| ext
  ext -->|"F8 webhook — signed"| cdn
Security View

Threat Model Data Flow Diagram

Processes, stores and flows with trust boundaries drawn across them, so that every boundary crossing can be enumerated for threats.

Planning Artifact

Sequences the work: roadmaps, waves, dependencies and cutover.

2
gantt
  title Target state — 18 months
  dateFormat YYYY-MM-DD
  axisFormat %b %y

  section Foundation
  Landing zone and connectivity      :done,   f1, 2026-01-01, 60d
  Identity federation                :done,   f2, after f1, 45d
  Observability baseline             :active, f3, after f1, 75d

  section Decouple
  Strangler facade at edge           :active, d1, 2026-03-15, 90d
  Extract order domain               :        d2, after d1, 120d
  Extract pricing domain             :        d3, after d2, 90d
  Retire shared order database       :crit,   d4, after d3, 60d

  section Data
  Ingest to raw zone                 :        a1, 2026-04-01, 75d
  Conformed customer entity          :        a2, after a1, 90d
  Retire nightly extract jobs        :        a3, after a2, 45d

  section Resilience
  Multi-zone for tier 0              :        r1, 2026-06-01, 60d
  Automated failover rehearsal       :        r2, after r1, 45d
  Second region for tier 0           :crit,   r3, after r2, 90d
Planning Artifact

Architecture Roadmap

The sequence of architectural change over time, grouped by theme, with dependencies visible and each bar tied to an outcome rather than a technology.

flowchart LR
  subgraph w0["Wave 0 — Foundation"]
    direction TB
    f1["Landing zone"]
    f2["Connectivity + DNS"]
    f3["Identity federation"]
    f4["Observability + backup"]
  end

  subgraph w1["Wave 1 — Prove it (6 apps)"]
    direction TB
    a1["Internal wiki<br/><i>rehost</i>"]
    a2["Reporting portal<br/><i>rehost</i>"]
    a3["Batch scheduler<br/><i>replatform</i>"]
  end

  subgraph w2["Wave 2 — Bulk (34 apps)"]
    direction TB
    b1["Departmental apps<br/><i>rehost ×26</i>"]
    b2["Shared services<br/><i>replatform ×8</i>"]
  end

  subgraph w3["Wave 3 — Hard cases (9 apps)"]
    direction TB
    c1["Order management<br/><i>refactor</i>"]
    c2["Data warehouse<br/><i>replatform</i>"]
    c3["Partner gateway<br/><i>refactor</i>"]
  end

  subgraph w4["Wave 4 — Exit"]
    direction TB
    d1["Mainframe interfaces<br/><i>replace</i>"]
    d2["Data centre exit<br/><i>contract ends Q3</i>"]
  end

  w0 -->|"platform accepted<br/>by security + ops"| w1
  w1 -->|"runbook proven<br/>rollback rehearsed"| w2
  w2 -->|"shared services live<br/>latency measured"| w3
  w3 -->|"last dependency<br/>severed"| w4
Planning Artifact

Migration Wave Plan

Which applications move in which batch, in what order, and what the dependency between batches actually is.