Data engineering · Interview questions · Updated November 2026
Data engineering interview questions in 2026 test SQL and indexing, data modelling, ETL and ELT pipelines, Apache Spark, Apache Kafka, stream processing with Apache Flink or Spark Structured Streaming, orchestration with Apache Airflow, and data quality and governance. Interviewers also expect current versions: Apache Kafka has run without ZooKeeper since 4.0, and data lake questions now centre on lakehouse layers over cloud object storage. This guide explains each topic by level and gives a 2–3 week plan. It ends with 10 free data engineering practice questions with answers and explanations.
At a glance
| Topic | Data engineering interviews and technical screenings |
| Levels covered | Junior, mid-level and senior |
| Core topics | SQL, modelling, Spark, Kafka, streaming, Airflow |
| Kafka today | No ZooKeeper since Apache Kafka 4.0 (KRaft mode) |
| Official syllabus | Not published: no single body sets one |
| Exametics set | 6 practice tests, 637 questions |
- Expect code-reading questions: what a query returns, when a Spark job runs, and what happens when a task is retried.
Source: Apache Kafka 4.0.0 release announcement. Checked on 9 November 2026.
What interviewers test in data engineering interviews
Data engineering interview questions check whether you can move data reliably from sources to analysts: query it, model it, process it in batch and in streams, schedule it, and prove it is correct.
No official data engineering syllabus is published, so each company picks its own stack. The topics below are the common core.
SQL, indexing and data modelling
SQL is the base for every other topic, so expect it early in the process. Expect joins, aggregation, NULL handling, common table expressions and, above all, window functions. The PostgreSQL window functions tutorial explains the key idea: a window function works across related rows, but the rows keep their separate identities instead of being grouped into one output row.
The same tutorial says window functions are allowed only in the SELECT list and ORDER BY, because they run after WHERE, GROUP BY and HAVING. That is why “top 3 per group” queries use a subquery or CTE. The PostgreSQL window functions reference separates row_number(), rank() (with gaps) and dense_rank() (without gaps).
Indexing questions usually ask why a query is slow. The PostgreSQL multicolumn index guide says a B-tree index on several columns is most efficient when the query constrains the leading (leftmost) columns.
Data modelling questions cover fact and dimension tables, the grain of a fact table, star versus snowflake schemas, and slowly changing dimensions.
ETL, ELT and the lakehouse
ETL transforms data before loading it; ELT loads raw data first and transforms it in the warehouse or lakehouse.
Storage questions now centre on cloud object storage and open formats. The Apache Parquet overview describes Parquet as a column-oriented file format designed for efficient storage and retrieval. Table formats add database features on top: the Delta Lake documentation lists ACID transactions, scalable metadata and versioning, and the Apache Iceberg site lists schema evolution, hidden partitioning and time travel.
The Databricks medallion architecture page describes bronze as raw, unvalidated data, silver as validated, cleaned and enriched data, and gold as data that is often highly aggregated.
Apache Spark
Spark questions test how the engine runs your code, not only the DataFrame API. The Spark programming guide says all transformations are lazy and only run when an action, such as count() or collect(), needs a result. It calls the shuffle expensive: disk I/O, serialisation and network I/O.
Performance questions follow from that. The Spark SQL performance tuning guide (Spark 4.3.0 docs) covers:
- Broadcast joins:
spark.sql.autoBroadcastJoinThresholddefaults to 10 MB; tables below it can be sent to every worker instead of shuffling the large side. - Adaptive Query Execution (AQE): on by default since Spark 3.2.0. It coalesces post-shuffle partitions, converts sort-merge joins to broadcast joins and splits skewed join tasks.
- Join hints:
BROADCAST,MERGE,SHUFFLE_HASHandSHUFFLE_REPLICATE_NL, with no guarantee that Spark will use the hinted strategy.
Kafka, Flink and stream processing
Kafka questions start with the basics: topics, partitions, keys, offsets and consumer groups. The Kafka introduction says events with the same key go to the same partition, and consumers read a partition’s events in exactly the order they were written. The KafkaConsumer documentation says each partition is assigned to exactly one consumer in a group, and that isolation.level=read_committed makes a consumer read only committed transactional messages.
Architecture questions have changed. The Apache Kafka 4.0 release announcement calls 4.0 the first major release to operate entirely without Apache ZooKeeper, running in KRaft mode by default.
Streaming questions test time. The Flink time concepts page separates event time (when the event happened on its device) from processing time (the clock of the machine running the job), and says a watermark with time t declares that event time has reached t. The Spark Structured Streaming guide sets its watermark as the maximum event time seen minus a lateness threshold.
Fault tolerance is the senior topic. The Flink fault tolerance guide says end-to-end exactly-once needs replayable sources and transactional (or idempotent) sinks.
Orchestration, data quality and governance
Airflow questions cover Dags, schedules, data intervals, retries, catchup and backfill. The Airflow Dag runs page (Airflow 3.4.0 docs) says each Dag run has a data interval, the time range it works on, and that missed runs are not backfilled by default.
The Airflow best practices page says tasks should produce the same outcome on every re-run, and warns that an INSERT on a re-run can create duplicate rows.
Data quality and governance questions ask how you would catch bad data before analysts see it: checks for nulls, uniqueness, ranges and freshness, schema enforcement, lineage and access control.
Exametics practice tests
Data Engineering Interview Practice Tests
- 6 practice tests with 106 to 107 questions each: 637 questions in total
- Every answer explained: why the right answer is right and why the others are wrong
- Each question mapped to a topic area, from SQL and data modelling to Spark, Kafka, Flink and Airflow
- Timed Exam Mode test; rebuilt for 2026 with KRaft, lakehouse layers and current Spark and Flink APIs
- Lifetime access
30-day refund. Instant access after payment.
Data engineer interview questions by level
The level changes the depth more than the topics: juniors explain what a tool does, mid-level engineers explain why a pipeline behaves as it does, and seniors explain how they would design, scale and recover a platform.
| Level | What you should be able to do |
|---|---|
| Junior | Write joins, aggregations and window functions; explain fact and dimension tables; describe ETL versus ELT; explain what Spark, Kafka and Airflow are for. |
| Mid-level | Tune a slow query or Spark job, build incremental and idempotent loads, choose partition keys, handle late data and write data quality checks. |
| Senior | Design batch and streaming architectures, reason about exactly-once delivery, plan schema evolution and backfills, and set up governance and cost controls. |
Junior data engineer expectations
Junior screens are mostly SQL and concepts, such as writing the latest order per customer and explaining why you used row_number().
Mid-level data engineer expectations
Mid-level questions are often debugging stories: a slow shuffle, a skewed key, duplicates after a retry, or late events dropped from a stream. Name the cause and the fix.
Senior data engineer expectations
Senior interviews move to design trade-offs: batch or streaming, Delta Lake or Iceberg, and what “exactly once” really covers.
Next on your data engineering path
- SQL Query Interview Preparation practice tests: SQL is often the first technical screen, so extra query practice pays off.
- Databricks Data Engineer Associate practice tests: a vendor certification that tests Spark and lakehouse skills in depth.
- AWS Certified Data Engineer Associate (DEA-C01) practice tests: useful if the roles you apply for run their pipelines on AWS.
How to prepare for a data engineering interview in 2–3 weeks
If you already work with data, two to three weeks is a realistic plan: SQL and modelling first, then the processing engines, then timed practice.
- Days 1–4: SQL and indexing Write window-function queries for ranking, running totals and gaps between events. Read a few query plans and explain why a composite index helps one query and not another.
- Days 5–7: data modelling and ELT Model a small sales domain as a star schema. Define the grain of each fact table and build a Type 2 customer dimension with effective dates.
- Days 8–10: Spark and the lakehouse Run a Spark job, read its plan, and find the shuffles. Compare a broadcast join with a sort-merge join, and write Parquet into a Delta Lake or Iceberg table with bronze, silver and gold layers.
- Days 11–13: streaming and orchestration Produce keyed events to Kafka and consume them with a group. Add a watermark to a windowed aggregation, then write an Airflow Dag whose tasks are safe to retry.
- Days 14–18: timed practice Take the data engineering interview practice tests in timed Exam Mode, read the explanation for every miss, and redo your weakest topic areas.
Tip
For every tool, prepare one failure story: what broke, how you found it, and what you changed.
Planning more than one exam?
If you are preparing for several interviews or a data certification as well, the All-Access Pass covers every practice test on Exametics, including the 58 interview-question sets and new exams as they are added, with lifetime access. It costs less than buying about six single practice tests.
Free data engineering interview questions (10 with answers)
Try these 10 free practice questions before you open the answers. They are original sample questions with answers, each labelled with its topic area; the full Exametics data engineering practice test set has 637 questions in the same style.
Practice question 1 · SQL
A table holds four scores: 100, 90, 90 and 80. You run rank() OVER (ORDER BY score DESC). What rank does the row with score 80 get?
- A. 3
- B. 4
- C. 2
- D. 5
Show answer
Answer: B. rank() gives tied rows the same rank and then leaves a gap. The two 90s share rank 2, so the next row is ranked 4. The PostgreSQL window functions reference describes rank() as “with gaps”.
A is what dense_rank() returns, because it has no gaps. C is the rank of the 90s. D would need five rows.
Practice question 2 · SQL
In PostgreSQL, a developer wants the three most recent orders per customer and writes SELECT * FROM orders WHERE row_number() OVER (PARTITION BY customer_id ORDER BY order_date DESC) <= 3. What happens?
- A. It returns the three most recent orders for each customer.
- B. It works if the condition moves to a
HAVINGclause afterGROUP BY customer_id. - C. It fails: window functions are not allowed in
WHERE. - D. It returns the three most recent orders in the whole table, ignoring the partition.
Show answer
Answer: C. The PostgreSQL tutorial says window functions are permitted only in the SELECT list and ORDER BY, because they logically run after WHERE, GROUP BY and HAVING. Compute row_number() in a subquery or CTE and filter in the outer query.
A and D assume the query runs, but it is rejected. B is wrong because window functions are also forbidden in HAVING.
Practice question 3 · Indexing
A PostgreSQL table has a B-tree index on (customer_id, order_date). Which WHERE clause lets the index limit the scanned range most effectively?
- A.
customer_id = 42 AND order_date >= '2026-01-01' - B.
order_date >= '2026-01-01' - C.
customer_id > 10 AND order_date = '2026-01-01' - D.
customer_id = 42 OR order_date = '2026-01-01'
Show answer
Answer: A. The PostgreSQL multicolumn index guide says equality constraints on the leading columns, plus an inequality on the first column without an equality, limit the part of the index that is scanned. A has equality on the leading column and a range on the second, so both narrow the scan.
B has no condition on the leading column. PostgreSQL 18 can sometimes use a skip scan, but it only pays off when customer_id has few distinct values. In C the inequality is on the first column, so order_date does not reliably narrow the scan (skip scan may help, but it is not guaranteed). D uses OR, so rows matching only the order_date condition cannot be found through the leading column.
Practice question 4 · Data modelling
A customer moves from Leeds to Bristol. Analysts must still report the customer’s past orders under Leeds and new orders under Bristol. How should the customer dimension handle the change?
- A. Overwrite the city with Bristol in the existing row.
- B. Add a
previous_citycolumn to the existing row and keep one row per customer. - C. Delete the old row and insert a new one that reuses the same surrogate key.
- D. Close the current row and insert a new row with a new surrogate key.
Show answer
Answer: D. This is a Type 2 slowly changing dimension. The old row gets an end date, and the new row gets its own surrogate key, a start date and often a current-row flag, so old fact rows keep pointing at the Leeds version and new ones point at the Bristol version.
A is Type 1: history is lost and old orders move to Bristol. B is Type 3: it keeps only one previous value and does not tie each order to the right version. C keeps a single key, so old facts would also show Bristol.
Practice question 5 · Spark
A PySpark script defines df2 = df.filter(df.status == "paid").withColumn("net", df.amount - df.tax), prints “ready”, and then calls df2.count(). When are the filter and the new column actually computed?
- A. When
filter()is called, because filters run immediately to reduce data early. - B. When
withColumn()is called, because adding a column creates a new DataFrame in memory. - C. When
count()is called, because it is an action. - D. Never, because
count()only reads file metadata and skips transformations.
Show answer
Answer: C. The Spark programming guide says all transformations are lazy: Spark records them and computes them only when an action requires a result. count() is an action, so the filter and the new column run then.
A and B describe eager execution, which Spark does not use for transformations. D is wrong because the count must reflect the filter, so Spark has to apply it.
Practice question 6 · Spark
A Spark SQL job joins a 2 TB sales table with a 5 MB country lookup table, and the plan shows a sort-merge join that shuffles the sales table. What is the best fix?
- A. Repartition both tables by the join key before the join.
- B.
collect()the sales table to the driver and join it in a Python loop. - C. Increase
spark.sql.shuffle.partitionsso the shuffle is spread over more tasks. - D. Broadcast the small table, for example with a
BROADCASThint.
Show answer
Answer: D. The Spark performance tuning guide says tables below spark.sql.autoBroadcastJoinThreshold (10 MB by default) can be broadcast to all worker nodes, and lists BROADCAST as a join hint. The 2 TB side then joins locally without a shuffle.
A still shuffles the large table. B pulls 2 TB onto the driver. C only changes how the shuffle is split; it does not remove it.
Practice question 7 · Kafka
A Kafka topic has 6 partitions and events are keyed by customer_id. A classic consumer group with 8 consumer instances subscribes to it. Which statement is true?
- A. Two consumers get no partitions, and each customer’s events stay in order.
- B. Every event is delivered to all 8 consumers in the group.
- C. Kafka guarantees one global order for all events across the 6 partitions.
- D. Adding more consumers to the group always increases throughput, even beyond the number of partitions.
Show answer
Answer: A. The KafkaConsumer documentation says each partition is assigned to exactly one consumer in the group, so with 6 partitions only 6 of the 8 consumers get work. The Kafka introduction says events with the same key go to the same partition and are read in the order they were written, so per-customer order holds.
B describes separate groups; within one group an event goes to one consumer. C is wrong because ordering is only guaranteed within a partition. D is wrong because extra consumers beyond the partition count sit idle in a classic consumer group.
Practice question 8 · Stream processing
A Spark Structured Streaming query uses withWatermark("event_time", "10 minutes") before a windowed count. The maximum event time the query has seen so far is 12:21. Which watermark does the next trigger use?
- A. 12:21
- B. 12:11
- C. 12:31
- D. The current wall-clock time minus 10 minutes
Show answer
Answer: B. The Spark Structured Streaming guide sets the watermark as the maximum event time seen minus the lateness threshold, at the start of each trigger: 12:21 minus 10 minutes is 12:11.
A ignores the threshold. C adds the threshold instead of subtracting it. D uses processing time, but the watermark is based on event time in the data.
Practice question 9 · Airflow
A daily Airflow task runs INSERT INTO sales_daily SELECT ... for its data interval. It failed after writing part of the data, Airflow retried it, and the table now has duplicate rows. What is the best fix?
- A. Set
retries=0on the task so a partial load is never run a second time. - B. Turn on catchup so missed intervals are filled in.
- C. Make the task idempotent by replacing the rows for its data interval.
- D. Compute the load date with
datetime.now()in the Dag file’s top-level code.
Show answer
Answer: C. The Airflow best practices page says tasks should produce the same outcome on every re-run, warns that an INSERT on a re-run can cause duplicate rows, and recommends an upsert. Replacing the interval’s rows (delete and insert in one transaction, overwrite the partition, or upsert) gives the same result on every re-run.
A loses automatic recovery, and a manual re-run would still duplicate rows. B is about missed schedule runs, not duplicates. D makes results depend on when the code runs, not on the data interval.
Practice question 10 · Flink
A Flink job reads from Kafka with checkpointing in exactly-once mode and appends rows to a database through a plain, non-transactional sink. After a failure and restart, some rows appear twice in the database. Why?
- A. Exactly-once mode turns checkpointing off, so Flink cannot restore its state.
- B. Exactly-once covers Flink’s managed state, not this non-transactional sink.
- C. Kafka sources cannot be replayed, so Flink re-reads random offsets after a restart.
- D. The HashMap state backend always duplicates output; switching to RocksDB fixes it.
Show answer
Answer: B. The Flink fault tolerance guide says exactly-once means every event affects Flink-managed state exactly once. For end-to-end exactly-once, sources must be replayable and sinks must be transactional or idempotent, and this sink is neither.
A is wrong because exactly-once relies on checkpoints. C is wrong because Kafka is a replayable source: Flink resumes from the offsets stored in the checkpoint. D is wrong because the state backend changes where state is kept, not whether an external sink is transactional.
How did you score?
8–10 correct: you are ready for a full timed test, so try Exam Mode next. Under 8: go back to the topic areas you missed in the official docs linked above, then practise them again. The data engineering interview practice tests have 637 questions like these, each with a full explanation.
Common mistakes in data engineering interviews
Weak answers often ignore re-runs, ordering or current versions.
- Calling ZooKeeper a current Kafka component. Kafka 4.0 runs entirely without ZooKeeper, in KRaft mode. Mention ZooKeeper only for older clusters and migrations.
- Filtering on a window function in
WHERE. Compute it in a subquery or CTE first. - Promising global order in a Kafka topic. Order holds only within a partition, so key events that must stay in order.
- Writing pipelines that are not safe to re-run. Overwrite by partition or upsert by key.
- Treating “exactly once” as a property of one tool. End-to-end exactly-once depends on the source, the engine and the sink together.
Data engineering interview questions: FAQs
What do data engineering interview questions cover in 2026?
They cover SQL and indexing, data modelling, ETL and ELT, Apache Spark, Apache Kafka, stream processing, Apache Airflow, and data quality and governance. Expect current tool versions: the Apache Kafka 4.0 release announcement says Kafka now runs entirely without ZooKeeper.
Are there free data engineering interview practice questions?
Yes. This post includes 10 free data engineering sample questions with answers and explanations, covering SQL, indexing, modelling, Spark, Kafka, streaming and Airflow. For a full timed practice test, the Exametics data engineering interview practice tests have 6 tests and 637 questions.
How many questions are in the Exametics data engineering interview practice tests?
There are 6 practice tests with 106 to 107 questions each, 637 questions in total, including a timed Exam Mode test. Every question explains why the right answer is right and why the others are wrong.
Which topic should I study first for a data engineering interview?
Start with SQL, because modelling, Spark SQL and data quality checks all build on it. Then move to data modelling, Spark and Kafka, and finish with orchestration and data quality.
Is a data engineering interview hard, and how long should I prepare?
It is demanding because it mixes live SQL, system design and debugging scenarios. If you already work with data, two to three weeks of focused study is a realistic plan; allow more time if Spark or streaming is new to you.
Is there an official data engineering interview syllabus?
No. No single body publishes a data engineering interview syllabus, so each company sets its own topics. Vendors run their own certifications, such as the Databricks Certified Data Engineer Associate and the AWS Certified Data Engineer – Associate, which some candidates take alongside interview preparation.
Official documentation used: PostgreSQL 18, Apache Spark 4.3.0, Apache Kafka, Apache Flink 2.3 and Apache Airflow 3.4.0. Checked on 9 November 2026.
Practise for your data engineering interview
Work through 637 questions in six practice tests on SQL, modelling, Spark, Kafka, Flink, Airflow and data quality, with a full explanation for every answer and a timed Exam Mode test.
✓ Every answer explained · ✓ Timed exam mode · ✓ 30-day refund