Raw, Staging, Curated: Layers by Purpose

• Layers exist for reprocessing boundaries and contract boundaries, not for tidiness. A boundary is worth a layer when you would want to re-run everything after it without re-running everything before it, or when a group of consumers needs a stable shape that the layer above does not provide (Model Layering).
• Raw preserves what arrived, unmodified, so every later stage is reconstructable. Its promise is fidelity to delivery, not correctness — it contains duplicates, source-shaped names, and whatever the connector delivered including its mistakes (The Raw Landing Zone).
• Staging makes the data usable without deciding what it means: dedupe, cast types, rename to house conventions, handle deletes, apply nothing that a business person would recognise as a rule. Its promise is one row per entity with predictable types.
• Curated applies meaning: business rules, joins across sources, the analytical grain, the metric definitions. Its promise is a documented contract — grain, owner, freshness, known gaps — that consumers may build on (Dataset Documentation).
• The split matters most during an incident, because each boundary is a place to ask one question and get one answer. Is raw complete for the period? Is staging one row per entity? Is curated at the grain it claims? The first "no" is where the incident lives (Lineage Debugging).
• The names are conventions and they vary — raw/staging/curated, landing/base/marts, bronze/silver/gold, source/intermediate/reporting. They describe the same three jobs. Arguing about the names is a substitute for arguing about the boundaries (Medallion: One Naming Convention Among Several).

warehouse/
├── raw/                    ← what the connector delivered. append-only.
│   ├── raw_orders/         ← grain: one CDC change record
│   │   ├── _load_date=2026-03-13/
│   │   └── _load_date=2026-03-14/
│   └── raw_customers/
├── staging/                ← usable, not yet meaningful
│   ├── stg_orders          ← grain: one order, latest change, typed
│   └── stg_customers       ← grain: one customer
├── intermediate/           ← optional. shared joins, materialised once
│   └── int_orders_enriched
└── curated/                ← contract lives here. consumers read only this.
    ├── fct_orders          ← grain: one order. owner: revenue team.
    ├── dim_customer        ← grain: one customer, current
    └── revenue_daily       ← grain: one country-day (mart)

• Make raw immutable, append-only, partitioned by load time, and closed to consumers. Every property in that sentence is doing work: immutability makes it a reference, append-only makes it history, load partitioning makes reprocessing bounded, and the access restriction stops metrics being written at the source's grain (Data Access Control).
• Keep business logic out of staging entirely. The test is simple: if a non-engineer would recognise the rule as a business decision, it belongs in curated. A WHERE status <> 'test' in staging is a business rule wearing a technical disguise.
• Give every curated dataset a declared grain, an owner, a freshness expectation and a written list of what it does not include. An undocumented curated table is a staging table that consumers have been misled about (Data Ownership).
• Add a layer only when you can name the boundary it creates. "We want an intermediate layer" is not a reason; "these five models share a join that costs more than storing it" is (Compute Waste).
• Let the layer boundary be where tests live. Test raw for arrival completeness, staging for structural assumptions, curated for business assertions. Tests scattered without regard to layer end up asserting the same thing three times and the important thing nowhere.
• Materialise by read-to-build ratio rather than by layer. There is no rule that staging must be views and curated must be tables; there is only the arithmetic of how often each is read (Where the Transformation Actually Runs).

• Raw guarantees that what was delivered is retained and reprocessable. It guarantees nothing about completeness relative to the source, nothing about duplicates, and nothing about types (CDC Failure Modes and the Retention Deadline).
• Staging guarantees structure: one row per entity, conformed types, deletes represented. It deliberately guarantees nothing about business meaning, which is what makes it reusable by consumers who disagree about meaning.
• Curated guarantees its declared contract and nothing beyond it. A curated table with no declared grain guarantees nothing at all, whatever its name suggests.
• No layer guarantees the layer above it was complete. Completeness is a property you measure by reconciling against the source, and every layer inherits the gaps of the one before (Reconciliation).
• Publish atomicity is per dataset, so two curated tables built by the same run become visible at two different moments. A consumer joining them during that gap sees a state that never existed (Atomic Publish).