# Snowflake in 2026: architectuur, SQL en sollicitatievragen voor data engineers

> Een gids voor 2026 over de Snowflake-architectuur voor data engineers: hoe storage en compute scheiden, hoe virtual warehouses en micro-partitions werken, en de sollicitatievragen die productie-ervaring toetsen.

- Published: 2026-06-29
- Updated: 2026-07-06
- Author: SharpSkill
- Tags: snowflake, data-engineering, data-warehouse, sql, snowflake-architecture, dynamic-tables
- Reading time: 10 min

---

Snowflake-sollicitatievragen toetsen of een data engineer de ontkoppelde architectuur van het platform begrijpt, niet alleen de SQL-syntax. Het multi-cluster shared-data-ontwerp dat Snowflake introduceerde, scheidt storage, compute en services in drie onafhankelijke lagen, en die scheiding verklaart vrijwel elke beslissing over performance en kosten die een team op het platform neemt. Deze gids behandelt de Snowflake-architectuur, de SQL-patronen die queries snel en goedkoop houden in 2026, en de sollicitatievragen die echte productie-ervaring blootleggen.

> **De drie lagen van Snowflake in één zin**
>
> Snowflake splitst een datawarehouse op in drie onafhankelijke lagen: gecentraliseerde storage die gecomprimeerde columnaire data bevat, virtual warehouses die elastische compute leveren, en een cloud services-laag die metadata, security en query-optimalisatie afhandelt. Elke laag schaalt zonder de andere te beïnvloeden.

## Snowflake-architectuur: storage, compute en cloud services

