Wat is Medallion Architecture?

In de moderne datawereld worden organisaties overspoeld met enorme hoeveelheden ruwe data uit tientallen bronnen: ERP-systemen, API's, IoT-sensoren, SaaS-platformen en meer. Het ordenen, transformeren en beschikbaar stellen van al deze data op een betrouwbare, schaalbare manier is een van de grootste uitdagingen voor data engineers in 2026. De Medallion Architecture — ook wel bekend als het Bronze-Silver-Gold patroon — is dé referentiearchitectuur die hier een antwoord op biedt.

Oorspronkelijk gepopulariseerd door Databricks binnen het Lakehouse-concept, heeft het patroon inmiddels zijn weg gevonden naar Microsoft Fabric, het uniforme data-analyseplatform van Microsoft dat in 2023 werd gelanceerd en in 2025-2026 explosief is gegroeid in adoptie. Fabric combineert Data Factory, Synapse, Power BI en meer in één platform — met OneLake als de centrale opslag. Dat maakt het bij uitstek geschikt voor een Medallion-aanpak.

In 2026 is dit patroon relevanter dan ooit. Met de opkomst van AI-workloads, real-time streaming en steeds strengere datakwaliteitseisen van compliance-afdelingen, biedt een goed geïmplementeerde Medallion Architecture in Microsoft Fabric de fundering voor betrouwbare data producten — van dashboards tot ML-modellen.

De Drie Lagen in Detail

Dataflow door de Lagen

Medallion Architecture in Microsoft Fabric

Microsoft Fabric biedt een unieke infrastructuur voor het implementeren van Medallion Architecture. Het platform bestaat uit meerdere workloads die naadloos samenwerken op OneLake — één gedistribueerde opslag voor de hele tenant. Je hoeft data niet meer te kopiëren tussen systemen: alle Fabric-componenten lezen en schrijven naar dezelfde Delta Parquet-bestanden.

Aanbevolen Fabric-componenten per Laag

Praktische Codevoorbeelden

Hieronder vind je realistische PySpark-notebooks die je direct kunt gebruiken in Microsoft Fabric. We werken met een fictief retailbedrijf dat verkooptransacties verwerkt.

Stap 1: Bronze Ingest — Raw data opslaan

# Notebook: 01_bronze_ingest_sales.py
# Microsoft Fabric - PySpark Notebook
# Doel: Ruwe verkoopdata inladen vanuit Azure SQL Database naar Bronze Lakehouse

from pyspark.sql import SparkSession
from pyspark.sql.functions import current_timestamp, lit
from datetime import datetime

spark = SparkSession.builder.appName("BronzeIngest_Sales").getOrCreate()

# Verbinding naar bronsysteem (SQL Server via linked service)
jdbc_url = "jdbc:sqlserver://prod-server.database.windows.net:1433;database=RetailDB"
connection_properties = {
    "user": mssparkutils.credentials.getSecret("kv-fabric", "sql-user"),
    "password": mssparkutils.credentials.getSecret("kv-fabric", "sql-password"),
    "driver": "com.microsoft.sqlserver.jdbc.SQLServerDriver"
}

# Watermark-gebaseerde incrementele load
last_load_date = "2024-01-01"  # In productie: ophalen uit metadata tabel

df_raw = spark.read.jdbc(
    url=jdbc_url,
    table=f"(SELECT * FROM dbo.SalesTransactions WHERE ModifiedDate > '{last_load_date}') AS src",
    properties=connection_properties
)

# Metadata kolommen toevoegen voor traceerbaarheid
df_bronze = df_raw.withColumn("_ingestion_timestamp", current_timestamp()) \
                  .withColumn("_source_system", lit("RetailDB_SQL")) \
                  .withColumn("_batch_date", lit(datetime.today().strftime("%Y-%m-%d")))

