Microsoft Fabric

Bronze, Silver, Gold in Microsoft Fabric: A Practical Medallion Architecture Guide

A practical guide to Bronze, Silver, and Gold layers in Microsoft Fabric, including what belongs in each layer, how data should move between them, Lakehouse and Warehouse choices, quality rules, and common implementation mistakes.

By JaviPublished 17 min readIntermediate

On this page

Bronze, Silver, and Gold are simple names for an important idea:

Data should become more trustworthy, structured, and useful as it moves through your platform.

In Microsoft Fabric, this is commonly implemented as a medallion architecture.

Microsoft describes the three layers as:

  1. BronzeRaw
  2. SilverEnriched / validated
  3. GoldCurated
The three Medallion layers

The names are easy.

The design decisions are not.

The real questions are:

  • What exactly belongs in Bronze?
  • What should be rejected or quarantined in Silver?
  • Should Gold be a Lakehouse or Warehouse?
  • Should each layer have its own Lakehouse?
  • Where should business logic live?
  • How do you make the flow replayable?
  • How do you avoid turning Silver into another raw zone?
  • How do you prevent Gold from becoming a copy of Silver?

This article focuses on those practical decisions.

The purpose of the medallion pattern

The purpose of medallion architecture is not to create three folders with different names.

It is to separate concerns.

A useful mental model is:

  1. BronzePreserve what arrived
  2. SilverMake the data trustworthy
  3. GoldMake the data useful for consumers
What each layer is for

Each layer answers a different question.

Bronze asks:

What did the source send us?

Silver asks:

What data do we trust and how should it be standardized?

Gold asks:

What shape do analysts, reports, APIs, or downstream products actually need?

That separation is the value of the pattern.

Bronze: preserve the source

Bronze should represent the source as faithfully as practical.

The goal is not to make the data pretty.

The goal is to preserve a recoverable copy of what arrived.

Typical Bronze content includes:

  • CSV;
  • JSON;
  • Parquet;
  • copied database extracts;
  • CDC output;
  • API payloads;
  • raw event data;
  • source-system snapshots.

A Bronze layer should make it possible to answer:

What did we receive?
When did we receive it?
From which source?
Which file or batch did it come from?
Can we replay it?

What should Bronze avoid?

Bronze should generally avoid heavy business transformation.

For example, avoid immediately:

joining customers to sales
mapping business categories
calculating revenue KPIs
removing source attributes
aggregating by day

Those changes make it harder to reconstruct the original input.

Bronze is most valuable when it remains a reliable point of replay.

Bronze does not mean “unmanaged”

Raw does not mean chaotic.

You still need operational metadata.

Useful fields or metadata can include:

source_system
source_file
ingestion_timestamp
batch_id
pipeline_run_id
tenant_id
source_modified_timestamp

For multi-tenant platforms, that metadata is especially important.

A record may be technically identical across tenants but operationally belong to a different source context.

Example Bronze structure

Suppose you ingest sales from multiple clients.

A file-oriented Bronze layout might be:

Files/
└── bronze/
    └── sales/
        ├── tenant=client_a/
        │   └── ingestion_date=2026-10-09/
        └── tenant=client_b/
            └── ingestion_date=2026-10-09/

Or you may land data directly into Delta tables.

The right choice depends on source format, replay requirements, data volume, and downstream processing. If Delta’s append, overwrite and MERGE behavior is new to you, Delta Tables in Microsoft Fabric for SQL Server Engineers covers it.

The key principle is that Bronze should preserve lineage back to the source.

Silver: make the data trustworthy

Silver is where raw data becomes reusable data.

This is usually where you:

  • validate schemas;
  • standardize types;
  • normalize dates;
  • standardize currencies or codes;
  • deduplicate;
  • handle nulls;
  • resolve data-quality issues;
  • join reference data;
  • apply conformed naming;
  • quarantine invalid records.

Microsoft describes Silver as the enriched layer where data is cleaned, standardized, and deduplicated before consumption.

Silver is often the most important engineering layer because it becomes the reusable foundation for multiple downstream products.

Silver should represent trusted detail

