No extract to reconcile
The reporting read and the application read are the same data, so a discrepancy is a bug rather than a schedule.
Transactional Systems
Writes, reads and state that stay consistent.
The workload a database has always been asked for: keys, joins, transactions, and the same rows serving both the application and the analysis.
A transaction from the request to the durable row — and the report that reads it while it runs.
Application records with consistent reads and writes while reports run against them.
Transactional workloads need point lookups, ordered ranges and consistent reads and writes. PLOMID carries them over the same storage contract as every other shape, so a system of record and its reporting do not have to be two systems.
A transaction from the request to the durable row — and the report that reads it while it runs.
Environment
The transaction
A client request that has to post exactly once, with consistency the business can rely on.
SQL
Two estates, drawn.
The same shapes, held two ways. The difference is not the storage, it is where the agreement between them lives.
Separate systems Copies kept in step
One layer One plan · one contract
What this workload moves.
Every shape below is a surface of the layer, not a format to be converted into one. They are read and written together.
- SQL Records, keys and joins
- JSON / documents Documents and nested objects
How the workload reaches the data.
The models this workload names, the path a request takes through them, and the surfaces that speak to the layer.
Transactional Systems · architecture
Workload
The shape of the work itself.
- Write
- Read
- Report
- Recover
Data models
The models this workload names.
- SQL
- JSON / documents
The layer
One path from a request to the data it names.
- Planning Predicates narrow the work before it runs
- Execution Rows, fields and windows answered together
- Transactions Readers and writers do not block each other
Surfaces
How the workload reaches the layer.
- SQL surface The query language the layer is documented in
- Applications Services and jobs reading and writing as they run
- Analytics & AI clients The same layer, the same access path
The work, stage by stage.
Choose a stage to read what happens there, or a shape to see every stage that handles it. Nothing on the map is a private interface.
PLOMID · Transactional Systems write · read · report · recover Select a stage
Stage
Write
Postings, updates and inserts from the application
SQL
01
Write
Postings, updates and inserts from the application
- SQL
02
Read
Point lookups and ordered ranges through indexes
- SQL
03
Report
Aggregates run over the same rows
- SQL
- JSON / documents
04
Recover
One durability and recovery path
- SQL
What changes when the data is in one place.
Stated as properties of the system rather than as results we cannot measure for you.
Operational reporting in place
Aggregates run over live tables instead of a nightly copy.
Documents beside rows
Fields that change shape stay in the same statement as the rows they belong to.
Bounded reads
Indexes and access paths decide what a query touches before a page is read.
What this is built on.
A transactional workload is judged on consistency and boundaries. These are the parts that provide them.
- Snapshot reads under continuous writes → Readers and writers do not block each other, which is what makes a telemetry feed and an application share one system.
- Predicates narrow the work → Indexes and access paths decide what a query touches before a page is read, so operational reads stay bounded.
- One data layer → Rows, documents and time-ordered events live in one system, so a question is asked once instead of once per store.
- One plan per request → A request is planned once against the layer rather than per system, which is where cross-system glue usually accumulates.
Workloads that sit beside this one.
Where this shows up.
Derived from the industry pages that reference this solution, so the two directions of the relationship always agree.
- Banking → Accounts, transactions, counterparties and the relationships between them.
- Payments → Authorisations, clearing, settlement, routing and fraud signals.
- Fintech → Ledgers, balances, product events and the relationships behind them.
- Enterprise → Systems of record, documents, workflow events and reporting in one organisation.
- Retail → Transactions, stock, stores, promotions and customer behaviour.
- E-commerce → Orders, catalogues, inventory, sessions and fulfilment events.
- Sovereign Infrastructure → Systems that must run inside a boundary, under a known operator.