Deliverables

flowchart TB
  subgraph sell["Sell"]
    direction LR
    s1["CRM<br/><i>SaaS · Sales</i>"]
    s2["Quoting<br/><i>bespoke · Sales</i>"]
    s3["Pricing A<br/><i>legacy · Sales</i>"]
    s4["Pricing B<br/><i>legacy · Regional</i>"]
  end
  subgraph fulfil["Fulfil"]
    direction LR
    f1["Order Mgmt<br/><i>bespoke · Ops</i>"]
    f2["WMS<br/><i>COTS · Ops</i>"]
    f3["Carrier Portal<br/><i>SaaS · Ops</i>"]
  end
  subgraph support["Support"]
    direction LR
    b1["ERP<br/><i>COTS · Finance</i>"]
    b2["Billing<br/><i>mainframe · Finance</i>"]
    b3["HRIS<br/><i>SaaS · HR</i>"]
    b4["Expenses<br/><i>SaaS · unowned</i>"]
  end
  s3 -.->|"same capability"| s4

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

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

flowchart TB
  gw["HTTP Gateway<br/><i>inbound</i>"]
  subgraph svc["Order API — inside the container"]
    direction TB
    ctrl["Order Controller<br/><i>validation, mapping</i>"]
    app["Order Application Service<br/><i>use cases, transactions</i>"]
    dom["Order Domain Model<br/><i>invariants, state rules</i>"]
    repo["Order Repository<br/><i>persistence port</i>"]
    pay["Payment Client<br/><i>anti-corruption adapter</i>"]
    out["Outbox Publisher"]
  end
  db[("PostgreSQL")]
  ext["Payment Provider"]
  bus[["Kafka"]]

  gw --> ctrl --> app
  app --> dom
  app --> repo --> db
  app --> pay --> ext
  app --> out --> db
  out -.->|"relay reads outbox"| bus

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

flowchart LR
  crm["CRM"]
  oms["Order Mgmt"]
  erp["ERP"]
  wms["WMS"]
  bill["Billing<br/><i>mainframe</i>"]
  dw[("Warehouse")]
  ptnr["Partner"]

  crm -->|"I-01 · REST · on demand"| oms
  oms -->|"I-02 · SFTP CSV · nightly"| erp
  oms -->|"I-03 · MQ · near real time"| wms
  wms -->|"I-04 · REST · on demand"| oms
  erp -->|"I-05 · flat file · nightly"| bill
  bill -->|"I-06 · DB link · nightly"| dw
  oms -->|"I-07 · CDC · continuous"| dw
  ptnr -->|"I-08 · AS2 EDI · hourly"| oms
  oms -->|"I-09 · AS2 EDI · hourly"| ptnr

flowchart TB
  subgraph l1["Experience"]
    direction LR
    e1["Web"] --- e2["Mobile"] --- e3["Partner Portal"]
  end
  subgraph l2["Channel & API"]
    direction LR
    c1["API Gateway"] --- c2["BFF"] --- c3["Event Ingress"]
  end
  subgraph l3["Business Services"]
    direction LR
    b1["Ordering"] --- b2["Pricing"] --- b3["Fulfilment"] --- b4["Billing"]
  end
  subgraph l4["Integration"]
    direction LR
    i1["Message Broker"] --- i2["Adapters"] --- i3["File Transfer"]
  end
  subgraph l5["Data"]
    direction LR
    d1["Operational Stores"] --- d2["Analytical Platform"] --- d3["Cache"]
  end
  subgraph l6["Infrastructure"]
    direction LR
    f1["Compute"] --- f2["Network"] --- f3["Storage"]
  end
  l1 --> l2 --> l3 --> l4 --> l5 --> l6

  sec["Security<br/>&<br/>Identity"]
  ops["Observability<br/>&<br/>Operations"]

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

flowchart LR
  subgraph cust["Customer"]
    direction TB
    c1(["Submits claim"])
  end
  subgraph intake["Intake — automated"]
    direction TB
    a1["Validate policy"]
    a2{"Policy active<br/>and in cover?"}
    a3["Auto-assess<br/><i>rules + model</i>"]
    a4{"Confidence<br/>&ge; threshold?"}
  end
  subgraph handler["Claims Handler"]
    direction TB
    h1["Manual review"]
    h2{"Approve?"}
  end
  subgraph fin["Finance"]
    direction TB
    p1["Schedule payment"]
  end

  c1 --> a1 --> a2
  a2 -->|"no"| r1(["Reject — notify with reason"])
  a2 -->|"yes"| a3 --> a4
  a4 -->|"yes"| p1
  a4 -->|"no"| h1 --> h2
  h2 -->|"yes"| p1
  h2 -->|"no"| r2(["Decline — notify with appeal route"])
  p1 --> e1(["Paid"])

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"])

