Master data Architecture

How it is built: the rows stay where they are.

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.

SAP S/4HANAreleased read interfacesOracle FusionREST · BICC · JDBCSalesforcesObjects APISnowflakewarehouseDatabricksUnity CatalogServiceNow · Workdaytables · web servicessource permission, as the readerthe source returns only what this person may seeLIMA FEDERATED ENGINEone plan across all sourcespushes filters and aggregates downjoins on the golden cross-referenceapplies the 12 platform layerscaches where latency needs it, labelledlogs every readgrids · pivots · APIs · SQL · agentseverything reads through the same engine
One engine reads the sources where they live. Each source checks the reader's own permission first, then Lima applies its twelve layers on top.
7
systems read in place: SAP S/4HANA, Oracle Fusion, Salesforce, Workday, ServiceNow, Snowflake, Databricks
connector library
0
copies of your source rows needed to start a domain
product
12
layers at which access is controlled, for read, write and delete
product
1
audit trail across every door: grid, pivot, API, SQL, agent
product
The three layers

Read, hold, serve

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.

Registered, then readableA source's objects list their rows the moment the connection is saved; the match rules preview live pairs as they are typed.
Where the rows live

Read in place, with a governed copy by exception

The choice is made per source, and the reason is recorded with it.

SourceHow Lima reads itWhen a governed copy is landed instead
SAP S/4HANA and ECCReleased read interfaces (CDS views, OData) and change capture; BAPIs and IDocs for the write-backDeep history for analytics, or a source system under load protection
Oracle Fusion and EBSFusion REST resources and business events; interface tables for EBS writesEBS estates where the interface is scheduled in batches
Salesforce, ServiceNow, WorkdayTheir published APIs, with the caller's own permission appliedAPI call limits that a working grid would exceed
Snowflake and DatabricksSQL against the conformed tables, with the filter pushed downAlready a copy: read directly
Files, portals and registriesScheduled fetch with the file kept as evidenceAlways 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.

One data bed

Reference data, hierarchies, dimensions, master records and transactions, with the keys enforced

This is the part that makes analytical questions and operational lookups answerable from the same model.

Reference datacountries · currencies · units · Incoterms · code listsHierarchiesproduct · customer · cost centre · plant · versions with datesDimensionstime · version · scenario · channelMaster datacustomers · products · suppliers · sites · accounts · employees (golden)Transactionssales orders · purchase orders · invoices · stock · forecasts · actualsforeign key · enforcedforeign key · enforcedforeign key · enforcedforeign key · enforcedWHAT THE KEYS GUARANTEEevery order names a customerthe bed knowsa cost centre must sitin exactly one place per hierarchy versiona currency on an invoicemust exist in the code lista forecast row must resolveto a real product and sitea merge of two customersre-points every order at onceone engine reads all five in one query, so a pivot on golden customers by month is one plan, one policy, one answer
The bed: reference data and hierarchies above, master records in the middle, transactions below, with the keys the platform enforces between them.

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.

Performance

How the design stays fast at enterprise volumes

Four mechanisms carry the load; each is described on the capability page that owns it.

MechanismWhat it doesWhere it is explained
Push-downFilters, sorts and aggregations are translated into the source's own query and executed there, so only the needed rows travelHigh-performance grids
Virtual scrollingA grid fetches the visible window and its neighbours, so a table of any size opens at onceHigh-performance grids
Materialisation by exceptionA golden view is materialised where latency or source load requires it, with the refresh and its freshness recordedImplementation styles
Cached lookupsThe headless lookup answers from the cross-reference and the surviving values, with related facts fetched on requestHeadless 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.

Explainable by construction

Every value carries where it came from and why it won

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.

address v112 Jan · SAP feedVAT verified03 Mar · portalmerge with CRM record19 Mar · steward P. Sharmapayment terms Net 4502 Apr · rule R-118e-mail refreshed15 May · agent, approvedas of 31 March: the record before the terms change, with the orders as they stood on 31 Marchno cap on history, no blind spots for rule-driven changes, and reads of sensitive columns are logged too
Every change is an entry; the point-in-time read on 31 March shows the record and its orders as they stood together.
Terms on this page

Read in placeThe rows stay in the system that owns them; Lima sends the filter and the columns, and the system returns the matching rows.
Push-downTranslating a filter, sort or aggregation into the source's own query language so the work happens where the data is.
The data bedThe one place where reference data, hierarchies, dimensions, master records and transactions sit with enforced keys between them.
MaterialisationStoring a computed golden view so reads are faster, with the refresh time and freshness recorded.
Write-backA change sent to the system of record through its released interface, with the acknowledgement stored beside the change.
Point-in-time readA read of the records and their transactions as they stood together on a chosen date.
Questions

What does Lima store, exactly?

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.

What happens when a source is offline?

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.

Does this need a lake?

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.

How does it fit the rest of the platform?

Master data is one capability of the Lima platform: the Backbone moves and lands data, SmartApps runs processes on the golden rows, and the connector library is shared. One security model and one audit trail cover all of them.

See your first domain built on your data

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.