Black Friday Flash Sale:

50% OFF ALL PRODUCTS
Ends in--d--h--m--s
COUPON:BLACKFRIDAY50

Data Engineering Interview Questions 2026: 10 Free with Answers

Data Engineering Interview Practice tests
In this article

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

TopicData engineering interviews and technical screenings
Levels coveredJunior, mid-level and senior
Core topicsSQL, modelling, Spark, Kafka, streaming, Airflow
Kafka todayNo ZooKeeper since Apache Kafka 4.0 (KRaft mode)
Official syllabusNot published: no single body sets one
Exametics set6 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.autoBroadcastJoinThreshold defaults 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_HASH and SHUFFLE_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

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.

LevelWhat you should be able to do
JuniorWrite joins, aggregations and window functions; explain fact and dimension tables; describe ETL versus ELT; explain what Spark, Kafka and Airflow are for.
Mid-levelTune a slow query or Spark job, build incremental and idempotent loads, choose partition keys, handle late data and write data quality checks.
SeniorDesign 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

See all interview questions practice tests →

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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

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 HAVING clause after GROUP 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.

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'

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_city column 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.

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.

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.partitions so the shuffle is spread over more tasks.
  • D. Broadcast the small table, for example with a BROADCAST hint.

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.

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

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=0 on 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.

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.

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

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.

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.

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.

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.

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.

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

Ready to test yourself?

Take timed, exam-style practice tests and see exactly which domains need more work before exam day.

Share this article

Leave a Comment

All-Access Pass
Practise for 800+ certification exams

Timed, exam-style tests with an explanation for every answer. Lifetime access.

₹18,808
Related practice tests
Practice Test

Price range: ₹944 through ₹1,416

Select options This product has multiple variants. The options may be chosen on the product page
Practice Test
6 practice tests
360 questions

Price range: ₹944 through ₹1,416

Select options This product has multiple variants. The options may be chosen on the product page
In this article

Keep reading

Get new exam guides in your inbox

One short email when we publish new guides and practice tests. No spam.

Shopping Cart
Scroll to Top