# Schrijven naar Bronze Lakehouse als Delta tabel
# Append-only: historiek bewaren!
df_bronze.write.format("delta") \
    .mode("append") \
    .partitionBy("_batch_date") \
    .save("abfss://bronze@onelake.dfs.fabric.microsoft.com/RetailLH.Lakehouse/Tables/sales_transactions_raw")

print(f"Bronze ingest voltooid: {df_bronze.count()} rijen geladen")

Stap 2: Silver Transformatie — Cleansing en Deduplicatie

# Notebook: 02_silver_transform_sales.py
# Microsoft Fabric - PySpark Notebook
# Doel: Bronze data cleansen, dedupliceren en laden naar Silver laag

from pyspark.sql import SparkSession
from pyspark.sql.functions import (
    col, trim, upper, to_date, when, row_number, current_timestamp
)
from pyspark.sql.window import Window
from delta.tables import DeltaTable

spark = SparkSession.builder.appName("SilverTransform_Sales").getOrCreate()

# Lees meest recente Bronze data
df_bronze = spark.read.format("delta").load(
    "abfss://bronze@onelake.dfs.fabric.microsoft.com/RetailLH.Lakehouse/Tables/sales_transactions_raw"
)

# 1. Basis cleaning
df_clean = df_bronze \
    .withColumn("customer_name", trim(upper(col("customer_name")))) \
    .withColumn("product_code", trim(col("product_code"))) \
    .withColumn("transaction_date", to_date(col("transaction_date_str"), "dd-MM-yyyy")) \
    .withColumn("amount", col("amount").cast("decimal(18,2)")) \
    .filter(col("transaction_id").isNotNull()) \
    .filter(col("amount") > 0)  # Negatieve bedragen uitsluiten

# 2. Deduplicatie: behoud meest recente record per transaction_id
window_spec = Window.partitionBy("transaction_id").orderBy(col("_ingestion_timestamp").desc())

df_deduped = df_clean \
    .withColumn("row_num", row_number().over(window_spec)) \
    .filter(col("row_num") == 1) \
    .drop("row_num", "_ingestion_timestamp", "_batch_date")

# 3. Kwaliteitscheck
total_records = df_deduped.count()
null_dates = df_deduped.filter(col("transaction_date").isNull()).count()
print(f"Totaal records: {total_records}")
print(f"Records met null datum (worden gemarkeerd): {null_dates}")

df_silver = df_deduped.withColumn(
    "dq_flag",
    when(col("transaction_date").isNull(), "INVALID_DATE")
    .when(col("customer_id").isNull(), "MISSING_CUSTOMER")
    .otherwise("VALID")
).withColumn("_silver_timestamp", current_timestamp())

# 4. MERGE naar Silver tabel (SCD Type 1 upsert)
silver_path = "abfss://silver@onelake.dfs.fabric.microsoft.com/RetailLH.Lakehouse/Tables/sales_transactions"

if DeltaTable.isDeltaTable(spark, silver_path):
    silver_table = DeltaTable.forPath(spark, silver_path)
    silver_table.alias("target").merge(
        df_silver.alias("source"),
        "target.transaction_id = source.transaction_id"
    ).whenMatchedUpdateAll() \
     .whenNotMatchedInsertAll() \
     .execute()
    print("Silver MERGE succesvol uitgevoerd")
else:
    # Eerste keer: volledige write
    df_silver.write.format("delta").mode("overwrite").save(silver_path)
    print("Silver tabel aangemaakt en gevuld")

Stap 3: Gold Aggregatie — Business-klare data

# Notebook: 03_gold_aggregate_sales.py
# Microsoft Fabric - PySpark Notebook
# Doel: Silver data aggregeren naar Gold laag voor Power BI rapportage

from pyspark.sql import SparkSession
from pyspark.sql.functions import (
    col, sum, count, avg, date_trunc, year, month
)

spark = SparkSession.builder.appName("GoldAggregate_Sales").getOrCreate()