flowchart LR
  subgraph t1[" "]
    direction TB
    c1["cmd: Place Order"]
    e1["OrderPlaced<br/><i>fact</i>"]
    r1[("read: Order Status")]
    c1 --> e1 --> r1
  end
  subgraph t2[" "]
    direction TB
    c2["cmd: Authorise Payment"]
    e2["PaymentAuthorised<br/><i>fact</i>"]
    r2[("read: Payment Ledger")]
    c2 --> e2 --> r2
  end
  subgraph t3[" "]
    direction TB
    c3["policy: on PaymentAuthorised<br/>allocate stock"]
    e3["StockAllocated<br/><i>fact</i>"]
    r3[("read: Availability")]
    c3 --> e3 --> r3
  end
  subgraph t4[" "]
    direction TB
    c4["policy: on StockAllocated<br/>request despatch"]
    e4["ConsignmentCreated<br/><i>fact</i>"]
    r4[("read: Tracking")]
    c4 --> e4 --> r4
  end
  e1 --> c2
  e2 --> c3
  e3 --> c4

flowchart TB
  subgraph fwd["Forward path"]
    direction LR
    f1["1. Reserve stock"] --> f2["2. Authorise payment"] --> f3["3. Create consignment"] --> f4["4. Capture payment"] --> f5["5. Despatch"]
  end
  subgraph comp["Compensation"]
    direction RL
    k1["Release stock"] --- k2["Void authorisation"] --- k3["Cancel consignment"] --- k4["Refund<br/><i>visible to customer</i>"]
  end
  f1 -.->|"undo"| k1
  f2 -.->|"undo"| k2
  f3 -.->|"undo"| k3
  f4 -.->|"undo"| k4
  f5 -.->|"no undo — goods have left"| x(["point of no return"])

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

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 --> [*]

flowchart LR
  a["Idea accepted<br/><i>work 2d</i>"]
  w1(["wait 9d<br/>backlog"])
  b["Refinement<br/><i>work 1d</i>"]
  w2(["wait 4d<br/>awaiting design"])
  c["Build<br/><i>work 5d</i>"]
  w3(["wait 3d<br/>awaiting review"])
  d["Code review<br/><i>work 0.5d</i>"]
  w4(["wait 6d<br/>awaiting test env"])
  e["Test<br/><i>work 2d</i>"]
  w5(["wait 11d<br/>awaiting release window"])
  f["Release<br/><i>work 0.5d</i>"]

  a --> w1 --> b --> w2 --> c --> w3 --> d --> w4 --> e --> w5 --> f
  f --> tot["Work 11d &middot; Wait 33d<br/>Lead time 44d &middot; Flow efficiency 25%"]

flowchart LR
  party["Party"]
  cust["Customer"]
  supp["Supplier"]
  prod["Product"]
  order["Order"]
  ship["Shipment"]
  inv["Invoice"]
  pay["Payment"]
  loc["Location"]

  cust -->|"is a"| party
  supp -->|"is a"| party
  cust -->|"places"| order
  order -->|"is for"| prod
  supp -->|"supplies"| prod
  order -->|"is fulfilled by"| ship
  ship -->|"is sent to"| loc
  order -->|"is billed on"| inv
  inv -->|"is settled by"| pay

flowchart LR
  cust(["Customer"])
  app["Registration<br/><i>process</i>"]
  kyc["KYC Provider<br/><i>external · EU</i>"]
  core["Core Platform<br/><i>process</i>"]
  crm[("CRM store<br/><i>EU region</i>")]
  dwh[("Analytics store<br/><i>EU region</i>")]
  mkt["Marketing SaaS<br/><i>external · US</i>"]

  cust -->|"name, DoB, address, ID image"| app
  app -->|"name, DoB, ID image"| kyc
  kyc -->|"pass/fail, risk score"| app
  app -->|"full profile"| core --> crm
  crm -->|"pseudonymised profile, nightly"| dwh
  crm -->|"email, consent flag, on change"| mkt

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

