Owning the logic
AI inside SAP S/4HANA and CTRM, two client case studies: U.S. Grains and Australian LNG
Owning the logic
AI inside SAP S/4HANA and CTRM, two client case studies: U.S. Grains and Australian LNG
I built this pattern with two very different commodity businesses:
- A U.S. grains exporter originating from producers (farmers), storing, blending, hedging, and exporting through a Gulf export corridor.
- An Australian LNG exporter running contract‑to‑cargo‑to‑cash out of an Australian export hub into Asia.
I used SAP S/4HANA as the ERP spine (both clients are now on this), a CTRM as the front‑to‑back trading backbone (vendor‑agnostic because we were asked not to share this), and I ran delivery using SAP Activate as a control framework, not as a slide deck.
For years, AI sat outside that machine in dashboards.
AI advised. People typed the final answer back into SAP or the CTRM.
Now, AI is moving into the core: into CTRM confirmations, scheduling decisions, valuation inputs, payment matching, and even SAP postings.
- The big question for leaders: if AI can change books, cash, or risk, do you know who owns the logic?
And I treated the AI part like a system-of-record change:
- New accountability (one owner per model and process)
- System invariants (“what must always be true” around inventory, valuation, cash, and controls)
- Audit-grade evidence (prove what happened and why)
- Tiered execution (the more high‑stakes, the more deterministic and human‑approved)
- Incident and model risk management (risk register, scenario testing, degrade‑to‑rules).
Why I put AI inside the core
Trade happens fast. The value isn’t in insights; it’s in safe execution at the moment decisions are made.
- Sidecar AI improves thinking.
- Core AI changes reality (positions, inventory, cash, and accounting).
That’s the control bar.
The ten non-negotiables I enforced
AI-in-the-core requires governance like a financial system. I used these ten rules across both clients:
- 1. One owner per model and process.
- 2. No uncontrolled write-back into CTRM or SAP.
- 3. Hard tiering: Tier 1 (high stakes), Tier 2 (bounded), Tier 3 (advisory).
- 4. Every Tier 1 action requires evidence + approval.
- 5. Every Tier 2 action requires deterministic constraints + an exception path.
- 6. Every Tier 3 output must be clearly advisory and non-binding.
- 7. All AI outputs must be replayable (same inputs ⇒ same outputs).
- 8. Every decision stores a “packet” (inputs, rules, model version, outputs, user action).
- 9. The system must degrade to rules/manual when confidence drops or incidents occur.
- 10. Control owners sign off before go-live.
AI without controls is just automation risk.
My tier model: all tiers in release one
I don’t treat AI as one thing. I use three tiers so the control model matches the risk model.
Tier definitions (how I used them)
- Tier 1 (high-stakes): can touch valuation, postings, cash.
- Tier 2 (bounded): can auto-exec in constraints and tolerate exceptions.
- Tier 3 (advisory): cannot write to books; used for extraction, summarization, drafting.
Execution stance (how I kept it safe)
If it can change economic truth (cash, exposure, inventory, or accounting), it’s Tier 1, and it must be approval-first or constraints-first.
| Tier | Default stance | Auto-exec allowed only when | Stop controls (non-negotiable) |
|---|---|---|---|
| 1 | Approval-first | Action is low variance, tightly bounded, reconciles end-to-end, and SoD is enforced | tolerance bands, SoD, posting validation, reconciliation preview, decision logging |
| 2 | Auto-exec on “green path” | Deterministic constraints fully bound allowable actions | constraint engine, exception workflow, sampling review, drift monitoring |
| 3 | Auto-exec | Output cannot change books/risk/cash by itself | prompt/config logging, sampling review, content safety rules |
Tier ladder with execution gates
Oversight by tier. Execution by guardrails.
Tier 1: High-stakes AI
Definition: Touches valuation, exposure, inventory, postings, or cash risk.
Default stance: Approval-first.
Typical actions:
- Valuation parameter change (curve/basis selection)
- Accounting posting proposal (journal lines)
- Reserve/accrual recommendation above threshold
- Settlement decision that changes cash outcome
Hard stop: No posting. No cash release. No valuation change without approval + evidence.
Tier 2: Bounded AI
Definition: Material operational/credit outcomes, bounded by deterministic constraints.
Default stance: Auto-exec on green path.
Typical actions:
- Auto-match invoices within tolerance bands
- Auto-route exceptions to the right approver
- Adopt logistics plan option when constraints all pass
- Apply standard cash matching when deterministic rules match
Any constraint breach routes to exception workflow.
Tier 3: Advisory AI
Definition: Advisory and content. Cannot change books, risk, or cash by itself.
Default stance: Auto-exec.
Typical actions:
- Extract terms from contracts and docs
- Draft emails, checklists, and summaries
- Explain ‘why’ in plain language
- Prepare committee narrative drafts
No write-back to economic fields. No commit actions.
AI Output Created
Gate 1: Data readiness
- Freshness SLA met
- Completeness checks passed
- Lineage tags present
Fail → Hold
Gate 2: Deterministic controls
- Tolerance bands
- Limit checks
- Constraints engine
Fail → Hold
Gate 3: SoD + role check
- Builder ≠ approver ≠ operator
- Right role for this action
Fail → Hold
Gate 4: Human oversight (conditional)
- Visually used for Tier 1, sometimes for Tier 2, never for Tier 3
Gate 5: Commit action
- Write to CTRM transaction
- Post in SAP
- Create payment proposal
Fail → Hold
Gate 6: Evidence packet written
- Decision packet stored (context, inputs hash, model hash, output, controls, user action, downstream doc IDs)
Fail → Hold
Gate 7: Monitoring + sampling
- Drift score
- Override rate
- Exception volume
Exception workflow
- Hold transaction
- Create approval task
- Capture reason code
- Notify owner
Fail → Hold
Green path criteria
- Action space fully bounded by deterministic constraints
- Reconciliation proven end-to-end
- SoD enforced in workflow
- Rollback to rules rehearsed
- Decision packet captured 100%
- Auto
- Approval required
- Advisory only
Tier sets required oversight. Guardrails decide whether execution is allowed.
How I used SAP Activate: I treated phases as control gates
I treated SAP Activate as a release gating system. Each phase had a hard deliverable I could verify.
Every gate had a named owner and a decision: ship, hold, or degrade to manual rules.
Activate, rewritten as “AI-in-the-core delivery gates”
| SAP Activate phase | What I made different for AI-in-the-core | Hard deliverables I required | Gate owners |
|---|---|---|---|
| Discover | AI use cases triaged by tier and control requirements | Tiering model, initial risk register, initial evidence requirements | Program sponsor + control owner |
| Prepare | Data and integration plan is verified (lineage, reconciliation, SoD) | Data contracts, interface reconciliations, decision packet schema | Data owner + ERP/CTRM owner |
| Explore | Guardrails and exception workflows designed and tested | Constraint engine, approval workflows, rollback plan, sampling plan | Control owners + process owners |
| Realize | AI-in-the-core built with audit-grade logging | Build artifacts, test evidence, monitoring plan, runbooks | Delivery owner + audit/risk sign-off |
| Deploy | Go-live only with sign-offs and degrade-to-rules tested | Go-live checklist, incident runbook, committee reporting pack | Business owner + risk committee |
| Run | Ongoing drift monitoring and controls validation | Drift dashboards, sampling reviews, incident logs, improvement backlog | Ops owner + internal audit |
The reference architecture I repeated
This is the backbone. It works for ERP + CTRM + AI because it makes execution safe and auditable:
- Systems of record (CTRM, SAP S/4HANA)
- Deterministic guardrails outside the model
- Decision packet stored for every action
- Evidence chain for controls and approvals
- A single trace for audit: “trigger → decision → action → posting”
Where AI sat
- Close to work, not to reporting.
- Sidecar AI for analysis, but core AI for execution.
- Separate “advisor” outputs from “executor” actions.
- Put AI behind a constraint engine and SoD controls.
- Make every action replayable.
Systems + integration
- Use events and APIs, not file drops, for decisions that move risk or cash.
- Keep the source-of-truth in CTRM/SAP.
- Use integration (SAP Integration Suite or equivalent) for trace and resilience.
- Every AI action writes a decision packet to a log store.
- Decision packets link to SAP docs and CTRM transactions.
Case Study 1: U.S. Grains, producer origination to export, end to end
I anchor this in a U.S. client export corridor:
- Producer origination (contracts, credit)
- Receiving at elevator (weight, grade, inventory)
- Storage and blending (spec integrity)
- Hedge + sales (risk and valuation)
- Shipment planning (terminal slots, demurrage)
- Invoicing + settlement (cash)
- Month-end close (SAP postings)
Grain Step 0, Foundation: exposure integrity and data contracts
Business process elements
- Trade capture
- Inventory movements
- Pricing and valuation
- Settlement and invoicing
- ERP posting
Systems + integration
- CTRM trade + physical positions
- SAP S/4HANA inventory and GL
- Market data feeds
- Interfaces: API‑first, event‑driven
AI actions by tier
- Tier 3: Extract and reconcile interface specs and contract terms.
- Tier 2: Detect breaks in position/inventory ties with deterministic tolerances.
- Tier 1: No auto-posting. Approval-first for any fix that changes exposure, valuation, or SAP.
Commercial goal:
Stop arguing about where the truth is. Make “books vs ops vs cash” alignment visible daily.
What I built
A lineage map for every economic fact: quantity, quality, price, timing, counterparty.
- Every key field has an owner and a contract.
- Every interface has a reconciliation check.
- Every break has a reason code and escalation path.
- Every fix produces evidence.
Output
- Daily tie-out dashboard (CTRM position ↔ SAP inventory ↔ bank/ops feeds)
- Critical breaks queue with owners
- Audit trace: “what changed, who approved, what posted”
Critical controls
- System-of-record rules (CTRM vs SAP vs terminal data)
- Reconciliation preview before posting
- Separation of duties: builder ≠ approver ≠ operator
- Evidence: decision packet stored with hashes and references
- Fallback: degrade to deterministic rules, no AI write-back
U.S. GRAINS FOUNDATION: LINEAGE + RECONCILIATION
Purpose: Make exposure integrity visible.
- SOURCE SYSTEMS
- Scale ticket
- Inventory move
- CTRM
- Position tie-out
- Inventory tie-out
- Trade position
- P&L tie-out
- SAP
- Invoice
- GL posting
Grain Step 1, Producer onboarding, contract capture, and credit posture
Business process elements
- Producer master setup
- Contract capture (spot and forward)
- Credit exposure and limits
- Approval workflow
- Document storage
Systems + integration
- CTRM contract objects
- SAP customer/vendor master
- Credit system or limits engine
- Doc repository
Human touchpoints
- Origination enters the contract and key terms
- Credit approves limits and exposure
- Legal approves templates and deviations
AI actions
- Tier 3 (auto):
- extract key terms from producer contracts and templates
- draft contract summary for credit and legal
- Tier 2 (auto on green path):
- route approval workflows based on policy and counterparty type
- flag clause deviations vs. standard library
- Tier 1 (approval-first):
- recommend counterparty risk posture (limit class / payment terms)
- flag accounting-sensitive terms (e.g., variable consideration triggers)
Tier 1 controls
- All limit class changes require approval, with reason codes
- Policy deviations generate an exception workflow and a signed decision
- No AI write-back into credit master fields
- Evidence packet ties clause refs → approvals → contract ID
Deterministic guardrails + evidence
- Guardrails:
- standard clause library diff check
- payment term bounds by counterparty class
- SoD: contract creator cannot approve deviations
- Evidence stored:
- contract text hash + extracted field hash
- policy rule versions used
- approver ID + timestamp + disposition
Grain Step 2, Receiving at the elevator, grading, storage, and inventory integrity
Business process elements
- Scale ticket capture (gross/tare/net)
- Grain grading (moisture, damage, FM, TW)
- Bin allocation and segregation
- Blending and conditioning
- Inventory movements (receipt, transfer, shrink)
Systems + integration
- Scale and lab systems
- CTRM inventory objects
- SAP inventory postings
- Terminal/warehouse systems
- Interfaces and reconciliation checks
Human touchpoints
- Weighmaster validates tickets and handles exceptions
- Quality team reviews grade anomalies
- Ops approves shrink and loss above tolerance
AI actions
- Tier 3 (auto):
- draft receiving summaries and exception notes
- extract and normalize lab result formats
- Tier 2 (auto on green path):
- detect anomalous weight patterns and grade outliers
- recommend bin allocation within segregation rules
- suggest blend options with cost/spec trade-offs
- Tier 1 (approval-first):
- recommend reserves/accruals if quality shifts are material
- recommend shrink/loss postings above threshold
Tier 1 actions
- Reserve / accrual recommendations tied to quality changes
- Shrink / loss postings above policy thresholds
Deterministic guardrails
- weight tolerance bands and duplicate ticket prevention
- segregation rules enforced as hard stops
- mass balance checks and shrink tolerance
- exception workflow for any constraint breach
Evidence logged
- scale ticket IDs + lab result IDs + hashes
- constraint checks fired + outcomes
- approvals for Tier 1 items with reason codes
Grain Step 3, Hedge + sales, valuation, and exposure integrity
Business process elements
- Sales contracts and shipments
- Hedge execution and position management
- Daily valuation and P&L
- Exposure reporting and limits
- Margin and cash forecasting
Systems + integration
- CTRM positions, valuations, and risk
- Market data feeds (curves, basis, FX)
- SAP GL and subledger
- Risk limits engine and approvals
- Decision log store
AI actions by tier
- Tier 3:
- draft daily narrative for risk committee: what moved and why
- summarize exceptions, overrides, and key drivers
- Tier 2:
- detect valuation anomalies and missing market data inputs
- suggest hedge adjustments within deterministic limits
- rank pricing scenarios for commercial review
- Tier 1:
- propose valuation parameter changes (curve/basis selection)
- propose reserve/accrual changes above threshold
Tier 1 actions
- Valuation parameter changes that affect P&L or exposure
- Reserve/accrual recommendations above threshold
Deterministic guardrails
- market data freshness and completeness SLAs
- limit checks and bounded action space for Tier 2 suggestions
- approval workflow for any Tier 1 change
Evidence logged
- market data snapshot hash + sources
- valuation run ID + parameters + model version
- approvals and overrides tied to position IDs
Grain Step 4, In-transit, port, docs, and FOB transfer
Business process elements
- In-transit legs (rail, barge, vessel)
- Terminal receipts and load plans
- Docs (B/L, certs, invoices)
- FOB transfer and title/ risk
- Demurrage and claims
Systems + integration
- Terminal/port systems
- Docs management system
- CTRM shipment legs and events
- SAP logistics and inventory postings
- Bank and LC systems (if used)
AI actions by tier
- Tier 3:
- draft shipping docs checklists and exception notes
- summarize terminal/port status changes
- Tier 2:
- optimize shipment plans within constraints (slots, capacity, laycans)
- flag demurrage risk and suggest mitigations
- detect doc completeness gaps before release
- Tier 1:
- recommend FOB transfer timing changes if material
- recommend claims/reserve actions above thresholds
Tier 1 actions
- FOB/title transfer decisions that shift exposure and accounting timing
- Claims/reserve recommendations above thresholds
Deterministic guardrails
- constraint engine: slot availability, capacity, laycan windows
- doc completeness as hard stop before release
- approval workflow for Tier 1 timing or reserve changes
Evidence logged
- shipment event IDs + terminal receipt IDs
- doc IDs + hashes + validation outcomes
- decision packet for plan option adopted + constraints passed
Implementation note: I forced every “green path” shipment plan to be provably feasible: constraints satisfied, demurrage risk quantified, and rollback steps rehearsed.
Grain Step 5, Invoicing, payables, and GL prep
Business process elements
- Invoice generation (provisional and final)
- Payables and receivables
- Claims and adjustments
- Cash application and matching
- ERP posting readiness
Systems + integration
- CTRM settlement docs
- SAP AR/AP and GL
- Bank statements and payment runs
- Docs repositories
- Interfaces and reconciliation
Human touchpoints
- Settlements reviews invoice exceptions and disputes
- Finance reviews posting proposals and accruals
- Treasury approves payment runs and cash release
AI actions by tier
- Tier 3:
- extract invoice and settlement terms from docs
- draft dispute narratives and communications
- Tier 2:
- auto-match invoices to contracts and receipts within tolerance
- auto-route exceptions with reason codes
- propose cash application matches when deterministic rules align
- Tier 1:
- propose journal lines for SAP posting (approval-first)
- propose payment release decisions above thresholds
Tier 1 actions
- Posting proposals that impact GL timing or amounts
- Payment release decisions that change cash outcomes
Deterministic guardrails
- tolerance bands for invoice matching
- segregated roles for proposal vs approval vs execution
- reconciliation preview before SAP posting
- exception workflow for any mismatch
Evidence logged
- invoice IDs + contract IDs + receipt IDs
- matching rules fired + outcomes + reason codes
- SAP doc IDs linked to decision packets
Integration note: Integration was API-first. Decision packets linked to SAP doc IDs and CTRM settlement IDs.
Grain Step 6, Month-end close, board/audit, and continuous control proof
Business process elements
- Month-end valuation and accruals
- Inventory and position reconciliation
- Close checklist and sign-offs
- Committee reporting packs
- Audit evidence preparation
Systems + integration
- CTRM close runs and valuation
- SAP close and postings
- Reconciliation dashboards
- Decision log + evidence store
- Reporting outputs for committees
AI actions by tier
- Tier 3:
- draft close narratives and committee summaries
- compile evidence packs and check completeness
- Tier 2:
- detect reconciliation breaks and route owners
- monitor drift and override rates
- Tier 1:
- recommend material accrual/reserve changes (approval-first)
- recommend valuation parameter changes (approval-first)
Critical controls
- Close sign-off requires tied-out reconciliations
- All Tier 1 items require senior approval
- Evidence completeness checks before committee packs
- Audit trail integrity validation
Evidence logged
- close run IDs + reconciliations + outcomes
- approvals + reason codes + timestamps
- committee pack version + linked evidence IDs
RECONCILIATION (CTRM ↔ SAP ↔ BANK/OPS)
- positions, inventory, P&L
- Cash/Settlements, Physical Movements
- AR/AP, Cash
- RECONCILED & TIED-OUT
- Across all systems
- BANK & OPS FEEDS
- Position & Inventory
- P&L & Valuation
- AR/AP & Cash
EVIDENCE COMPLETENESS (AI-INFLUENCED DECISIONS)
- CONTROLS FIRED (Rules, Limits, Overrides) LOGGED
- APPROVALS CAPTURED (User Sign-off, Timestamp) SIGNED
- SAP DOC LINKAGE PRESENT (Doc ID, Posting Ref) LINKED
- AUDIT TRAIL COMPLETE
MONTH-END CLOSE: FOB U.S. GULF EXPORT
STATUS: CLOSED & AUDITABLE
Positions, Inventory, P&L, Cash, and AI Evidence Reconciled and Proven.
Case Study 2: Australian LNG, export hub to Asia, end to end
I anchor this in an Australian export hub story:
Australian LNG export hub → SPA and cargo schedule → nominations → terminal slot → loading → voyage → discharge into Asia → pricing and settlement → LC docs → cash → close.
Destination stays “Asia” in the narrative, with the working assumption of a North Asian buyer under a standard SPA structure.
LNG Step 0, Foundation: from contract to cargo to cash (with IFRS triggers)
Business process elements
- SPA master terms and deviations
- Cargo schedule and nominations
- Terminal slotting and loading events
- Pricing mechanics and settlement
- LC docs and cash application
Systems + integration
- CTRM deals, cargos, pricing, and exposure
- SAP S/4HANA AR/AP and GL
- Terminal systems (loading, measurement)
- Docs systems (B/L, origin, quality)
- Bank/LC systems
- Integration constraints: every event must link to a cargo ID and a trade ID
- SoD across commercial, finance, and treasury approvals
- Evidence store links terms → triggers → postings
AI actions by tier
- Tier 3:
- extract and normalize SPA terms and clauses
- draft nomination summaries and cargo narratives
- Tier 2:
- detect deviations from standard SPA policy library
- flag pricing mechanic triggers and timing constraints
- route workflows to owners based on triggers
- Tier 1:
- recommend accounting trigger treatments (IFRS 15/9) above thresholds
- recommend posting proposals only with approval-first
Critical controls
- Policy mapping: clause → accounting policy trigger → control → evidence
- No AI write-back into pricing or accounting fields without deterministic constraints
- Approval workflow required for deviations from standard SPA terms
- Decision packets stored for every trigger evaluation
LNG Step 1, Contract + SPA review, deviations, and accounting trigger mapping
Business process elements
- SPA clause review and deviations
- Accounting trigger mapping (IFRS 15, IFRS 9)
- Workflow approvals (commercial, legal, finance)
- Contract master updates in CTRM
Human touchpoints
- Legal reviews deviations vs. standard clauses
- Commercial approves economic deviations
- Finance approves accounting trigger interpretations
AI actions by tier
- Tier 3:
- extract clause text and map to standard library
- draft deviation summaries and approvals packet
- Tier 2:
- detect clause diffs and route workflows
- flag trigger conditions (variable consideration, derivatives, LC terms)
- Tier 1:
- recommend accounting treatments only with approval-first
- block any posting proposal until evidence is complete
Deterministic guardrails
- clause diff must reference approved library clause IDs
- policy mapping must point to specific accounting policy IDs
- SoD: clause reviewer cannot approve accounting treatment
Evidence logged
- SPA text hash + extracted clause refs
- trigger evaluation logs + policy versions
- approvals + timestamps + disposition + reason codes
LNG Step 2, Nominations, shipping plan, and terminal slotting
Business process elements
- Buyer nominations and cargo plan creation
- Terminal slot requests and confirmations
- Vessel nominations and logistics planning
- Constraint management (slots, capacity, windows)
Systems + integration
- CTRM cargo and nomination objects
- Terminal scheduling system
- Logistics feeds (vessel availability, ETA)
- Workflow approvals system
AI actions by tier
- Tier 3:
- draft nomination summaries and plan narratives
- Tier 2:
- rank feasible cargo plan options within constraints
- flag out-of-window nominations and route approvals
- Tier 1:
- no auto-confirmation of terminal slots without approvals
Deterministic guardrails
- slot window constraints and capacity checks
- approval required for out-of-window nominations
- rollback plan to manual scheduling if conflicts spike
Evidence logged
- nomination IDs + constraint checks + outcomes
- approval tasks + dispositions
- terminal slot confirmation IDs linked to decision packets
LNG Step 3, Loading, docs, provisional invoice, and risk posture
Business process elements
- Loading events and measurement (quantity, quality)
- B/L issuance and docs compilation
- Provisional invoice creation
- Risk posture updates and exposure monitoring
Systems + integration
- Terminal measurement systems
- Docs systems and validation
- CTRM shipment events
- SAP provisional billing
Human touchpoints
- Terminal ops validates measurement and load completion
- Docs team validates completeness before release
- Finance reviews provisional invoice proposals
AI actions by tier
- Tier 3:
- draft docs checklists and exception narratives
- summarize loading event changes
- Tier 2:
- detect doc completeness gaps and anomalies
- route exceptions to owners
- Tier 1:
- propose provisional invoice amounts only with approval-first
Deterministic guardrails
- measurement completeness and validation thresholds
- doc completeness as hard stop before release
- approval workflow for Tier 1 invoice proposals
Evidence logged
- loading event IDs + measurement report IDs
- doc IDs + validation outcomes
- invoice proposal logs + approvals + SAP doc links
LNG Step 4, In-transit monitoring, discharge, and final outturn reconciliation
Business process elements
- Voyage monitoring and ETA management
- Discharge events and final outturn quantity/quality
- Final invoice and settlement readiness
Systems + integration
- AIS/vessel tracking feeds
- Terminal discharge systems
- Docs systems (outturn reports)
- CTRM cargo events and pricing
- SAP billing and cash processes
AI actions by tier
- Tier 3:
- draft in-transit status narratives and exception notes
- Tier 2:
- detect ETA threats and suggest feasible options within constraints
- flag discharge variances and route owners
- Tier 1:
- recommend final outturn adjustment postings only with approval-first
Deterministic guardrails
- ETA and window constraints with escalation paths
- variance tolerance bands for outturn reconciliation
- approval required for any Tier 1 adjustment
Evidence logged
- tracking feed snapshots + hashes
- outturn report IDs + validation outcomes
- adjustment proposals + approvals + doc links
| DOCUMENT | REQUIRED | RECEIVED | VALIDATED | NOTES |
|---|---|---|---|---|
| Bill of Lading | ✓ | ✓ | ✓ | Clean, on board |
| Commercial Invoice | ✓ | ✓ | ✓ | Values match LC |
| Certificate of Origin | ✓ | ✓ | ✕ | Incorrect format |
| Packing List | ✓ | ✕ | ✕ | Not received |
| Quality Certificate | ✓ | ✕ | ✕ | Pending |
LNG Step 5, Settlement, cash application, and audit-grade evidence chain
Business process elements
- Final settlement and invoicing
- LC presentation and docs validation
- Cash receipt and application
- Close and audit evidence
Systems + integration
- CTRM settlement events
- SAP AR and cash application
- Bank statement feeds and LC systems
- Docs validation and storage
- Evidence store linked to postings
AI actions by tier
- Tier 3:
- draft LC presentation checklists and narratives
- compile evidence packs and completeness checks
- Tier 2:
- auto-route missing docs and exceptions
- auto-reconcile cash receipts within deterministic rules
- Tier 1:
- payment release or settlement adjustments require approval-first
Critical controls
- Doc completeness as hard stop before LC presentation
- SoD across settlements, finance, and treasury
- Reconciliation preview before SAP posting and cash application
- Audit trace for every decision packet
Accounting policy patterns I enforced: IFRS, US GAAP, mixed ledgers
- I treated accounting policy as code: policy → triggers → controls → evidence.
- IFRS 15: revenue recognition triggers were explicit and traceable.
- IFRS 9: derivative and hedge accounting triggers were explicit and traceable.
- US GAAP: equivalent triggers and controls mapped to the same evidence chain.
- Mixed ledgers: policy mapping chooses ledger rules, not humans on spreadsheets.
- Contract term triggers: payment terms, variable consideration, indexation, delivery points.
- Operational event triggers: load/discharge events, title transfer, measurement reports.
- Measurement triggers: quantity/quality/outturn vs tolerance bands.
- Pricing mechanic triggers: JCC linkage, S-curves, basis/curve selection, FX timing.
- All triggers must map to a control and a required evidence packet.
The minimum evidence chain I stored per AI decision
- Trigger ID and timestamp
- Inputs snapshot hash (data + docs references)
- Model version hash + prompt/config version
- Deterministic controls fired + outcomes
- Tier and execution stance (approval-first / green path / advisory)
- User action (approve/override/reject) + reason code
- Downstream transaction IDs (CTRM + SAP doc links)
- Monitoring signals (drift score, override rate, exception volume)
FMSB logic I encoded (simplified)
Different standards, same discipline: policy → control → evidence mapped for every AI decision.
My runbook: what breaks, how I contained it, how I proved it
I treat AI like a critical system. Incidents are expected. The question is how you contain and prove.
Incident type 1: data outage or stale feed (Tier 2 impact)
- Detection
- freshness SLA breach
- missing values in required fields
- reconciliation breaks increase
- Contain
- hold auto-exec paths
- switch to last-good snapshot if allowed
- notify data owner
- Recover
- replay decisions with corrected inputs
- validate reconciliations
- clear exception backlog
- Evidence
- data feed logs + hashes
- decisions held and why
- replay outcomes
Incident type 2: model drift or logic mismatch (Tier 1/2 impact)
- Detection
- drift score spikes
- override rate increases
- exception volume increases
- Contain
- freeze Tier 1 changes (approval-only)
- tighten Tier 2 green path constraints
- increase sampling review
- Recover
- recalibrate constraints or retrain model
- re-run scenario tests
- ship only with sign-off
- Evidence
- drift metrics
- sampling reviews
- sign-offs and version history
NIST’s AI Risk Management Framework focuses on managing AI risks and improving trustworthy use of AI systems. I use that mindset for drift management: measure, manage, govern.
Incident type 3: wrong posting proposal (Tier 1 impact)
- Detection
- posting validation fails
- reconciliation preview mismatch
- account mapping version mismatch
- Contain
- hard stop: no posting
- route to finance approver
- lock affected transaction IDs
- Recover
- correct mapping or rule logic
- re-run proposal and preview
- post only after approval
- Evidence
- decision packet + rule versions
- approvals + reason codes
- SAP doc linkage
Incident type 4: workflow bottleneck (Tier 2/3 impact)
- Detection
- approval queue backlog
- SLA breach for exception handling
- Contain
- re-route tasks to backup approvers
- tighten green path to reduce exceptions
- Recover
- clear backlog
- adjust constraints and policy rules
- improve routing logic
- Evidence
- queue metrics
- routing logs
- post-incident improvements
Reporting packs I shipped to committees (one page each)
- Board pack (one page):
- value delivery
- top risks and mitigations
- incidents and containment
- sign-offs
- Risk Committee pack (one page):
- Tier 1 changes approved and why
- Tier 2 green path rate, exceptions, overrides
- drift score and monitoring
- top control breaks
- Audit Committee pack (one page):
- evidence completeness rate
- reconciliation status
- SoD compliance metrics
- sampled decision packets (random)
Audit Committee pack (one page)
- Evidence completeness rate (all Tier 1, sample Tier 2)
- Reconciliation status (CTRM ↔ SAP ↔ bank/ops)
- SoD compliance (builder/approver/operator)
- Random sampled decision packets (with hashes and doc links)
- Exceptions and remediations