Het bepalende kenmerk van de Snowflake-architectuur is dat storage en compute fysiek gescheiden zijn. Data staat één keer opgeslagen in een gecentraliseerde storage-laag die draait op cloud object stores zoals Amazon S3 of Azure Blob Storage. Een willekeurig aantal compute-clusters kan diezelfde data gelijktijdig lezen zonder deze te kopiëren, een aanpak die het oorspronkelijke engineeringteam [multi-cluster shared data](https://dl.acm.org/doi/10.1145/2882903.2903741) noemde in de SIGMOD-paper uit 2016 die het ontwerp introduceerde.

De storage-laag bewaart data in onveranderlijke, gecomprimeerde, columnaire bestanden die micro-partitions heten. Een gebruiker beheert deze bestanden nooit rechtstreeks. Snowflake schrijft ze weg, houdt hun metadata bij en ruimt ze op. De compute-laag bestaat uit virtual warehouses, elk een cluster van servers dat Snowflake on demand provisioned. De cloud services-laag ligt boven beide en coördineert alles: die parset SQL, plant queries, dwingt access control af, beheert transacties en bewaart de metadata die features zoals Time Travel en zero-copy cloning mogelijk maken.

Omdat deze lagen onafhankelijk zijn, kan een warehouse worden geresized of gedropt zonder een enkele byte data aan te raken, en kan storage doorgroeien tot petabytes zonder enige compute te provisionen.

```sql
-- setup_warehouse.sql
-- Create an isolated compute cluster and a database.
CREATE WAREHOUSE analytics_wh
  WAREHOUSE_SIZE = 'MEDIUM'      -- 4 credits/hour, doubles each size step
  AUTO_SUSPEND = 60             -- suspend after 60s idle to stop billing
  AUTO_RESUME = TRUE            -- resume automatically on the next query
  INITIALLY_SUSPENDED = TRUE;

CREATE DATABASE sales_analytics;
USE WAREHOUSE analytics_wh;
USE DATABASE sales_analytics;

-- Storage and compute are independent: dropping the warehouse
-- leaves every table in sales_analytics untouched.
```

Het droppen van `analytics_wh` nadat dat script is uitgevoerd, zou alle compute-facturering stopzetten terwijl elke tabel opvraagbaar blijft zodra een nieuw warehouse wordt aangemaakt. Die ontkoppeling is het allerbelangrijkste idee om in een sollicitatiegesprek te kunnen verwoorden.

## Hoe virtual warehouses de compute van Snowflake schalen

Een virtual warehouse is een benoemd compute-cluster met een omvang in T-shirtmaten: X-Small, Small, Medium, Large en groter. Elke stap omhoog verdubbelt zowel het aantal servers als het creditverbruik per uur, dus een Large warehouse kost vier keer zoveel als een Small, maar rondt een scan-intensieve query ook ongeveer vier keer sneller af. Deze lineaire afweging tussen prijs en performance betekent dat de goedkoopste optie vaak een groter warehouse is dat korter draait.

Er bestaan twee schaaldimensies, en die verwarren is een veelvoorkomende valkuil in sollicitatiegesprekken. Verticaal schalen resized een enkel warehouse om één query sneller te maken. Horizontaal schalen voegt clusters toe aan een multi-cluster warehouse om meer gelijktijdige queries te bedienen. Een dashboard dat om 9 uur 's ochtends door 200 analisten wordt bevraagd, heeft meer clusters nodig, geen groter warehouse; een nachtelijke backfill van een biljoen rijen heeft een groter warehouse nodig, geen extra clusters.

> **Verticaal versus horizontaal schalen**
>
> Resize een warehouse (verticaal) om een enkele trage query te versnellen die veel data scant. Voeg clusters toe (horizontaal) aan een multi-cluster warehouse wanneer veel gebruikers tegelijk queries draaien en verzoeken in de wachtrij belanden. Het ene lost latency op voor een zware taak; het andere lost concurrency op voor veel kleine taken.

```sql
-- scale_compute.sql
-- Multi-cluster warehouse: add clusters when concurrency rises and
-- remove them when demand falls. Each cluster is a separate MEDIUM engine.
ALTER WAREHOUSE analytics_wh SET
  MIN_CLUSTER_COUNT = 1
  MAX_CLUSTER_COUNT = 4          -- up to 4 clusters during peak load
  SCALING_POLICY = 'STANDARD';   -- favor performance over credit savings

-- Resize vertically for one heavy job, then shrink back afterward.
ALTER WAREHOUSE analytics_wh SET WAREHOUSE_SIZE = 'XLARGE';
-- ... run the heavy backfill ...
ALTER WAREHOUSE analytics_wh SET WAREHOUSE_SIZE = 'MEDIUM';
```

`AUTO_SUSPEND` en `AUTO_RESUME` maken dit economisch haalbaar. Een opgeschort warehouse kost niets, en Snowflake factureert per seconde met een minimum van 60 seconden. Een korte auto-suspend instellen op interactieve warehouses voorkomt dat inactieve clusters credits verstoken tussen queries door.

## Micro-partitions en clustering keys voor snelle SQL

Snowflake slaat elke tabel op als een verzameling [micro-partitions](https://docs.snowflake.com/en/user-guide/tables-clustering-micropartitions), die elk 50 tot 500 MB aan ongecomprimeerde data in columnair formaat bevatten. Voor elke micro-partition legt Snowflake de minimum- en maximumwaarde van elke kolom vast in de metadata. Wanneer een query op een kolom filtert, leest de optimizer die metadata en slaat elke partition over waarvan het waardebereik onmogelijk kan matchen, een proces dat partition pruning heet. Daarom heeft Snowflake geen handmatige indexes nodig: pruning gebeurt automatisch op elke kolom.

Pruning werkt het best wanneer de filterkolom correleert met de volgorde waarin data werd ingeladen. Een tabel die per datum wordt geïngest, prunet datumbereik-queries efficiënt. Wanneer een grote tabel vaak wordt gefilterd op een kolom die losstaat van de laadvolgorde, plaatst een clustering key gerelateerde rijen bij elkaar over micro-partitions heen, zodat pruning effectief blijft naarmate de tabel groeit.

```sql
-- clustering.sql
-- Filters on naturally ordered columns prune partitions with no index.
SELECT order_date, SUM(amount_usd) AS revenue
FROM orders
WHERE order_date BETWEEN '2026-01-01' AND '2026-03-31'
GROUP BY order_date;

-- For a multi-terabyte table queried by a non-load-order column,
-- a clustering key co-locates related rows to keep pruning effective.
ALTER TABLE orders CLUSTER BY (customer_region, order_date);

-- Inspect clustering depth before committing to a key.
SELECT SYSTEM$CLUSTERING_INFORMATION('orders', '(customer_region, order_date)');
```

Clustering keys zijn niet gratis: Snowflake draait een automatische achtergrondservice om ze te onderhouden, en die service verbruikt credits. De vuistregel is om alleen een clustering key toe te voegen aan tabellen in de terabytegrootte waar query-profielen slechte pruning laten zien. Kleinere tabellen prunen zelf al goed, en een voortijdige clustering key verspilt geld. Die afweging uitleggen maakt vaak het verschil tussen een junior- en een seniorantwoord.

> **Clustering kan meer kosten dan het oplevert**
>
> Op een tabel met veel inserts en updates herorganiseert de automatische reclustering-service micro-partitions continu om de clustering key aan te houden, en dat onderhoud kan meer credits verstoken dan de queries die het versnelt. Meet eerst de query-workload met het query-profiel, en reserveer clustering voor tabellen die veel vaker worden gelezen dan geschreven.

## Data laden en transformeren: Snowpipe, Streams en Dynamic Tables

Drie ingestiepatronen dekken de meeste workloads. Bulk `COPY INTO` laadt gestagede bestanden in één commando en past bij geplande batchtaken. Snowpipe laadt bestanden continu in serverless micro-batches, getriggerd door cloud storage-events, voor bijna-realtime aankomst. Snowpipe Streaming duwt individuele rijen door een low-latency API wanneer versheid onder de seconde ertoe doet. Kiezen tussen deze opties op basis van latency- en bestandsgrootte-eisen is een frequente sollicitatievraag, en het juiste antwoord begint met "het hangt af van de versheid die de downstream consumer daadwerkelijk nodig heeft."

Transformatie binnen het warehouse leunde historisch op Streams en Tasks. Een Stream legt wijzigingen op rijniveau op een tabel vast (change data capture), en een Task draait SQL volgens een schema om die wijzigingen te consumeren en downstream samen te voegen.

```sql
-- incremental_pipeline.sql
-- A stream tracks row-level changes (CDC) on the raw landing table.
CREATE STREAM orders_stream ON TABLE raw_orders;

-- A task consumes the stream on a schedule and merges changes downstream.
CREATE TASK refresh_orders
  WAREHOUSE = analytics_wh
  SCHEDULE = '5 MINUTE'
  WHEN SYSTEM$STREAM_HAS_DATA('orders_stream')
AS
  MERGE INTO orders t
  USING orders_stream s ON t.order_id = s.order_id
  WHEN MATCHED THEN UPDATE SET t.amount_usd = s.amount_usd
  WHEN NOT MATCHED THEN INSERT (order_id, amount_usd)
    VALUES (s.order_id, s.amount_usd);
```

In 2026 zijn Dynamic Tables de voorkeursmanier geworden om incrementele transformaties uit te drukken. In plaats van een Stream aan een Task te koppelen en de merge met de hand te schrijven, declareert een Dynamic Table een target lag en een query, en berekent Snowflake de incrementele refresh automatisch. Dat verwijdert het merendeel van de orchestratie-boilerplate terwijl de resultaten vers blijven.

```sql
-- dynamic_table.sql
-- Dynamic Tables replace the stream + task pattern with a declarative
-- target lag. Snowflake computes the incremental refresh automatically.
CREATE DYNAMIC TABLE daily_revenue
  TARGET_LAG = '5 minutes'
  WAREHOUSE = analytics_wh
AS
  SELECT order_date, SUM(amount_usd) AS revenue
  FROM orders
  GROUP BY order_date;
```

Voor teams die op open formaten bouwen, laten de Iceberg-tabellen van Snowflake het warehouse [Apache Iceberg](https://iceberg.apache.org/)-data lezen en schrijven die in de eigen cloud-bucket van een klant staat, wat lock-in vermijdt terwijl de query-engine en governance van Snowflake behouden blijven. Veel teams combineren Snowflake met [dbt](https://docs.getdbt.com/) voor versiebeheerde, geteste transformaties, een workflow die wordt behandeld in de [gids over dbt-datatransformaties en testing](/blog/data-engineering/dbt-data-transformations-testing-interview-2026).

## Snowflake-sollicitatievragen voor data engineers

De onderstaande vragen komen keer op keer terug in Snowflake-sollicitatiegesprekken voor data engineering. Sterke antwoorden koppelen een feature terug aan de scheiding van storage en compute in plaats van syntax op te dreunen.

**Welk probleem lost het scheiden van storage en compute op?** Het elimineert contentie. Analisten die dashboards draaien, een data science-team dat features traint en een ELT-taak die data laadt, kunnen elk op hun eigen warehouse tegen dezelfde tabellen draaien zonder om resources te concurreren of data te kopiëren. Compute schaalt op voor een zware taak en schort zichzelf op wanneer die inactief is, terwijl de storagekosten gelijk blijven, ongeacht hoeveel compute eraan gekoppeld is.

**Hoe werken Time Travel en zero-copy cloning?** Beide steunen op de onveranderlijkheid van micro-partitions. Omdat Snowflake een micro-partition nooit overschrijft, blijven oudere versies op schijf staan gedurende het retentievenster (tot 90 dagen op Enterprise). Time Travel bevraagt een tabel zoals die op een tijdstip in het verleden was door naar die oudere partitions te wijzen, en `CLONE` maakt een nieuwe tabel die naar dezelfde partitions verwijst zonder de storage te dupliceren totdat een van beide kanten wordt gewijzigd. Copy-on-write is wat een kloon van een petabyte-tabel onmiddellijk en vrijwel gratis maakt.

**Wanneer moet een clustering key worden gedefinieerd?** Alleen op grote tabellen (grofweg een terabyte of meer) die vaak worden gefilterd of gejoind op een kolom die losstaat van hun laadvolgorde, en pas nadat een query-profiel slechte pruning bevestigt. Clustering brengt doorlopende onderhoudscredits met zich mee, dus het is een bewuste optimalisatie, geen standaardkeuze.

**Hoe worden de kosten van Snowflake beheerst?** Via warehouse-sizing, agressieve auto-suspend, het cluster-aantal afstemmen op echte concurrency, en resource monitors die het creditverbruik begrenzen. Een resource monitor kan warehouses automatisch waarschuwen of opschorten zodra een quota is bereikt.

```sql
-- cost_control.sql
-- A resource monitor caps credit spend and suspends warehouses
-- automatically when the monthly quota is reached.
CREATE RESOURCE MONITOR monthly_cap
  WITH CREDIT_QUOTA = 1000
  FREQUENCY = MONTHLY
  START_TIMESTAMP = IMMEDIATELY
  TRIGGERS
    ON 80 PERCENT DO NOTIFY
    ON 100 PERCENT DO SUSPEND;

ALTER WAREHOUSE analytics_wh SET RESOURCE_MONITOR = monthly_cap;
```

**Streams en Tasks of Dynamic Tables?** Dynamic Tables passen bij declaratieve pipelines waar een doelversheid de eis is en Snowflake de refresh kan beheren. Streams en Tasks blijven het juiste gereedschap wanneer de transformatie imperatieve controle, side effects of logica vereist die één enkele query niet kan uitdrukken. Weten waar elk past, in plaats van standaard voor één te kiezen, wijst op productie-ervaring.

**Hoe verschilt ELT op Snowflake van traditionele ETL?** De goedkope storage en elastische compute van Snowflake maken het praktisch om ruwe data eerst te laden en die vervolgens ter plekke te transformeren, het patroon dat wordt behandeld in de [gids over ETL versus ELT-architectuur](/blog/data-engineering/etl-vs-elt-data-pipeline-architecture). Kandidaten die zich op de volledige cyclus voorbereiden, kunnen de [module over ETL- en ELT-patronen](/technologies/data-engineering/interview-questions/etl-elt-patterns) oefenen naast het bredere [data-engineeringtraject](/technologies/data-engineering).

## Conclusie

- De Snowflake-architectuur scheidt storage, compute en cloud services in drie onafhankelijke lagen, en vrijwel elk ontwerpantwoord is terug te voeren op die scheiding
- Virtual warehouses schalen verticaal voor zwaardere enkele queries en horizontaal voor hogere concurrency; auto-suspend en facturering per seconde houden inactieve compute gratis
- Micro-partitions met per kolom min/max-metadata leveren automatische partition pruning, en daarom heeft Snowflake geen handmatige indexes nodig
- Voeg clustering keys alleen toe aan tabellen op terabyteschaal met bewezen slechte pruning, aangezien onderhoud credits verbruikt
- Stem het ingestiepatroon af op de vereiste versheid: bulk COPY voor batch, Snowpipe voor continue micro-batches, Snowpipe Streaming voor latency onder de seconde
- Geef in 2026 de voorkeur aan Dynamic Tables voor declaratieve incrementele transformaties, en reserveer Streams en Tasks voor imperatieve logica
- Time Travel en zero-copy cloning benutten beide de onveranderlijkheid van micro-partitions en copy-on-write, waardoor point-in-time-queries en directe klonen goedkoop zijn
- Beheers kosten met correct geschaalde warehouses, agressieve auto-suspend, op concurrency afgestemde clusters en resource monitors

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/nl/blog/data-engineering/snowflake-architecture-sql-data-engineer-interview-2026