Data Engineering Study Plan (2026)

Your study time should match where interviews actually test you. 32.7% of rounds are phone-screen SQL. 20.7% are technical screens. 11.7% are onsite SQL. That means SQL alone accounts for over 44% of all rounds. Start there. Then layer Python, data modeling, and system design.

Based on DataDriven's analysis of verified interview data. Each plan includes specific topics, practice targets, and milestones calibrated to actual interview frequency.

2-Week Sprint

You have an interview in two weeks. Phone-screen SQL is the most common first round, so that is where you start. This plan focuses on the highest-frequency topics and cuts everything else. Budget 3-4 hours per day with one rest day per week.

Week 1: SQL Intensive

•Monday: Window functions. Solve 5 ROW_NUMBER and RANK problems. Time yourself at 15 minutes each. Review frame clauses (ROWS BETWEEN).
•Tuesday: Window functions continued. 5 problems using LAG, LEAD, and running totals. Practice writing PARTITION BY clauses from scratch.
•Wednesday: JOINs. 5 problems mixing INNER and LEFT JOIN. Focus on NULL behavior in LEFT JOINs. Then 3 self-join problems.
•Thursday: Aggregation. GROUP BY with HAVING, conditional aggregation using CASE WHEN inside SUM/COUNT. 5 problems.
•Friday: CTEs and subqueries. Chain 3+ CTEs in a single query. Practice correlated subqueries and EXISTS. 5 problems.
•Saturday: Mixed SQL. 8 problems across all topics, timed. Simulate interview conditions: no looking up syntax.
•Sunday: Rest day. Review your wrong answers from the week. Rewrite the hardest query from memory.

Week 2: Modeling, Design, Behavioral

•Monday: Data modeling. Normalization vs. denormalization. Design 2 schemas: an e-commerce system and an event tracking system.
•Tuesday: Star schemas and SCDs. Design a fact/dimension model for a subscription business. Practice explaining trade-offs out loud.
•Wednesday: Pipeline design. Study idempotency, orchestration, and error handling. Sketch 2 pipeline architectures on paper.
•Thursday: Behavioral prep. Write 6 STAR stories covering: a production incident, a cross-team project, pushing back on a requirement, debugging under pressure, a project you led, a failure you learned from.
•Friday: Mock interview 1. Full timed SQL round (3 problems in 45 minutes) + 1 pipeline design (30 minutes).
•Saturday: Mock interview 2. Full timed round. Address weak spots from Friday. Review and revise behavioral stories.
•Sunday: Rest. Light review only. Read through your STAR stories once. Get sleep.

8-Week Standard

You are switching into data engineering from a related role. SQL and Python get the most time since they dominate DE interview loops. Data modeling and system design fill the later weeks. Budget 1.5-2 hours per day, 6 days per week. Every Sunday is a rest day.

Weeks 1-2: SQL Foundations

•Week 1 daily schedule: Mon/Wed/Fri = 5 new problems (SELECT, WHERE, ORDER BY, JOINs). Tue/Thu = review and redo problems you got wrong. Sat = 8 mixed problems timed.
•Week 2 daily schedule: Mon/Wed/Fri = 5 JOIN problems (INNER, LEFT, FULL OUTER, CROSS, self-joins). Tue/Thu = aggregation practice (GROUP BY, HAVING, conditional logic). Sat = 8 mixed problems timed.
•Target by end of week 2: You can write a 3-table JOIN with GROUP BY and HAVING from scratch in under 10 minutes.
•Sunday: Rest. No SQL. Go outside.

Weeks 3-4: Intermediate SQL

•Week 3 focus: Window functions only. Mon = ROW_NUMBER and RANK. Tue = DENSE_RANK and NTILE. Wed = LAG and LEAD. Thu = running totals and averages. Fri = frame clauses (ROWS BETWEEN). Sat = 8 window function problems timed.
•Week 4 focus: CTEs, subqueries, NULLs. Mon/Tue = CTEs and recursive queries. Wed/Thu = scalar and correlated subqueries, EXISTS. Fri = COALESCE, NULLIF, three-valued logic. Sat = mixed intermediate problems.
•Target by end of week 4: You can chain CTEs with window functions and handle NULLs correctly on the first try most of the time.
•Sunday: Rest.

