Lima assembles golden records from rows read in the systems that own them, holds the master data, hierarchies, reference data and transactions in one data bed with the keys enforced, and serves the result through one policy to grids, pivots, APIs, SQL and agents.
Every capability page sits in one of these three layers; the layers are the whole architecture.
The six stages a domain goes through map onto the three layers: Connect reads, Resolve and Structure and Govern hold, Serve and Analyse serve.
Read. A source is registered once, with its released read interface and its credentials. From that moment its objects show their rows: Lima sends the filter and the columns it needs, the source applies its own permissions, and the matching rows come back. The match runs on those live rows, so a domain is ready on the day the systems are connected.
Hold. What Lima stores is the agreed part: the golden records' surviving values, the cross-reference of source keys, the hierarchies and their versions, the reference data, the rules and the audit trail. The source rows stay in the source. This keeps the stored volume small and the storage explainable, and it is why a correction in a source is visible at the next read.
Serve. One query engine answers every door: the steward's grid, the pivot, the REST and SOAP services, the SQL interface, the agent endpoint. The rules, the twelve security layers and the audit trail attach to the engine, so a value masked in the grid is masked in the API answer and in the SQL result.
The choice is made per source, and the reason is recorded with it.
| Source | How Lima reads it | When a governed copy is landed instead |
|---|---|---|
| SAP S/4HANA and ECC | Released read interfaces (CDS views, OData) and change capture; BAPIs and IDocs for the write-back | Deep history for analytics, or a source system under load protection |
| Oracle Fusion and EBS | Fusion REST resources and business events; interface tables for EBS writes | EBS estates where the interface is scheduled in batches |
| Salesforce, ServiceNow, Workday | Their published APIs, with the caller's own permission applied | API call limits that a working grid would exceed |
| Snowflake and Databricks | SQL against the conformed tables, with the filter pushed down | Already a copy: read directly |
| Files, portals and registries | Scheduled fetch with the file kept as evidence | Always landed, since the source keeps no queryable state |
Where a copy is landed, the Lima Backbone lands it under the same keys, security and audit as the rest, and Lima reads it there. The Backbone pages cover the movement; the federated display page covers the choice per source and what the reader sees in each case.
This is the part that makes analytical questions and operational lookups answerable from the same model.
Referential integrity is enforced at the platform, so a transaction that refers to a merged customer follows the merge, a hierarchy node that loses its parent is caught at validation, and a code value in use is protected from deletion. These are the guarantees that make a pivot on golden dimensions trustworthy.
Because the transactions sit beside the master records, three things become single queries: a pivot of revenue by golden customer and month, a business rule over a total (credit exposure across open orders and invoices), and a drill-down from a pivot cell to the source rows behind it.
The bed is described in full on the data bed page, with the key types, the integrity checks and what happens to transactions when a merge or an unmerge runs. Rules over totals and drill-downs are the two capabilities that depend on it most directly.
Four mechanisms carry the load; each is described on the capability page that owns it.
| Mechanism | What it does | Where it is explained |
|---|---|---|
| Push-down | Filters, sorts and aggregations are translated into the source's own query and executed there, so only the needed rows travel | High-performance grids |
| Virtual scrolling | A grid fetches the visible window and its neighbours, so a table of any size opens at once | High-performance grids |
| Materialisation by exception | A golden view is materialised where latency or source load requires it, with the refresh and its freshness recorded | Implementation styles |
| Cached lookups | The headless lookup answers from the cross-reference and the surviving values, with related facts fetched on request | Headless API |
On the showcase estate the headless lookup answers in 84 ms at the median, and a grid over 41,800 supplier records with four sources joined opens in about two seconds. Both figures are showcase measurements, labelled as such; a production figure depends on your sources and network.
This is what makes the architecture defensible in an audit and teachable to a steward.
Each surviving value on a golden record carries four things: the source record it came from, the rule that chose it, the time it was chosen and the person or process that approved it. The grid shows the first of these as a coloured edge on the cell, and the cell display page shows the rest on hover.
A merge keeps both source records and the evidence that joined them, so an unmerge restores the previous state and the transactions follow. Every change and every sensitive read is an entry in the append-only ledger, and a question 'as it stood on 31 March' reads the records and their transactions together as of that date.
The surviving values of the golden records, the cross-reference of source keys, the hierarchies and versions, the reference data, the rules, the security model and the audit trail. Source attributes beyond the surviving values and the transactions are read at query time, apart from what is deliberately materialised.
The stored part stays readable and the answer states which sources were reachable, with the freshness per source. The write-back queues and retries, and the acknowledgement is stored when it arrives.
A lake is useful for deep history and heavy analytics, and Lima reads Snowflake and Databricks as first-class sources. A domain can be built and served with the ERP and the CRM alone.
Bring two systems that hold the same customers, suppliers or materials. In one working day we connect them, run the match on live rows, review the queue with your steward and publish the first golden view with its API.