flowchart TB
  subgraph d1["Domain: Sales"]
    direction TB
    p1["<b>customer-360</b><br/><i>daily · 99.5% freshness SLO<br/>owner: Sales Data</i>"]
    p2["<b>pipeline-facts</b><br/><i>hourly</i>"]
  end
  subgraph d2["Domain: Fulfilment"]
    direction TB
    p3["<b>order-events</b><br/><i>streaming · &lt;60s<br/>owner: Fulfilment Eng</i>"]
    p4["<b>delivery-performance</b><br/><i>daily</i>"]
  end
  subgraph d3["Domain: Finance"]
    direction TB
    p5["<b>revenue-recognised</b><br/><i>daily · certified<br/>owner: Finance Systems</i>"]
  end

  subgraph plat["Self-Serve Platform"]
    direction LR
    s1["storage + compute"] --- s2["catalog + lineage"] --- s3["access control"] --- s4["quality + observability"]
  end

  gov["Federated Governance<br/><i>global: identity keys · classification · retention</i>"]

  p3 -->|"consumed by"| p1
  p1 -->|"consumed by"| p5
  p3 -->|"consumed by"| p5
  plat --- d1
  plat --- d2
  plat --- d3
  gov -.-> d1
  gov -.-> d2
  gov -.-> d3

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
  }

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

flowchart LR
  src1[("Orders DB")] --> cdc["CDC connector"]
  cdc --> t1[["orders.raw<br/><i>12 parts · key: orderId<br/>retain 7d</i>"]]
  src2["Clickstream"] --> t2[["events.clicks<br/><i>36 parts · key: sessionId<br/>retain 3d</i>"]]

  t1 --> p1["Normalise<br/><i>stateless</i>"]
  p1 --> t3[["orders.clean<br/><i>12 parts · key: orderId<br/>compacted</i>"]]
  t3 --> p2["Enrich + join<br/><i>stateful · 30 min window</i>"]
  t2 --> p2
  p2 --> st[("RocksDB state<br/><i>checkpoint 60s</i>")]
  p2 --> t4[["orders.enriched<br/><i>12 parts · retain 30d</i>"]]
  p2 --> dlq[["orders.dlq"]]

  t4 --> sink1["Serving store"]
  t4 --> sink2["Lakehouse sink<br/><i>5 min commit</i>"]

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

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

flowchart TB
  subgraph pri["Primary site"]
    direction TB
    p1["Application tier"]
    p2[("Transactional DB")]
    p3[("Object storage")]
    p4["Secrets + config"]
  end
  subgraph dr["Recovery site — warm"]
    direction TB
    d1["Application tier<br/><i>scaled to 0 · IaC ready</i>"]
    d2[("DB replica<br/><i>async · lag &lt; 30s</i>")]
    d3[("Storage replica<br/><i>cross-region · 15 min</i>")]
    d4["Secrets replicated"]
  end

  p2 ==>|"async"| d2
  p3 ==>|"async"| d3
  p4 ==>|"sync"| d4

  subgraph run["Recovery sequence — tested 2026-05-18"]
    direction TB
    s1["1. Declare · 5 min"]
    s2["2. Promote replica · 8 min"]
    s3["3. Scale app tier · 6 min"]
    s4["4. Repoint DNS · 5 min<br/><i>TTL 60s</i>"]
    s5["5. Verify + reconcile · 12 min"]
    s1 --> s2 --> s3 --> s4 --> s5
  end
  dr --> run
  run --> res(["Restored — measured RTO 36 min"])

flowchart LR
  subgraph e1["Ephemeral / PR"]
    direction TB
    a1["scaled to 1<br/>mocked externals<br/>synthetic data<br/><i>proves: it builds and unit-passes</i><br/>auto-destroy 24h"]
  end
  subgraph e2["Dev"]
    direction TB
    a2["shared<br/>real internal deps<br/>synthetic data<br/><i>proves: integration wiring</i><br/>anyone deploys"]
  end
  subgraph e3["Staging"]
    direction TB
    a3["prod-shaped topology<br/>real deps · sandbox externals<br/>masked prod-like data<br/><i>proves: contracts + performance</i><br/>pipeline only"]
  end
  subgraph e4["Production"]
    direction TB
    a4["full scale · multi-AZ<br/>real data<br/><i>proves: nothing — it serves</i><br/>pipeline + gate"]
  end
  e1 --> e2 --> e3 --> e4
  note["Same artifact promoted throughout.<br/>Config differs; the image digest does not."]

