Data Engineer Mock Interview
Practice the exact SQL and Python questions top tech companies ask, along with their Spark questions and their data modeling and pipeline architecture rounds. Write real code and get line-by-line AI feedback while the simulator tracks your weak spots across all 5 interview domains.
The whole loop a mock should prepare you for
A data engineer loop is 5 to 7 touches, and candidates get cut at very different stages. A good mock rehearses the round where you're actually weak, not just the one you enjoy. Bar height is the share of candidates still in the running.
Recruiter screen
Background, motivation, level, logistics. A gate, not a test. Nearly everyone who applies and matches gets here.
Technical screen
Live SQL and Python in a shared editor. The biggest single cut, before a human reads deeper. A mock of this round is the highest-leverage practice.
Onsite loop
SQL, Python, data modeling, pipeline design, behavioral. The panel weighs your trade-offs and how you argue them, not just a green test.
Debrief
Interviewers compare notes and set level. Consistency across rounds matters as much as any single strong one.
Offer
Level sets the band. The gap between a screen-out and an offer is mostly closed in the SQL and modeling rounds.
Where a modeling round gets decided
The data modeling round decides more senior loops than any other, and practicing alone gives you nobody to push on your schema the way a reviewer will. A mock has to argue with the design. Here is a representative prompt and the difference between a pass and a rejection.
Design the schema for a subscription business. How do you track a customer who upgrades, downgrades, then churns?
States the grain first ("one row per subscription state change"), models the change history as an SCD Type 2 on the plan dimension with effective and expiry dates, and keeps revenue in an additive fact so MRR rolls up cleanly.
Defends the choice under pushback: explains why a mutable "current_plan" column would destroy the history the business needs, and joins facts on the surrogate key so past invoices keep the plan that was true at the time.
Stores customers.current_plan as a single column and overwrites it on every change, so the upgrade and downgrade are gone and churn analysis is impossible.
Never states the grain, so the interviewer cannot tell what one row means, and cannot answer "what was MRR last March" without the history the model threw away.
Why mock interviews change your outcome
Reading questions and hints comes first, and then you have to implement them under time pressure with feedback.
Reading solutions does not substitute for active practice
Reviewing 500 SQL solutions does not transfer cleanly to writing one from a blank editor under time pressure. Mock interviews force active recall: write the query, run it, debug, iterate. Pulling an answer out of memory makes it stick better than rereading it, and the research on retrieval practice often finds the gap is wide.
Self-assessment tends to miss the actual weak areas
Candidates routinely overestimate SQL fluency and underestimate data modeling. 3 weeks of grinding window functions doesn't help when the actual gap is articulating SCD Type 2 tradeoffs out loud. A simulator that spans all 5 domains shows those blind spots in the first session, then measures accuracy by subtopic over the next 20 questions.
Interview conditions change the kind of errors that appear
Writing SQL at a desk with documentation open is a different task from writing it in 25 minutes with an interviewer watching. Time pressure produces specific failure modes: dropped PARTITION BY clauses, missing NULL handling, untested joins. Timed mock sessions bring those mistakes out in practice, before the onsite.
Tight feedback loops accelerate improvement
Solo practice produces a write-check-move-on loop that misses subtler issues: an O(n^2) approach when O(n) was available, a LEFT JOIN that silently drops rows. The AI reviewer names the exact case and why it bites. Over dozens of sessions, that edge over checking your own work compounds.
5 domains, 1,569 questions
A typical DE interview loop includes 2 coding rounds (SQL and Python), 1 data modeling round, and 1 system design round. Some companies add a Spark-specific round. DataDriven covers all 5.
SQL
Window functions, CTEs, joins, aggregations, and subqueries executed against a real database. The AI checks correctness, edge case coverage, and query performance. Every question runs your actual SQL, not multiple choice. Topic breakdown: Window functions 34%, Joins 28%, Aggregation 22%, CTEs 10%, Subqueries 6%
Python
Data manipulation, ETL logic, file parsing, API handling, and pandas. Code executes in a sandbox with access to pandas, numpy, and the standard library. Your answer is scored on correctness, edge case handling, and adherence to Pythonic patterns. Topic breakdown: Data manipulation 40%, ETL logic 25%, File parsing 15%, API handling 10%, Pandas 10%
Data Modeling
Star schema design, fact vs dimension tables, slowly changing dimensions, data vault, and medallion architecture. The AI interviewer asks follow-up questions based on your answers, exactly like a real discussion round. Topic breakdown: Star schema 30%, SCDs 20%, Normalization 20%, Data vault 15%, Medallion 15%
Pipeline Architecture
Batch vs streaming, idempotency, orchestration, failure handling, and schema evolution. System design rounds where the AI probes your reasoning with follow-up questions that get harder as you answer correctly. Topic breakdown: Batch vs stream 25%, Reliability 25%, Orchestration 20%, Schema evolution 15%, Scaling 15%
Spark
Partitioning strategy, shuffle optimization, broadcast joins, UDFs, and Spark SQL. Questions target the performance tuning and debugging that interviewers care about, not just API syntax. Topic breakdown: Partitioning 30%, Joins 25%, Performance 20%, SQL 15%, Streaming 10%
How the mock interview simulator works
4 steps from picking a domain to working your weak spots.
- 01
Pick a domain and difficulty
Choose a coding domain like SQL or Python, or a design domain like Data Modeling or Pipeline Architecture. Spark is the 5th option. Set your target difficulty from entry-level to staff engineer. The simulator selects questions matching your profile.
- 02
Code or discuss in real time
SQL and Python rounds open a full code editor where your code runs for real against real data. Data modeling and pipeline rounds use a discussion format where the AI asks follow-up questions based on your answers. Timer optional.
- 03
Get AI feedback line by line
Feedback looks at correctness and edge cases, and it also comments on performance, code style and how clearly you communicate. Your SQL or Python code executes, and the results show right away where it broke. In discussion rounds, the AI looks at how complete your reasoning is and how far it goes.
- 04
Review weak spots and drill them
After each session, you get a breakdown by topic. We track your accuracy over time and surface the topics where you're weakest. You work the weak topics directly, before the real loop finds them for you.
4 scorecard signals candidates routinely miss
DE interviewers at FAANG describe the same evaluation criteria as those at fintechs and high-growth startups, and candidates tend to underweight them.
Recognizing the shape of a problem beats recall
Most DE interviews cycle through roughly 40 core question patterns dressed up as hundreds of variations. The candidate who recognizes that a 'find consecutive events' prompt is a gaps-and-islands problem can solve it in roughly 12 minutes, while the candidate who brute-forces it runs out of time. DataDriven groups questions by pattern, so you learn to spot the pattern instead of chasing each variant.
Edge cases carry significant weight
A query that produces the right output on sample data leaves several questions open: does it handle NULLs, does it survive duplicate timestamps, does it return the right answer on an empty table. Interviewers at Google and Amazon give real partial credit according to how many edge cases a solution handles. The AI reviewer reports which cases passed and which broke, with the specific failing input.
Communication carries about half the weight
Internal scorecards at most large companies separate problem solving from communication and weight them comparably. Explaining the approach before coding, naming a tradeoff out loud, walking through why you picked one design over another: all of it counts. The discussion-mode rounds in the simulator practice this directly, with follow-up questions that probe how deep the response goes, not just the initial answer.
Speed distinguishes seniority levels
A mid-level candidate may solve a medium SQL problem in 25 minutes. A senior candidate solves the same problem in 10 minutes and spends the remaining 15 discussing edge cases and how the query would scale after optimization. The simulator tracks solve time per question and per topic; topics where solve time runs long get flagged for another pass.
DataDriven vs alternatives
How the simulator stacks up against a human coach and LeetCode, and against practicing alone.
| Feature | DataDriven | Coach ($150/hr) | LeetCode | Solo Practice |
|---|---|---|---|---|
| Data engineering questions | 1,569 across 5 domains | Varies by coach | < 50 DE-specific | You find them yourself |
| Real code execution | Real SQL + Python execution | Depends on setup | Generic SQL engine | Local setup required |
| AI scoring + feedback | Line-by-line, every question | Human review (limited time) | Pass/fail only | None |
| Discussion rounds | AI follow-up questions | Yes (best format) | Not available | Not possible |
| Cost | Open to every member | Hourly coaching fees | Paid subscription | Free |
| Availability | 24/7, unlimited sessions | Scheduling required | 24/7 | 24/7 |
| Tracks weak spots | Automatic topic tracking | Manual notes | Basic stats | Spreadsheet if disciplined |
Where the questions come from
Every question was asked in a real data engineering interview, written with reference to internal scorecards, and calibrated to real round time budgets.
Sourced from interview reports at 281 companies
Every question here comes from interview reports submitted by candidates who interviewed at Meta, Google, Amazon, Netflix, Uber, Airbnb, Stripe, Snowflake, Databricks, and hundreds of other companies (281 represented at last count). Questions target the most frequently observed patterns rather than offering a random selection; each question ties to a pattern that recurs across those reports.
Authored with reference to interviewer scorecards
The questions and scoring rubrics here are written with input from data engineers who have conducted interviews at large tech companies, using the structure of internal scorecards as a reference. Hints, evaluation criteria, and follow-up prompts reflect how interviewers score candidates in practice rather than the more generic feedback most coding platforms provide.
Difficulty calibrated to interview-round time budgets
Questions are rated Easy, Medium, and Hard based on the time and depth observed in real interview rounds rather than academic complexity. A Medium question targets 15 to 25 minutes of solve time, matching the per-question budget in a 45-minute coding round after accounting for intros and discussion. A Hard question targets the senior and staff bands.
A plan for the mocks, by how long you have
Mocks work best on a schedule. The order that holds up across the loop: SQL and Python to fluency first, then modeling, then design, then full mock loops, with behavioral last. Pick the track that matches your runway.
2-week sprint+
SQL reflexes + 1 mock a day
Drill the highest-frequency SQL patterns, timed, 2 problems a day, plus 1 full mock. Do not start a new tool this close in. Prioritize the rounds that carry the most weight.
Modeling + a full mock loop
3 worked schemas defended out loud, DE-style Python on messy input, then a timed end-to-end mock with a hire/no-hire verdict. Rehearse 2 behavioral stories in first person.
8-week plan+
SQL and Python to fluency
Weeks 1-2. Rebuild both to reflex on real interview problems, timed, with hidden-test discipline. This is the base everything else sits on.
Data modeling, drawn and defended
Weeks 3-5. At least 10 data modeling problems, grain stated first, each trade-off defended against pushback. The round that decides most senior loops.
Pipeline design, out loud
Weeks 6-7. 15-plus design prompts practiced aloud: ingest to serve, failure modes, re-runnability, orchestration named. Lead the conversation and surface trade-offs unprompted.
Mocks and behavioral rehearsal
Week 8. 4 to 6 full mock loops out loud, weighted to your weakest domain, plus behavioral stories in first person with quantified impact. Taper, do not cram new material.
Frequently asked questions
What is a data engineer mock interview?+
How many questions does DataDriven have?+
Is DataDriven better than hiring a mock interview coach?+
Does the code execute, or is it pattern-matched?+
How is DataDriven different from LeetCode for data engineering?+
What level of experience is DataDriven designed for?+
Start a mock interview
- 01
Reading a solution is not the same as writing one
Every engineer who has frozen on a query they had read a dozen times knows the gap. The only preparation that closes it is producing the answer yourself, under time, before the interview does it for you
- 02
76% of hiring managers reject on the coding task, not the resume
From HackerRank's 2024 Developer Skills Report. Candidates who look strong on paper still fail the live screen if they haven't done timed, executable practice
- 03
5 problem shapes cover 80% of data engineer loops
Dedup, sessionization, top-N-per-group, slowly-changing dimensions, partition tricks. Writing the shapes by hand turns the unfamiliar into pattern recognition
Related mock interview guides
SQL Mock Interview for Data Engineers
SQL interview patterns with window functions and CTEs, practiced against real SQL execution.
Python Mock Interview for Data Engineers
Practice Python data manipulation and ETL logic, including file parsing, with real code execution.
Data Modeling Mock Interview
Star schema and data vault design, including SCDs, with AI follow-up questions in discussion mode.
The weekly data challenge
Dirty, production-shaped data, scored blind each week.