# Lees Silver data (alleen VALID records)
df_silver = spark.read.format("delta").load(
    "abfss://silver@onelake.dfs.fabric.microsoft.com/RetailLH.Lakehouse/Tables/sales_transactions"
).filter(col("dq_flag") == "VALID")

# Dimensie: klanten (voorbeeld - join met klantentabel)
df_customers = spark.read.format("delta").load(
    "abfss://silver@onelake.dfs.fabric.microsoft.com/RetailLH.Lakehouse/Tables/customers"
)

# Feitentabel: maandelijkse omzet per klant en productcategorie
df_gold = df_silver \
    .join(df_customers, "customer_id", "left") \
    .withColumn("year_month", date_trunc("month", col("transaction_date"))) \
    .groupBy(
        "year_month",
        col("customer_segment"),
        col("product_category"),
        col("region")
    ).agg(
        sum("amount").alias("total_revenue"),
        count("transaction_id").alias("transaction_count"),
        avg("amount").alias("avg_transaction_value"),
        count("customer_id").alias("unique_customers")
    ) \
    .withColumn("year", year(col("year_month"))) \
    .withColumn("month", month(col("year_month")))

# Schrijven naar Gold — overwrite per partitie (idempotent)
df_gold.write.format("delta") \
    .mode("overwrite") \
    .option("overwriteSchema", "true") \
    .partitionBy("year", "month") \
    .save("abfss://gold@onelake.dfs.fabric.microsoft.com/RetailLH.Lakehouse/Tables/fact_monthly_sales")

# Registreer als SQL tabel voor direct gebruik in Warehouse/Power BI
spark.sql("""
    CREATE TABLE IF NOT EXISTS gold_lakehouse.fact_monthly_sales
    USING DELTA
    LOCATION 'abfss://gold@onelake.dfs.fabric.microsoft.com/RetailLH.Lakehouse/Tables/fact_monthly_sales'
""")

print(f"Gold tabel bijgewerkt: {df_gold.count()} aggregatierijen")

Medallion Architecture vs. Alternatieven

In de Nederlandse markt zien we dat de combinatie Medallion + Fabric snel mainstream wordt bij mid-market en enterprise organisaties. Het biedt de juiste balans tussen structuur, flexibiliteit en time-to-value — zonder de extreme complexiteit van Data Vault of Data Mesh.

Best Practices voor Productie

Production Tips

-- In Fabric Notebook
OPTIMIZE silver_lakehouse.sales_transactions
ZORDER BY (transaction_date, customer_id);

VACUUM silver_lakehouse.sales_transactions
RETAIN 168 HOURS;

# DQ Check voorbeeld
dq_results = {
    "null_rate": null_count / total,
    "duplicate_rate": dup_count / total,
    "pipeline_run": run_id
}
# Schrijf naar monitoring tabel

Conclusie: Wanneer Wel en Niet Gebruiken?

Medallion Architecture in Microsoft Fabric is een krachtige combinatie die voor veel Nederlandse organisaties de juiste keuze is. Maar het is geen one-size-fits-all oplossing. Hier is een eerlijk overzicht:

Voor de meeste Nederlandse organisaties die nu beginnen met of doorgroeien in datamaturiteit, is Medallion Architecture in Microsoft Fabric de meest pragmatische, schaalbare en toekomstvaste keuze. Het platform groeit snel, de community is actief, en de integratie met Power BI en AI Foundry (voor Copilot-workloads) maakt het een platform dat met je meegroeit.

Begin klein: implementeer eerst één domein (bijv. sales of finance) met een solide Bronze-Silver-Gold structuur. Bewijs de waarde, verfijn je patronen, en schaal daarna uit naar het hele platform. De

👨‍💻 Over de auteur

Abdullah Özisik — Data Engineer met specialisatie in AI-integratie en MLOps. Expert in het bouwen van intelligente data pipelines die gebruik maken van machine learning en generative AI voor geautomatiseerde data processing en optimalisatie.

💼 LinkedIn 👨‍💻 GitHub