Most data engineering interviews are SQL puzzles on a clean, well-behaved table. Write a window function, join three tables, find the second-highest salary. The candidate who has drilled these does well, and then joins your team and freezes the first time a pipeline fails because a source changed its schema overnight.
Real data work is not writing queries against tidy data. It is dealing with data that is late, malformed, duplicated, or silently wrong, inside a pipeline that has to keep running. That is the thing to interview for, and a SQL quiz never touches it.
Why the SQL quiz misses the job
A clean SQL question tests whether someone knows the syntax. Useful as a floor, but the hard part of data engineering is almost never the query. It is:
- noticing the numbers are wrong before a stakeholder does
- tracing a bad metric back through several transformation steps
- deciding what to do with rows that violate an assumption
- keeping a job idempotent so a re-run does not double-count
None of those show up when the data is perfect and the job already works. You have to break something.
Give them a pipeline that is failing
The strongest data engineering interview is a small but real pipeline that runs and produces wrong output, plus the tools to inspect it and a brief: "the daily revenue number is coming out too high, the pipeline is green, find out why and fix it."
Good broken scenarios for data work:
- Dirty input that violates an assumption. Duplicate rows from an upstream retry, a null where the code assumes a value, a currency field that switched format. Tests whether they validate input or trust it.
- A silent join fan-out. A one-to-many join that inflates a sum. The job succeeds, the number is wrong. Tests whether they can reason about grain and cardinality, which is the actual skill.
- A non-idempotent job. A pipeline that double-counts when re-run. Tests whether they understand why that matters and how to fix it.
- A broken DAG dependency. A task that runs before its input is ready, so it processes stale or partial data. Tests whether they understand orchestration, not just transformation.
- A schema drift. An upstream column renamed or retyped, breaking a downstream step quietly. Tests whether they build for change or for today.
The unifying trait: the job does not crash. It produces a plausible, wrong answer. Distinguishing "wrong" from "crashed" is most of the discipline.
What to watch for
Score the investigation, not the final query:
- Do they validate before they trust? Strong data engineers check row counts, look for duplicates, and sanity-check totals before assuming the logic is the problem.
- Do they reason about grain? The moment they say "wait, what is one row supposed to represent here," you are talking to someone who has been burned by a fan-out before.
- Do they trace, not guess? Following a wrong number backward through each transformation, checking the output of each step, versus randomly rewriting SQL.
- Do they think about re-runs and failure? "What happens if this runs twice" and "what happens if the source is late" are questions a production data engineer asks reflexively.
- Do they consider the blast radius of the fix? Backfills and reprocessing are dangerous. Do they think about what the fix does to historical data?
The anti-signal is a candidate who dives straight into rewriting the transformation without ever confirming what the data actually looks like, and calls it done when the number changes, without checking it is now correct.
Scoring it cleanly
As with any hands-on assessment, write down the behaviors so two interviewers agree (see how to write a technical interview rubric):
- Did they inspect the data before touching the code?
- Did they correctly identify the cause (grain, dirty input, non-idempotency) rather than patch a symptom?
- Was the fix correct and safe to re-run, or would it break on the next load?
- Did they consider historical/backfill impact?
- Could they explain, at the end, exactly why the number was wrong?
A candidate who finds and explains the fan-out but runs out of time before writing the perfect fix beats one who rewrites the query until the number looks right without understanding why.
Why a real pipeline beats a SQL editor
You cannot stage a schema drift or a non-idempotent re-run in a query box. The signal lives in a running pipeline with real orchestration and messy data.
EasyEnv runs the candidate in a real environment with a genuinely broken pipeline and records the session, so the panel can review how they moved from "the number is wrong" to "here is why." That recording is far more useful than a final SQL file, because in data engineering the answer matters less than whether the person can be trusted to notice when the data lies.
The takeaway
Data engineering is not clean SQL on clean data. It is catching and fixing wrong answers in a pipeline that keeps running.
Give the candidate a pipeline that is quietly lying, and watch whether they catch it.