A common mistake is to aggregate too early.

Silver should usually retain useful detail.

For example:

  1. BronzeRaw sales events
  2. SilverValidated sales transactions
  3. GoldDaily merchant revenue
Keep detail in Silver

If you aggregate directly in Silver, you may lose reusable detail that another downstream workload needs later.

Think of Silver as:

trusted, standardized, reusable detail.

Example Silver transformation

Imagine this Bronze input:

sale_id      = "A123"
merchant_id  = "0042"
amount       = "19.95"
sale_date    = "10/09/2026"
currency     = "usd"

Silver might standardize it to:

sale_id      STRING
merchant_id  INT
amount       DECIMAL(18,2)
sale_date    DATE
currency     STRING = "USD"

It might also reject rows where:

sale_id is null
amount cannot be parsed
merchant_id is unknown
sale_date is invalid

That is a meaningful quality boundary.

Quarantine invalid data instead of silently deleting it

A mature Silver layer should not silently discard invalid records.

Instead, consider a quarantine pattern:

  1. Bronze
  2. Validate
    • valid
      Silver
    • invalid
      Quarantine
Quarantine pattern

A quarantine record can include:

original payload
validation rule
error code
error message
batch_id
source_file
ingestion_timestamp

This allows operations teams to investigate bad data without losing it.

Silver is where conformance happens

If several sources represent the same business concept differently, Silver is usually where you normalize them.

Example:

Source A → merchant_id
Source B → advertiser_id
Source C → account_code

Silver can map them into a common concept:

merchant_key

This is where a multi-source platform begins to create a stable enterprise model.

Gold: optimize for consumption

Gold exists for consumers.

That may include:

  • Power BI semantic models;
  • dashboards;
  • reports;
  • APIs;
  • data products;
  • ML features;
  • operational exports;
  • downstream applications.

Gold should be shaped around use cases.

Typical Gold structures include:

  • star schemas;
  • fact tables;
  • dimension tables;
  • aggregates;
  • business summaries;
  • KPI tables;
  • serving tables.

Microsoft’s Fabric guidance describes Gold as the curated layer intended for reporting and analytical consumption.

Example Gold model

From a trusted Silver sales table:

Silver.sales_transaction

you might create:

Gold.fact_sales
Gold.dim_merchant
Gold.dim_date
Gold.daily_merchant_revenue
Gold.customer_lifetime_value

The important point is that Gold has a consumer purpose.

If a Gold table exists only because “Gold is required,” it probably should not exist.

Bronze, Silver, Gold example end to end

Imagine an e-commerce platform.

Bronze

sales.json
customers.csv
inventory.csv

Preserved as received.

Silver

sales_clean
customers_conformed
inventory_validated

Changes include:

  • type conversion;
  • duplicate removal;
  • data-quality checks;
  • date normalization;
  • test-record removal;
  • customer matching.

Gold

daily_sales_summary
customer_lifetime_value
inventory_forecast_input
merchant_performance

These are shaped for business consumption.

That general progression matches the practical Fabric examples Microsoft uses in its medallion guidance.

Should each layer have its own Lakehouse?

Microsoft recommends keeping medallion layers separated, and common Fabric patterns use a Lakehouse for each layer or Lakehouses for Bronze and Silver with a Warehouse for Gold.

A clean architecture can look like:

  1. lh_bronze
  2. lh_silver
  3. lh_gold
One Lakehouse per layer

This gives strong separation.

Benefits include:

  • clearer ownership;
  • easier access control;
  • cleaner lifecycle management;
  • reduced accidental cross-layer writes;
  • easier environment promotion.

But it is not the only possible design.

When a single Lakehouse can make sense

For smaller workloads, a single Lakehouse with schemas can be simpler:

SalesLakehouse

bronze.*
silver.*
gold.*

Fabric also supports medallion-style flows within one Lakehouse, including materialized lake views for multi-stage transformations.

This can reduce operational overhead.

The tradeoff is weaker physical separation between layers.

The choice should depend on:

  • security boundaries;
  • team ownership;
  • workload scale;
  • deployment model;
  • operational complexity.