flowchart TB
  subgraph prod["Cluster: prod-eu (regional, 3 AZ)"]
    direction TB
    cp["Control plane<br/><i>managed · private endpoint</i>"]
    subgraph pools["Node pools"]
      direction LR
      np1["system<br/><i>taint: CriticalAddonsOnly</i>"]
      np2["general<br/><i>3–30 nodes · spot 40%</i>"]
      np3["memory<br/><i>taint: workload=memory</i>"]
      np4["gpu<br/><i>taint: workload=gpu</i>"]
    end
    subgraph ns["Namespaces"]
      direction LR
      n1["team-orders<br/><i>quota · NetworkPolicy<br/>default-deny</i>"]
      n2["team-pricing<br/><i>quota · NetworkPolicy</i>"]
      n3["platform<br/><i>mesh · ingress · logging</i>"]
    end
    cp --- pools
    pools --- ns
  end
  subgraph nonprod["Cluster: nonprod-eu"]
    direction TB
    x1["shared node pool<br/><i>spot 90%</i>"]
  end
  reg[("Image registry<br/><i>signed images only</i>")] --> prod
  reg --> nonprod
  gitops["GitOps reconciler"] -.->|"applies desired state"| prod

flowchart TB
  u(["Users"]) --> gslb["Global traffic manager<br/><i>health + latency routing</i>"]

  subgraph ra["Region A — write primary"]
    direction TB
    a1["Edge + API"]
    a2["Services"]
    a3[("Primary DB<br/><i>accepts writes</i>")]
    a1 --> a2 --> a3
  end

  subgraph rb["Region B — read + standby"]
    direction TB
    b1["Edge + API"]
    b2["Services"]
    b3[("Replica<br/><i>read only · lag &lt; 2s</i>")]
    b1 --> b2 --> b3
  end

  gslb -->|"reads: nearest"| a1
  gslb -->|"reads: nearest"| b1
  gslb -->|"writes: always A"| a1
  b2 -.->|"write forwarding<br/>+45ms"| a2
  a3 ==>|"async replication"| b3
  arb{{"Failover arbitration<br/><i>manual promote · documented<br/>RPO &le; 2s · RTO 15 min</i>"}}
  arb -.-> a3
  arb -.-> b3

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

sequenceDiagram
  autonumber
  participant B as Browser
  participant A as App / BFF
  participant I as Identity Provider
  participant R as Resource API

  B->>A: GET /protected
  A-->>B: 302 to IdP (PKCE challenge, state, nonce)
  B->>I: authorise request
  I->>B: authenticate + MFA
  I-->>B: 302 back with authorisation code
  B->>A: code + state
  Note over A,I: back channel — browser never sees these
  A->>I: exchange code + PKCE verifier + client secret
  I-->>A: access token (10 min), refresh token, id token
  A->>A: store tokens server-side<br/>set HttpOnly SameSite cookie
  A-->>B: session cookie only
  B->>A: subsequent request + cookie
  A->>R: call with access token (Bearer)
  R->>I: fetch/refresh signing keys (JWKS, cached)
  R->>R: verify signature, issuer, audience,<br/>expiry, scope
  R-->>A: 200
  A-->>B: rendered response
  Note over A,I: on expiry the BFF refreshes<br/>with rotating refresh token

flowchart LR
  subgraph t4["Restricted"]
    direction TB
    a1["Card PAN · health records<br/>government ID images"]
    a2["<i>controls:</i> tokenise at edge<br/>field encryption · CMK<br/>no non-prod copies<br/>access JIT + approved<br/>full audit"]
  end
  subgraph t3["Confidential"]
    direction TB
    b1["Personal data · salary<br/>contracts · pricing"]
    b2["<i>controls:</i> encrypt at rest + transit<br/>masked in non-prod<br/>RBAC + quarterly review<br/>DLP on egress"]
  end
  subgraph t2["Internal"]
    direction TB
    c1["Operational metrics<br/>internal docs"]
    c2["<i>controls:</i> authenticated access<br/>standard retention"]
  end
  subgraph t1["Public"]
    direction TB
    d1["Published pricing<br/>marketing content"]
    d2["<i>controls:</i> integrity only"]
  end

  t4 --> s1[("Core DB · EU · Restricted")]
  t3 --> s1
  t3 --> s2[("Warehouse · EU · Confidential")]
  t2 --> s2
  t2 --> s3[("Object store · Internal")]
  t1 --> s3

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