Weeks 5-6: Python for Data Engineering

•Week 5 daily schedule: Mon = lists and list comprehensions (5 problems). Tue = dicts and dict operations (5 problems). Wed = sets and string manipulation. Thu = file I/O and JSON parsing. Fri = CSV processing and error handling. Sat = build a small ETL script from scratch.
•Week 6 daily schedule: Mon/Tue = write functions that parse nested JSON and deduplicate records. Wed/Thu = write code that joins two datasets by key using only built-in Python. Fri = edge case practice (empty inputs, missing keys, type mismatches). Sat = timed Python problems.
•Target by end of week 6: You can write a data transformation function in Python with error handling in under 20 minutes.
•Sunday: Rest.

Weeks 7-8: Modeling, Design, Behavioral, Mocks

•Week 7: Mon/Tue = data modeling (normalization, star schemas, SCDs). Design 4 schemas for different business domains. Wed/Thu = pipeline system design. Sketch 3 pipelines on paper with failure handling. Fri = behavioral prep. Write 8 STAR stories. Sat = rehearse stories, time each at under 3 minutes.
•Week 8: Mon = mock SQL round (timed). Tue = mock pipeline design (timed). Wed = drill weak spots from mocks. Thu = second mock round. Fri = final review of all topics. Sat = full mock interview loop (SQL + design + behavioral).
•Target by end of week 8: You can complete a full mock interview loop and feel confident in every round.
•Sunday: Rest.

16-Week Thorough

You are starting from scratch or switching from a non-technical role. The first 6 weeks build SQL fluency. Weeks 7-11 build Python skills. Weeks 12-16 cover modeling, system design, and behavioral prep. Budget 1-1.5 hours per day, 5 days per week. Weekends are rest days.

Weeks 1-3: SQL Basics

•Week 1: SELECT, FROM, WHERE, ORDER BY, LIMIT. Understand what a relational database is. 3 problems per day, Mon-Fri.
•Week 2: JOINs from first principles. Draw Venn diagrams. Solve 4 JOIN problems per day. Focus on understanding when LEFT JOIN produces NULLs.
•Week 3: GROUP BY, HAVING, aggregate functions. Conditional aggregation with CASE WHEN inside SUM and COUNT. 4 problems per day.
•Weekends: Rest. If you want to review, rewrite one query from the week from memory. That is it.

Weeks 4-6: Intermediate SQL

•Week 4: Subqueries (scalar, correlated, EXISTS). 3 problems per day. Practice rewriting subqueries as JOINs and back.
•Week 5: Window functions. Spend the entire week here. Mon = ROW_NUMBER/RANK. Tue = LAG/LEAD. Wed = running totals. Thu = NTILE and percentiles. Fri = mixed window problems.
•Week 6: CTEs, recursive queries, NULL handling, date functions. Round out your SQL toolkit. 4 problems per day covering all of these.
•Weekends: Rest.

Weeks 7-9: Python Fundamentals

•Week 7: Variables, types, control flow, functions. Write one small script per day (e.g., a function that validates email formats, a function that counts word frequencies).
•Week 8: Lists, dicts, sets, comprehensions, string manipulation. 3 problems per day.
•Week 9: File I/O, JSON, CSV, error handling with try/except. Build a small ETL script that reads a JSON file, transforms the data, and writes CSV output.
•Weekends: Rest.

Weeks 10-11: Python for Data Engineering

•Week 10: Working with APIs, HTTP requests, pagination, rate limit handling. Build a script that fetches paginated data from a public API.
•Week 11: Testing, logging, and writing maintainable pipeline code. Add tests and logging to the scripts you wrote in weeks 9-10.
•Weekends: Rest.