Do not create three Lakehouses only because a diagram showed three boxes.

Lakehouse or Warehouse for Gold?

Gold does not have to be a Lakehouse.

Microsoft’s current reference guidance explicitly supports:

    1. Bronze
    2. Lakehouse
    1. Silver
    2. Lakehouse
    1. Gold
    2. Warehouse
Lakehouse and Warehouse per layer

for SQL-first analytical serving patterns.

This can make sense when Gold consumers are heavily relational and SQL-oriented.

For example:

  1. BronzeRaw files / Delta
  2. SilverClean Delta tables
  3. Gold Warehouse
    • fact tables
    • dimensions
    • reporting views
    • stored procedures
    • T-SQL consumption
SQL-first Gold serving

This is often a strong fit for BI-centric platforms.

A practical decision rule

Use a Lakehouse for Gold when:

  • Spark and open Delta access matter;
  • data science consumes the layer;
  • file-level interoperability matters;
  • the workload remains lake-centric.

Use a Warehouse for Gold when:

  • the serving model is relational;
  • T-SQL is the primary interface;
  • star schemas dominate;
  • BI/reporting teams own the consumption layer.

The architecture can mix both.

Fabric is designed to support that flexibility.

Data quality belongs between layers

A layer transition should have an explicit contract.

For example:

  1. Bronze
  2. Silver
Bronze to Silver

might require:

schema valid
business key present
timestamp valid
numeric fields parse correctly
duplicates resolved
reference values recognized

Then:

  1. Silver
  2. Gold
Silver to Gold

might require:

conformed dimensions available
required joins valid
business rules satisfied
aggregation complete
no orphan facts

Each transition should make the data more trustworthy.

Make transformations replayable

A strong medallion implementation should support replay.

Suppose a Silver business rule changes.

You should be able to rebuild Silver from Bronze without going back to the source system.

Likewise, if Gold logic changes, you should be able to rebuild Gold from Silver.

That gives you:

source independence
repeatability
recoverability
auditable transformations

This is one of the strongest reasons to preserve Bronze correctly.

Incremental processing matters

A medallion architecture can fail operationally if every layer always performs full reloads.

At scale, consider:

  • watermarks;
  • CDC;
  • partition-based processing;
  • merge-based updates;
  • batch IDs;
  • file tracking;
  • checkpoint state.

For example:

  1. BronzeNew files only
  2. SilverProcess changed partitions
  3. GoldRefresh affected aggregates
Incremental processing per layer

The logical architecture may be simple while the execution strategy is incremental.

Incremental Loads in Microsoft Fabric works through this end to end: bounded watermark windows, deletes, late data, and recomputing only the affected Gold slices. Incremental writes also fragment each layer’s tables over time; Delta Table Maintenance in Microsoft Fabric covers when compaction helps.

Idempotency across layers

Every layer transition should answer:

What happens if the same batch runs twice?

For Bronze, duplicates may be preserved intentionally if they reflect source delivery.

For Silver, duplicate business events usually need deterministic handling.

For Gold, aggregations must avoid double counting.

A useful design is:

batch_id
source_key
business_key
load_timestamp

combined with deterministic merge or overwrite rules.

Logging should follow the data

Track each run through the layers.

For example:

run_id
pipeline_name
source
layer
table
rows_read
rows_written
rows_rejected
started_at
ended_at
status

Then an incident can be traced:

  1. Gold wrong
  2. Which Silver batch?
  3. Which Bronze input?
  4. Which source file/run?
Tracing an incident back through the layers

That is operational lineage.

Security can differ by layer

Bronze may contain:

  • raw PII;
  • source-specific identifiers;
  • unmasked data;
  • operational metadata.

Silver may contain cleaned but still sensitive detail.

Gold may expose only approved analytical fields.

Fabric security guidance explicitly shows scenarios where Bronze/Silver access is restricted to engineering teams while Gold is exposed to authorized analysts and business users.

This is another reason to treat layers as real trust boundaries rather than naming conventions.

Avoid business logic in Bronze

This deserves repetition.

Do not make Bronze depend on today’s interpretation of the business.