flowchart TB
  hsm[("HSM / Key Service<br/><i>root of trust · FIPS 140-2 L3</i>")]
  cmk["Customer Master Key<br/><i>per environment · rotate 1y</i>"]
  dek["Data Encryption Keys<br/><i>per dataset · rotate 90d</i>"]

  hsm --> cmk -->|"wraps"| dek

  subgraph vault["Secret Store"]
    direction TB
    v1["Static secrets<br/><i>rotate 90d</i>"]
    v2["Dynamic credentials<br/><i>DB · TTL 1h</i>"]
    v3["PKI issuer<br/><i>mTLS certs · TTL 24h</i>"]
  end
  cmk -->|"encrypts vault at rest"| vault

  subgraph wl["Workloads"]
    direction TB
    w1["Service A<br/><i>workload identity</i>"]
    w2["Pipeline<br/><i>OIDC federation</i>"]
  end

  w1 -->|"attests identity — no stored secret"| vault
  w2 -->|"short-lived token — no stored secret"| vault
  vault -->|"lease · auto-renew · revocable"| w1
  dek -->|"envelope decrypt"| w1
  audit[("Audit log<br/><i>every issue and revoke</i>")]
  vault --> audit

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

flowchart LR
  u1(["Employee<br/><i>managed laptop</i>"])
  u2(["Contractor<br/><i>unmanaged device</i>"])
  u3["Workload<br/><i>service identity</i>"]

  subgraph pep["Policy Enforcement"]
    direction TB
    px["Proxy / Gateway<br/><i>terminates every session</i>"]
  end

  subgraph pdp["Policy Decision"]
    direction TB
    eng{"Policy engine"}
    sig1["Identity + MFA"]
    sig2["Device posture"]
    sig3["Risk + location"]
    sig4["Resource sensitivity"]
    sig1 --> eng
    sig2 --> eng
    sig3 --> eng
    sig4 --> eng
  end

  subgraph res["Resources"]
    direction TB
    r1["Internal app"]
    r2[("Database")]
    r3["SaaS"]
  end

  u1 --> px
  u2 --> px
  u3 --> px
  px <-->|"authorise this request"| eng
  px -->|"allow · scoped · time-bound"| r1
  px -->|"allow · read-only"| r2
  px -->|"deny · posture fail"| r3
  log[("Decision log<br/><i>every allow and deny</i>")]
  eng --> log

flowchart TB
  s(["Alert: order submit p99 > 900 ms<br/>for 5 min"])
  s --> c1["1. Confirm scope<br/><i>one region or global?</i>"]
  c1 --> q1{"Global?"}
  q1 -->|"no"| a1["2a. Check that region's<br/>dependency health"]
  q1 -->|"yes"| a2["2b. Check shared dependencies:<br/>DB, cache, identity"]
  a1 --> q2{"Region-local cause?"}
  q2 -->|"yes"| m1["3. Shift traffic away<br/><i>runbook OPS-04</i>"]
  q2 -->|"no"| a2
  a2 --> q3{"DB CPU > 80%<br/>or replication lag > 10s?"}
  q3 -->|"yes"| m2["4. Enable read-path cache bypass=off<br/>+ raise connection limit<br/><i>flag: cache.aggressive</i>"]
  q3 -->|"no"| q4{"Recent deploy<br/>in last 60 min?"}
  q4 -->|"yes"| m3["5. Roll back<br/><i>runbook OPS-01</i>"]
  q4 -->|"no"| esc(["6. Escalate to<br/>Order team on-call<br/><i>stop investigating</i>"])
  m1 --> v["7. Verify p99 recovers<br/>within 10 min"]
  m2 --> v
  m3 --> v
  v --> q5{"Recovered?"}
  q5 -->|"yes"| done(["Close · record in incident log"])
  q5 -->|"no"| esc

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

