Payments

Every authorisation is an event with a record behind it.

A payment is a state machine with a deadline. Every step writes a record, every record has a party, and the fraud decision has to happen inside the same few hundred milliseconds.

A payment is a state machine with a deadline — every step writes to one layer.

The story

A payment is a state machine with a deadline — every step writes to one layer.

Where it starts

Authorisation and settlement records

Requests, responses, clearing files and settlement positions. It is the first of 4 workloads running in Payments.

The question it raises

Explainable declines

The decision, the signal and the transaction trace come from one layer, so an explanation does not require a second system’s logs.

Why one question is hard

From Initiate to Dispute

Payments data moves through 5 stages — Initiate → Authorise → Clear → Settle → Dispute. The shapes in play are SQL, Graph, Time series, JSON / documents, and answering one question means reading across all of them.

What PLOMID contributes

Payments are a consistency problem with a relationship problem inside it. These are the parts that hold both.

The environment

Authorisations, clearing, settlement, routing and fraud signals.

Authorisation, clearing and settlement produce records at volume, with strict ordering and reconciliation requirements. The signals that decide whether a payment is genuine are time-ordered and relational. PLOMID keeps the transactional trace and the signals that judge it in one layer, so a decline can be explained from the same source that produced it.

Where the data goes to work

Questions money asks repeatedly.

Each one reads records, and where it must, the relationships between them — from the same layer, not an extract.

Explainable declines

The decision, the signal and the transaction trace come from one layer, so an explanation does not require a second system’s logs.

  • SQL

Reconciliation that closes

Clearing and settlement records are queried against the same transactional source that produced them.

  • Graph
  • Time series

Scheme performance

Latency and outcome measurements sit beside the counterparty records they belong to.

  • SQL

Dispute evidence

Case documents and the transactions they concern stay queryable together.

  • SQL
The data journey

How payments data reaches one layer.

Walk the path the data takes, from the environment that produces it to the questions it answers. Select a station, or a shape, to read each step.

A payment is a state machine with a deadline — every step writes to one layer.

Environment

The request

A payment initiated with instrument and party records.

SQL

Data models in play

The shapes, in one layer.

4 shapes carry this domain. Choose a stage to read the operation, or a shape to see every stage that handles it.

PLOMID · Payments initiate · authorise · clear · settle · dispute Select a stage
Stage

Initiate

Payment request, instrument and party records

SQL

Workload map Payments workload map. Every shape on it is a surface of the layer, and each stage names the part of the operation it carries.
  • SQL Records, keys and joins
  • Graph Relationships and traversal
  • Time series Measurements and events in time order
  • JSON / documents Documents and nested objects
One environment · many workloads

What runs against payments data.

4 workload families over one set of shapes. Choose one to see what it moves and where it lands.

Requests, responses, clearing files and settlement positions.

  • Planned once against the layer, not once per store
  • Read beside the records it shares a key with
  • Persisted under one storage contract
Workload architecture

From posting to traversal.

Records first, relationships where the question needs them — every path a request can take through this data.

Payments · workload architecture
Workloads

What runs against this data.

  • Authorisation and settlement records
  • Routing and performance signals
  • Merchant and counterparty records
  • Dispute and case documents
Data models

The shapes those workloads read and write.

  • SQL
  • Graph
  • Time series
  • JSON / documents
The layer

One path from a request to the data it names.

  • Planning Predicates narrow the work before it runs
  • Execution Records, fields and windows answered together
  • Transactions Readers and writers do not block each other
Surfaces

How the work reaches the layer.

  • SQL surface The query language the layer is documented in
  • Applications Services and jobs writing and reading as they run
  • Analytics & AI clients The same layer, the same access path
Deployment & residency

Where this data is allowed to run.

Latency budgets are tight, so proximity between the decision and its data is part of the design conversation.

Deployment, residency and control
What you build next

Transactional Systems

Application records with consistent reads and writes while reports run against them.

If Explainable declines is your question, start here.