If a business definition changes tomorrow, you want to be able to replay from what actually arrived.

Good Bronze:

source customer_status = "A"

Bad Bronze transformation:

customer_status = "Active Premium Customer"

unless that is literally what the source sent.

Interpretation belongs later.

Avoid copying Bronze into Silver without adding trust

Another common anti-pattern:

  1. Bronze table
  2. COPY
    Silver table
Anti-pattern: Bronze copied into Silver

with no real validation or standardization.

That creates another storage layer without creating value.

Silver should represent a measurable quality improvement.

Avoid copying Silver into Gold without a consumer model

Likewise:

  1. Silver.sales
  2. COPY
    Gold.sales
Anti-pattern: Silver copied into Gold

usually adds little value.

Gold should represent a serving model.

For example:

  1. Silver.sales_transaction
    • Gold.fact_sales
    • Gold.daily_sales
    • Gold.merchant_performance
Gold as a serving model

Gold is where data becomes easy to consume.

Do not force every dataset through every layer

Not every dataset needs three physical copies.

Reference data, small configuration tables, or already-curated upstream datasets may not need identical treatment.

The pattern is a design tool, not a law.

Use it where the separation creates value.

Materialized lake views can simplify medallion transformations

Fabric now supports materialized lake views for declarative multi-stage Lakehouse transformations.

They can express Bronze-to-Silver-to-Gold dependencies while Fabric manages refresh order and persisted results.

This is useful when the transformation graph fits a declarative pattern.

It does not eliminate the need to define:

  • layer responsibilities;
  • quality rules;
  • ownership;
  • serving contracts.

Technology can orchestrate the transformations.

Architecture still has to define what they mean.

A multi-tenant example

Consider a platform serving many customers.

Bronze

tenant_id
source_file
source_row
ingestion_timestamp
raw payload

Silver

tenant_id
legacy_merchant_id
merchant_key
sale_id
sale_timestamp
amount
currency

Rules:

  • validate tenant;
  • normalize merchant identity;
  • remove duplicate events;
  • quarantine malformed rows;
  • convert types;
  • standardize currencies.

Gold

fact_sales
dim_merchant
daily_merchant_sales
monthly_tenant_summary

This creates a stable serving layer while preserving source differences upstream.

A practical Fabric architecture

One possible design:

  1. Sources
    • SFTP
    • APIs
    • SQL databases
    • files
  2. Fabric Data Factory
  3. Bronze Lakehouse
  4. validation / standardization
    Silver Lakehouse
  5. business model / aggregation
    Gold Warehouse
  6. Consumers
    • Power BI
    • APIs
    • reports
    • exports
A practical Fabric Medallion architecture

That is not the only correct architecture.

It is a useful starting point when you have mixed ingestion, Spark transformation, and SQL/BI consumption.

Layer ownership checklist

Bronze

Ask:

  • Can I reconstruct what the source sent?
  • Is lineage preserved?
  • Can I replay?
  • Is ingestion metadata present?
  • Did I avoid premature business logic?

Silver

Ask:

  • Are schemas standardized?
  • Are keys validated?
  • Are duplicates handled?
  • Are invalid rows quarantined?
  • Are business entities conformed?
  • Is this reusable detailed data?

Gold

Ask:

  • Who consumes this?
  • What business question does it support?
  • Is the grain explicit?
  • Are dimensions and facts clear?
  • Is it optimized for the consumer?
  • Can it be rebuilt from Silver?

Final thoughts

Bronze, Silver, and Gold are useful because they create boundaries.

Bronze preserves evidence.

Silver establishes trust.

Gold creates usability.

In Microsoft Fabric, those boundaries can be implemented with multiple Lakehouses, schemas inside a Lakehouse, a combination of Lakehouse and Warehouse, or newer declarative mechanisms such as materialized lake views.

The right implementation depends on scale, security, ownership, and consumer needs.

The most important rule is not:

Always create three layers.

It is:

Every layer should have a clear purpose and make the data more useful without destroying the ability to understand where it came from.

Tags

  • Microsoft Fabric
  • Medallion Architecture
  • Data Architecture