flowchart TB
  t1["T-7d · Dry run in staging<br/><i>full rehearsal, timed</i><br/>owner: Delivery"]
  t2["T-1d · Freeze changes · verify backups<br/>confirm rota and bridge<br/>owner: Ops"]
  t3["T-0 00:00 · Enable read-only on legacy<br/>owner: Ops"]
  t4["T-0 00:15 · Final delta migration<br/><i>est 90 min · checkpoint at 60</i><br/>owner: Data"]
  t5["T-0 01:45 · Reconcile counts + checksums<br/>owner: Data"]
  g1{"T-0 02:15 · GO / NO-GO<br/><i>criteria: 100% row match,<br/>0 critical defects, all owners present</i>"}
  t6["T-0 02:30 · Repoint DNS + feature flag<br/><i>TTL pre-lowered to 60s</i><br/>owner: Platform"]
  t7["T-0 02:45 · Smoke suite + 10 manual journeys<br/>owner: QA"]
  g2{"T-0 03:30 · Accept or roll back"}
  t8["T-0 03:30 · Open to 10% traffic<br/>owner: Platform"]
  t9["T-0 06:00 · 100% traffic<br/>owner: Platform"]
  t10["T+24h · Hypercare ends<br/>legacy kept read-only 30d"]
  rb(["ROLLBACK · revert DNS<br/>re-enable legacy writes<br/><i>est 20 min</i>"])
  pnr["POINT OF NO RETURN<br/><i>after first write to new system<br/>rollback needs reverse migration</i>"]

  t1 --> t2 --> t3 --> t4 --> t5 --> g1
  g1 -->|"no-go"| rb
  g1 -->|"go"| t6 --> t7 --> g2
  g2 -->|"roll back"| rb
  g2 -->|"accept"| t8 --> t9 --> t10
  t8 -.-> pnr

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

flowchart TB
  subgraph l1["Capabilities delivered"]
    direction LR
    c1["Product<br/>engineering"] --- c2["Data &<br/>analytics"] --- c3["Platform &<br/>infrastructure"] --- c4["Security &<br/>risk"]
  end
  subgraph l2["Organisation"]
    direction LR
    o1["Stream-aligned teams<br/><i>×9 · own build and run</i>"] --- o2["Platform team<br/><i>×1 · paved road</i>"] --- o3["Enabling team<br/><i>×1 · coaching</i>"] --- o4["Architecture chapter<br/><i>federated</i>"]
  end
  subgraph l3["Ways of working"]
    direction LR
    p1["Product-funded<br/><i>not project</i>"] --- p2["You build it<br/>you run it"] --- p3["Continuous<br/>delivery"] --- p4["Design authority<br/><i>advisory + gates</i>"]
  end
  subgraph l4["Governance"]
    direction LR
    g1["ARB<br/><i>off-radar only</i>"] --- g2["Tech radar<br/><i>quarterly</i>"] --- g3["Automated<br/>compliance"] --- g4["Exception<br/>register"]
  end
  subgraph l5["People"]
    direction LR
    s1["Skills gaps<br/><i>SRE ×6 · data eng ×4</i>"] --- s2["Sourcing<br/><i>hire 6 · reskill 4</i>"] --- s3["Career paths<br/><i>IC track added</i>"]
  end
  l1 --> l2 --> l3 --> l4 --> l5

quadrantChart
  title Business value against technical health
  x-axis "Poor technical health" --> "Good technical health"
  y-axis "Low business value" --> "High business value"
  quadrant-1 Invest
  quadrant-2 Migrate or re-engineer
  quadrant-3 Eliminate
  quadrant-4 Tolerate
  "Order management": [0.28, 0.92]
  "Payment gateway": [0.81, 0.95]
  "Customer portal": [0.74, 0.78]
  "Pricing engine": [0.22, 0.84]
  "Mainframe billing": [0.14, 0.88]
  "Legacy CRM": [0.19, 0.34]
  "Reporting portal": [0.31, 0.26]
  "Expenses tool": [0.68, 0.22]
  "Intranet wiki": [0.72, 0.18]
  "Partner gateway": [0.44, 0.66]

quadrantChart
  title Platform technologies
  x-axis "Retire" --> "Adopt"
  y-axis "Low usage" --> "High usage"
  quadrant-1 "Adopt — default choice"
  quadrant-2 "Hold — in use, do not extend"
  quadrant-3 "Retire — plan removal"
  quadrant-4 "Trial / Assess — bounded use"
  "Kubernetes (managed)": [0.92, 0.88]
  "PostgreSQL": [0.95, 0.93]
  "Kafka (managed)": [0.86, 0.72]
  "Terraform": [0.90, 0.80]
  "OpenTelemetry": [0.78, 0.55]
  "Service mesh": [0.55, 0.30]
  "Self-managed Elasticsearch": [0.18, 0.62]
  "Oracle DB": [0.12, 0.70]
  "Jenkins": [0.20, 0.45]
  "Nomad": [0.60, 0.08]
  "DuckDB (analytics)": [0.62, 0.12]