Weeks 12-13: Data Modeling + Pipeline Design

•Week 12: Mon/Tue = 1NF through 3NF with examples. Wed/Thu = star schemas and fact/dimension tables. Fri = SCDs (Type 1, 2, 3). Design 2 schemas from scratch.
•Week 13: Mon/Tue = pipeline architecture and orchestration basics. Wed = backfill strategies. Thu = schema evolution. Fri = design a complete pipeline on paper.
•Weekends: Rest.

Weeks 14-16: System Design + Behavioral + Full Mock Loops

•Week 14: System design deep practice. Design 5 pipelines end-to-end on paper (CDC ingestion, event streaming, daily batch ETL, reverse ETL, feature serving). Practice explaining each in 20 minutes.
•Week 15: Behavioral prep. Write and rehearse 10 STAR stories. Record yourself delivering each one and review the recordings. Time each at under 3 minutes.
•Week 16: Full mock interview loops. Mon = SQL mock. Tue = pipeline design mock. Wed = fix weak spots. Thu = behavioral mock. Fri = full end-to-end mock loop. Do at least 3 complete rounds this week.
•Week 16 Saturday: Light review of your notes. Get sleep before the real thing.

How to Know When You Are Ready

12 min

SQL benchmark

You can solve a medium-difficulty window function problem in under 12 minutes without looking anything up.

25 min

Pipeline design benchmark

You can sketch a pipeline architecture on a whiteboard in 25 minutes that includes ingestion, transformation, loading, error handling, and monitoring.

3 min

Behavioral benchmark

You can tell 5 different stories from memory, each under 3 minutes, covering collaboration, failure, debugging, trade-offs, and initiative.

Mock interview benchmark

You have completed at least 2 timed mock interview rounds and received feedback. If your mock interviewer says "I would hire you," you are ready.

Common Study Plan Mistakes

Reading instead of writing. Watching tutorials and reading solutions feels productive but does not build the muscle memory you need. For every hour of reading, spend two hours writing actual queries and code. If you cannot solve a problem without looking at the answer, you have not learned it yet.

Ignoring system design until the last week. System design questions require a different kind of preparation than SQL. You need to practice structuring your thoughts, drawing architectures, and reasoning about trade-offs out loud. Start practicing pipeline design by the halfway point of your plan.

Skipping behavioral prep entirely. Many candidates assume behavioral is "just talking" and skip preparation. Then they ramble, give vague answers, or cannot think of examples under pressure. Write your stories down. Rehearse them. Time them.

Studying too many topics at surface level. It is better to know window functions deeply than to have seen 20 topics once. Interviewers test depth, not breadth. Focus on the topics listed in your plan and resist the urge to add more until you have mastered the core set.

Study Plan FAQ

Which study plan should I choose?+

If you have an interview scheduled within 3 weeks, use the 2-week sprint. If you have 2-3 months and some technical background, the 8-week standard is right. If you are new to data engineering or want to be thorough, the 16-week plan builds everything from the ground up. You can always start with the 8-week plan and extend it if you need more time on specific topics.

How many hours per day should I study?+

The 2-week sprint assumes 3-4 hours per day. The 8-week standard works with 1.5-2 hours per day. The 16-week thorough plan needs about 1-1.5 hours per day. Consistency matters more than volume. Studying 1 hour every day for 8 weeks beats cramming 8 hours on weekends.

Should I study SQL or Python first?+

SQL first, always. It is the single most-tested skill in data engineering interviews, and phone-screen SQL is the most common round type. If you are short on time, SQL proficiency gives you the highest return. The top SQL concepts by frequency: aggregation, JOINs, and window functions. Once your SQL is solid, layer in Python.

How do I know when I am ready for interviews?+

You are ready when you can solve a medium-difficulty SQL window function problem in under 12 minutes, design a basic pipeline architecture in 25 minutes with failure handling, and tell 3 behavioral stories without reading notes. If any of those feel shaky, drill that specific area for another week.