# Apache Beam vs Spark 2026: Unified Pipelines en Sollicitatievragen

> Vergelijking van Apache Beam 2.76 en Spark 4.2 voor data pipelines. Portabiliteit, performance, sollicitatievragen en beslissingscriteria voor Data Engineers.

- Published: 2026-09-10
- Updated: 2026-09-10
- Author: Anthony Fillion-Maillet
- Reading time: 5 min

---

Apache Beam vs Spark vertegenwoordigt een van de meest voorkomende architectuurbeslissingen in moderne data engineering. Beam 2.76 (augustus 2026) en Spark 4.2 (juli 2026) verwerken beide batch- en streaming-workloads, maar hun ontwerpfilosofieën verschillen fundamenteel: Beam abstraheert de execution engine, terwijl Spark een strak geïntegreerde runtime biedt.

> **Snel Beslissingskader**
>
> Kies Beam wanneer portabiliteit over runners (Dataflow, Flink, Spark) belangrijk is of bij gebruik van Google Cloud Dataflow. Kies Spark bij zelfbeheerde clusters, Databricks-gebruik of ML-integratie met MLlib.

## Beam's Portabiliteitsmodel vs Spark's Unified Engine

Apache Beam scheidt het programmeermodel van de uitvoering. Een enkele pipeline-definitie draait op [Google Cloud Dataflow](https://cloud.google.com/dataflow), Apache Flink, Apache Spark of andere runners zonder codewijzigingen. Deze abstractie ontstaat doordat de Beam SDK een portabele pipeline-representatie genereert die elke compatibele runner interpreteert.

Spark 4.2 kiest de tegenovergestelde aanpak. De DataFrame API, Structured Streaming en MLlib delen dezelfde Catalyst optimizer en Tungsten execution engine. Deze strakke koppeling maakt optimalisaties mogelijk zoals [Adaptive Query Execution](https://spark.apache.org/docs/latest/sql-performance-tuning.html) die plannen runtime aanpassen op basis van werkelijke datastatistieken.

```python
# beam_pipeline.py
import apache_beam as beam
from apache_beam.options.pipeline_options import PipelineOptions

# Same code runs on Dataflow, Flink, or Spark runner
options = PipelineOptions([
    '--runner=DataflowRunner',  # Switch to FlinkRunner or SparkRunner
    '--project=my-project',
    '--region=us-central1',
    '--temp_location=gs://my-bucket/temp'
])

with beam.Pipeline(options=options) as pipeline:
    (pipeline
     | 'ReadEvents' >> beam.io.ReadFromPubSub(topic='projects/p/topics/events')
     | 'ParseJSON' >> beam.Map(lambda x: json.loads(x))
     | 'FilterValid' >> beam.Filter(lambda e: e.get('status') == 'valid')
     | 'WindowByMinute' >> beam.WindowInto(beam.window.FixedWindows(60))
     | 'CountPerWindow' >> beam.combiners.Count.Globally()
     | 'WriteToBQ' >> beam.io.WriteToBigQuery('project:dataset.table'))
```

Het Spark-equivalent bindt direct aan de Spark-runtime:

```python
# spark_streaming.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import from_json, col, window

spark = SparkSession.builder \
    .appName("EventProcessing") \
    .config("spark.sql.adaptive.enabled", "true") \
    .getOrCreate()

# Spark 4.2: ANSI mode enabled by default, stricter type checking
events = spark.readStream \
    .format("kafka") \
    .option("kafka.bootstrap.servers", "broker:9092") \
    .option("subscribe", "events") \
    .load()

processed = events \
    .select(from_json(col("value").cast("string"), schema).alias("data")) \
    .filter(col("data.status") == "valid") \
    .groupBy(window(col("data.timestamp"), "1 minute")) \
    .count()

processed.writeStream \
    .format("bigquery") \
    .option("table", "project.dataset.table") \
    .outputMode("append") \
    .start()
```

Beam's portabiliteit maakt cloud-agnostische architecturen mogelijk, maar voegt een vertaallaag toe. Spark's directe uitvoering toont doorgaans lagere latentie voor equivalente operaties op dezelfde hardware.

## Windowing en Event-Time Verwerking Vergeleken

Beide frameworks verwerken event-time semantiek, maar hun API's weerspiegelen verschillende achtergronden. Beam's windowing-model komt uit het [Dataflow Model paper](https://research.google/pubs/pub43864/) (2015) en behandelt windows als eersteklas pipeline-elementen. Spark paste zijn windowing aan voor Structured Streaming en integreerde het met de DataFrame API.

| Feature | Beam 2.76 | Spark 4.2 |
|---------|-----------|----------|
| Fixed windows | `FixedWindows(duration)` | `window(col, duration)` |
| Sliding windows | `SlidingWindows(size, period)` | `window(col, size, period)` |
| Session windows | `Sessions(gap)` | Niet natief (gebruik `flatMapGroupsWithState`) |
| Custom windows | `WindowFn` subklasse | Beperkt |
| Late data handling | Ingebouwde triggers | Watermark delays |
| Allowed lateness | Per-window configuratie | Globale watermark |

Session windows tonen het verschil het duidelijkst. Beam behandelt sessies als een native windowing-strategie:

```python
# beam_sessions.py
from apache_beam import window

# 30-minute session gap, allow 1 hour late data
windowed = (
    events
    | 'SessionWindow' >> beam.WindowInto(
        window.Sessions(30 * 60),  # 30 min gap closes session
        trigger=beam.trigger.AfterWatermark(
            early=beam.trigger.AfterProcessingTime(60),
            late=beam.trigger.AfterCount(1)
        ),
        allowed_lateness=3600,  # Accept data up to 1 hour late
        accumulation_mode=beam.trigger.AccumulationMode.ACCUMULATING
    )
)
```

Spark vereist stateful processing voor sessies:

```python
# spark_sessions.py
from pyspark.sql.streaming import GroupState, GroupStateTimeout

def update_session(key, events, state: GroupState):
    # Manual session management with state API
    session_data = state.getOption() or {"count": 0, "start": None, "end": None}
    
    for event in events:
        ts = event.timestamp
        if session_data["end"] and (ts - session_data["end"]).seconds > 1800:
            # Gap exceeded 30 min, emit previous session
            yield session_data
            session_data = {"count": 0, "start": ts, "end": ts}
        
        session_data["count"] += 1
        session_data["end"] = ts
        if not session_data["start"]:
            session_data["start"] = ts
    
    state.update(session_data)
    state.setTimeoutDuration(30 * 60 * 1000)  # 30 min timeout

# Spark 4.2 Arbitrary State API v2
result = events \
    .groupByKey(lambda e: e.user_id) \
    .flatMapGroupsWithState(
        update_session,
        outputMode="append",
        stateType=session_schema,
        timeoutConf=GroupStateTimeout.ProcessingTimeTimeout
    )
```

Voor sollicitatievoorbereidingen over deze onderwerpen biedt de [Apache Beam en Dataflow sollicitatievragen](/technologies/data-engineering/interview-questions/apache-beam-dataflow) module uitgebreide oefeningen.

## Performance: Benchmark Data uit 2026

Directe vergelijkingen vereisen zorgvuldige setup omdat Beam op Spark kan draaien als runner-optie. De relevante vergelijking is Beam-op-Dataflow vs native Spark.

Recente benchmarks van Databricks en Google Cloud tonen:

| Workload | Spark 4.2 (Databricks) | Beam 2.76 (Dataflow) | Opmerkingen |
|----------|------------------------|---------------------|-------|
| Batch ETL (1TB Parquet) | 4,2 min | 5,1 min | Spark's Photon engine voordeel |
| Streaming (100K events/sec) | 45ms p99 latentie | 120ms p99 latentie | Dataflow autoscaling overhead |
| Exactly-once sink writes | Natief | Natief | Beide ondersteunen sinds 2024 |
| Kosten (sustained workload) | $0,12/GB verwerkt | $0,08/GB verwerkt | Dataflow Flex pricing |

Spark 4.2's performanceverbeteringen komen van verschillende features:
- **ANSI mode standaard**: strengere SQL-semantiek detecteert fouten eerder
- **VARIANT datatype**: native handling van semi-gestructureerde data
- **Adaptive Query Execution**: runtime planoptimalisatie
- **Java 21 support**: virtual threads verminderen overhead

Beam 2.76 countert met:
- **Flink 2.0 runner support**: productie-ready stateful streaming
- **CDC offset persistence**: DebeziumIO FileSystemOffsetRetainer
- **ADK integratie**: Google Agent Development Kit support in Python SDK

## Veelvoorkomende Sollicitatievragen: Beam vs Spark

Technische sollicitatiegesprekken voor data engineering rollen vergelijken vaak deze frameworks. Hier zijn vragen die verschijnen in sollicitaties van 2026, met de verwachte antwoorddiepte.

**Q1: Wanneer zou men Beam kiezen boven native Spark?**

Verwachte antwoordpunten:
- Multi-cloud of hybride deployments waar pipeline-code ongewijzigd moet draaien
- Google Cloud omgevingen waar Dataflow beheerde infrastructuur biedt
- Complexe event-time semantiek die session windows of custom triggers vereist
- Teams met bestaande Beam-expertise uit Dataflow-achtergrond

Rode vlag antwoord: "Beam is altijd beter omdat het portabel is." Portabiliteit heeft overhead-kosten.

**Q2: Hoe beïnvloedt Beam's runner-abstractie debugging?**

Verwachte antwoordpunten:
- Stack traces refereren zowel Beam SDK als runner-implementatie
- Runner-specifieke optimalisaties kunnen zich anders gedragen (Flink checkpoints vs Spark checkpoints)
- Metrics API biedt uniforme monitoring, maar runner-dashboards tonen verschillende details
- Testen met DirectRunner voor deployment naar productie-runner

**Q3: Leg exactly-once semantiek in beide frameworks uit.**

Verwacht antwoord:

```python
# Beam: exactly-once via runner guarantees
# Dataflow provides exactly-once for both sources and sinks
# The SDK handles deduplication and checkpoint coordination

with beam.Pipeline() as p:
    (p
     | beam.io.ReadFromPubSub(subscription='...')  # Exactly-once read
     | beam.Map(process)
     | beam.io.WriteToBigQuery(...)  # Exactly-once write with retries
    )

# Spark: exactly-once via checkpointing and idempotent sinks
spark.readStream \
    .format("kafka") \
    .load() \
    .writeStream \
    .option("checkpointLocation", "/checkpoint")  # State recovery
    .foreachBatch(idempotent_write)  # Application-level deduplication
    .start()
```

Voor meer streaming sollicitatieonderwerpen, zie de [PySpark module](/technologies/data-engineering/interview-questions/pyspark).

**Q4: Hoe zou men een Spark batch job migreren naar Beam?**

Deze vraag test het begrip van beide API's. Kernpunten:

1. DataFrame operaties mappen naar PCollections en transforms
2. `spark.read` vervangen door geschikte Beam I/O connectors
3. UDF's converteren naar `beam.Map` of `beam.ParDo` functies
4. Partitionering anders afhandelen (Beam's `Reshuffle` vs Spark's `repartition`)
5. Testen met DirectRunner voor deployment naar productie-runner

## De Juiste Tool Kiezen: Beslissingsmatrix

De keuze hangt meer af van organisatorische context dan van technische mogelijkheden. Beide frameworks verwerken de meeste data engineering workloads competent.

| Factor | Favoriet Beam | Favoriet Spark |
|--------|-------------|-------------|
| Cloud provider | Google Cloud | AWS EMR, Databricks, on-prem |
| Team-expertise | Bestaande Dataflow-ervaring | Bestaande Spark/PySpark-skills |
| ML integratie | Beperkt (aparte tools) | MLlib, Spark ML |
| Interactieve analyse | Niet hiervoor ontworpen | Spark SQL, notebooks |
| Session windows | Native ondersteuning | Handmatige state management |
| Kostenmodel | Pay-per-use (Dataflow) | Cluster provisioning |
| Vendor lock-in | Lager (meerdere runners) | Hoger (Spark-specifieke code) |

Voor [ETL/ELT pattern-beslissingen](/technologies/data-engineering/interview-questions/etl-elt-patterns) moeten datavolume en latentie-eisen worden overwogen voor framework-selectie.

## Real-World Architectuur: Hybride Aanpak

Veel organisaties gebruiken beide frameworks. Een veelvoorkomend patroon:

```
[Streaming Ingestion]     [Batch Processing]     [ML Training]
        |                        |                    |
   Beam/Dataflow           Spark on Databricks    Spark MLlib
        |                        |                    |
        v                        v                    v
    BigQuery  <----- dbt -----> Delta Lake -----> Model Registry
```

Beam verwerkt streaming ingestion waar Dataflow's autoscaling past bij verkeerspatronen. Spark verwerkt batch-workloads waar cluster-economie sustained compute bevoordeelt. Beide voeden een unified data warehouse.

Deze architectuur verschijnt in de [Apache Spark tutorial](/blog/data-engineering/apache-spark-pyspark-data-pipelines-tutorial) met implementatiedetails.

## Kernpunten voor Beam vs Spark Selectie

- Beam 2.76 biedt runner-portabiliteit over Dataflow, Flink 2.0 en Spark, ruilt performance voor deployment-flexibiliteit
- Spark 4.2 levert strakkere integratie tussen SQL, streaming en ML-workloads met features zoals VARIANT types en Adaptive Query Execution
- Session windows en complexe triggers bevorderen Beam's native windowing-model
- Batch performance op equivalente hardware favoriseert doorgaans Spark door Catalyst/Tungsten optimalisatie
- Sollicitatievragen focussen op trade-offs in plaats van een framework superieur te verklaren
- Hybride architecturen met beide frameworks zijn gebruikelijk in productieomgevingen
- Kostenvergelijking hangt af van workload-patronen: Dataflow's per-GB pricing vs Spark cluster provisioning

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/nl/blog/data-engineering/apache-beam-vs-spark-2026-unified-pipelines-interview-questions