skip to content

Is a hybrid of Inmon's integration layer and Kimball star marts a real architecture?

level: seniorimportance: should knowfreq 44%

answer

  1. Two separable decisions, one good answer each
  2. Reconcile once below, serve dimensionally above
  3. Which school gives the layer, which the cadence?
  4. Diagnostic: does the middle layer reconcile anything?
  5. Thickness should follow how much sources disagree

basics

~20 s

Yes, and it is the common shape today: raw landing, a reconciled integration layer built once, and dimensional star marts published on top for consumption. It buys inherited definitions plus a query surface users can navigate, at the cost of maintaining two models.

solid answer

~50 s

It is not a fudge — it is what most platforms converge on. Raw data lands and is retained; an integration layer reconciles identities, codes and history once; **star schemas are published on top** because that is what BI tools and business users navigate well. Structurally it is the top-down shape: the marts are dependent, so they inherit definitions rather than inventing them. What it borrows from bottom-up is **delivery order** — you build only the integration one business process needs, publish its star, and widen the integration layer as the next process arrives, instead of modelling the whole enterprise before shipping anything. The costs are honest ones. Two models to maintain, every attribute travelling through both, and a real risk the middle layer becomes a pass-through nobody can justify. The test is whether it does actual reconciliation work; if each mart reads one source unchanged, the layer is ceremony.

code

text · 6 lines
text
raw.orders_crm        raw.orders_erp        raw.customer_web
        \                    |                    /
         +--- integration: customer, order (reconciled, historized)
                              |
                +-------------+--------------+
           dim_customer   fact_orders    fact_shipments   <- published stars

go deeper

for a junior

Recall the three-layer shape — raw landing, a reconciled integration layer, dimensional marts on top — and that users query the marts rather than the layers beneath.

for a middle

Explain which school contributes which part: the integration layer and dependent marts come from the top-down design, the ship-one-process-at-a-time cadence from the bottom-up one.

for a senior

Demonstrate you have seen it fail. Name the pass-through middle layer, marts that bypass it under deadline, and duplicated business logic, and say how you detect and prevent each.

for a principal

Own the sizing decision. Argue how thick the integration layer should be from the actual conflict between sources and the number of consumers, and set the rule about which layer owns which kind of logic.

## What the hybrid actually is The common modern platform shape is three layers: 1. **Raw / landing** — source data captured as it arrived, retained, not reinterpreted. Its value is that any downstream mistake can be corrected by reprocessing rather than by re-extracting from a system that may no longer hold the history. 2. **Integration** — one reconciled representation of the business. Identity resolution, code standardization, deduplication and history capture happen here, once. Modelled around enterprise entities rather than around any report. 3. **Publish / marts** — dimensional star schemas per business process, consumed by BI tools, notebooks and semantic definitions. That is the top-down architecture's skeleton with the bottom-up delivery cadence layered onto it. The marts are dependent — they read the integration layer, not the sources — so they inherit definitions. But you do not build the whole enterprise model first; you build the slice the current business process needs, publish its star, and widen as the next process arrives. ## Why it wins in practice **The two schools were optimizing different layers.** One argued about where reconciliation belongs; the other argued about what the consumption surface should look like. Those are separable decisions, and the hybrid takes the good answer to each: reconcile once upstream, serve dimensionally downstream. **Storage economics changed the argument.** The original objection to an extra layer was that copying data was expensive and every copy was another thing to keep in sync. Retaining raw and materializing an intermediate layer is now cheap enough that the argument is about maintenance effort, not disk. **Reprocessing removes the fear of publishing early.** With raw retained, a wrong grain or a missed business rule is a rebuild, not a data-loss incident. That makes it safe to ship an early mart, which was the bottom-up approach's main advantage, without the usual price of unreconciled numbers. ## Where hybrids go wrong **The pass-through middle layer.** The commonest failure: the integration layer contains one lightly-renamed model per source table, doing no reconciliation at all. It costs maintenance, adds latency, and buys nothing — the reconciliation just moved into the marts, where it duplicates. The diagnostic question is simple: *does anything in this layer combine or reconcile two sources?* If not, either give it that job or delete it. **Modelling the enterprise before shipping anything.** The other failure is adopting the top-down layer *and* the top-down delivery order, which reinstates the long silence before the first report. The hybrid's whole point is that the integration layer can be grown incrementally. **Two places to change one attribute.** Real and unavoidable. A new attribute travels through the integration model and then the dimension. Teams manage it with generated boilerplate, tests at both layers, and by being strict that business logic lives at exactly one layer — reconciliation below, presentation shaping above. When the same rule is implemented in both, the layers drift. **A mart that bypasses the layer.** Under deadline someone points a mart straight at a source. It works, and it quietly reintroduces the divergence the architecture exists to prevent. Make the dependency a rule the build enforces rather than a convention. ## Choosing how thick the middle should be The integration layer earns its keep in proportion to how much sources disagree. Many overlapping systems describing the same customers, post-merger consolidation, regulated reporting where reconciliation is auditable — thick layer, obviously worth it. One authoritative source per subject area and few consumers — a thick layer is ceremony, and a thin cleaning step feeding stars is the honest design. The mistake is picking the thickness from a reference diagram rather than from how much reconciliation the sources actually require. Note also that the integration layer does not have to be strictly normalized. Some organizations use another integration-oriented modelling style there while still publishing stars for consumption; the architectural role is what matters — reconcile once, upstream of publication. ## Answering in an interview Say yes, describe the three layers, and be explicit about which school contributes what: the integration layer and the dependent marts come from the top-down design, the incremental per-process delivery from the bottom-up one. Then show judgment by naming the failure modes — pass-through middle layer, marts that bypass it, duplicated logic — and how you would size the middle layer for the sources in front of you. Candidates who present the hybrid as a compromise sound uncertain; candidates who present it as two separable decisions answered independently sound like they have built one.

  • How do you tell whether your integration layer is earning its keep?
    Ask whether anything in it reconciles or combines more than one source. A layer of one renamed model per source table is a pass-through: it adds maintenance and latency while the real reconciliation happens redundantly in each mart. Either give it identity resolution, code standardization and history capture, or remove it and clean in staging.
  • If the marts are dependent on an integration layer, why not let BI tools query that layer directly for ad-hoc work?
    Because it is modelled for absorbing change, not for answering questions — many joins, entity names rather than business language, and no declared grain. Ad-hoc users will write subtly wrong queries and get numbers that disagree with the marts. If ad-hoc demand is real, publish a mart for it rather than opening the plumbing.
  • Does the integration layer have to be normalized?
    No. Its architectural job is to reconcile sources once, upstream of publication; the modelling style used to do that is a separate choice. Some organizations use a normalized enterprise model, others an integration-oriented style built around business keys and change history. Either way, dimensional stars are still published on top for consumption.

saying these in an interview costs you the question

  • Calls the hybrid a compromise with no clear rationale
  • Keeps a middle layer that only renames source tables
  • Implements the same business rule in both layers
  • Lets urgent marts read sources directly, bypassing integration
  • Sizes the integration layer from a diagram, not from source conflict

context