10 data engineering cheat sheets: the concepts every pipeline interview assumes
Data engineering interviews rarely ask for syntax. They probe whether you hold the core distinctions: ETL vs ELT, batch vs streaming, star vs snowflake, idempotent reruns. Here are 10 free one-page references that cover the conceptual layer every pipeline conversation assumes.
Data engineering interviews have a strange shape. They rarely ask you to write much code. Instead they probe distinctions: what actually separates ETL from ELT, when streaming is worth its cost, why a retry loaded every order twice. These are one-page ideas, which makes one-page references the right way to hold them. Here are 10 free cheat sheets covering the conceptual layer that every pipeline interview, and every real pipeline, quietly assumes you have.
The 10 sheets at a glance:
- ETL vs ELT
- Batch vs streaming
- Warehouse vs lake vs lakehouse
- OLTP vs OLAP
- Star vs snowflake
- Fact vs dimension tables
- Database keys explained
- Idempotency
- dbt basics
- Git for data
Architecture: the four decisions behind every stack
Every data platform is a stack of choices, and interviewers love asking you to defend them. These four sheets are the decisions themselves.
ETL vs ELT
One question decides your tooling, your costs, and who shapes the data: does Transform run before or after loading? The full comparison, and where dbt fits.
Batch vs streaming
Nobody needs real-time; they need a freshness number nobody asked for. The one question that settles the choice, the honest cost gap, and the micro-batch middle.
Warehouse, lake, lakehouse
Schema on write vs schema on read drives everything else. What separates the three architectures, the questions that pick between them, and the data swamp trap.
OLTP vs OLAP
Why the database that runs your app is the wrong place for dashboards. Row vs column storage, and the prod-DB trap that slows production.
Read them as a set: ETL vs ELT, batch vs streaming, warehouse vs lake vs lakehouse, and OLTP vs OLAP. Together they let you sketch a defensible architecture on a whiteboard, which is precisely what design rounds ask for.

Modeling: how warehouses are actually shaped
Modern tools automate the plumbing; nobody has automated the decision of what your tables should look like. Modeling questions are where pipeline interviews get concrete.
Star vs snowflake
The two classic warehouse shapes, when each wins, and the vocabulary interviewers expect, with diagrams. Star is usually faster; here is exactly why.
Fact vs dimension
The two-question test that sorts any column into fact or dimension in five seconds, and the join pattern behind every BI query.
Keys, explained
Primary, foreign, surrogate, composite: the four kinds of keys, why surrogates win the primary-key job, and what ON DELETE CASCADE really deletes.
The set: star vs snowflake, fact vs dimension tables, and database keys explained. Design a schema for an online store is a near-universal interview prompt, and these three pages are the complete answer: a fact table of orders, dimensions for customers and products, surrogate keys tying it together.

Pipelines and practice: what production actually demands
The last cluster is what separates people who have run pipelines from people who have read about them: reliability and workflow.
Idempotency
One timeout, one retry, every order loaded twice. Why plain INSERT is a loaded gun, and the three patterns, MERGE, partition overwrite, run-id dedupe, that make reruns free.
dbt basics
Models as SELECTs, ref() and the DAG it builds, two-line data tests, and the three materializations that cover real projects. dbt on one page.
Git for data
The daily loop, branches, the three ways to undo, and the .gitignore hygiene that keeps 2 GB CSVs and API keys out of your public repos.
Start with idempotency; the question what happens when your pipeline runs twice is the single best filter interviewers have for real experience. Then dbt basics, because dbt is now the default transform layer in ELT stacks, and git for data, because your pipeline code is only as trustworthy as its history.

Ask a candidate what happens when their pipeline runs twice. People who have operated real systems flinch, then answer in patterns. People who have only watched courses say it runs again.
How to use these sheets so they actually stick
Ten one-pagers can be skimmed in an evening, and skimming will get you almost nothing. Concepts feel understood long before they are usable. Use the sheets in three passes.
- 1
Read for the distinction
Each sheet is built around a single distinction. Your first pass is done when you can state it in one plain sentence, the way you would to a colleague.
Questions to ask- One sheet, one core contrast
- Say the difference out loud in one sentence
- If you can't, reread just that part
- 2
Drill with recall, not rereading
Reproduce the star schema diagram, the ETL vs ELT table, the three idempotency patterns from a blank page. The gaps you find are the actual studying.
Questions to ask- Close the sheet
- Redraw the diagram or table from memory
- Note what you missed, retry tomorrow
- 3
Build something that forces the concepts
A pipeline that survives a double run teaches idempotency better than ten rereads. And it becomes the story you tell when the interviewer says walk me through something you built.
Questions to ask- A small end-to-end pipeline on real data
- Modeled, tested, version controlled, rerunnable
- Public, so an interviewer can open it
That third step is the honest one. Cheat sheets cover the layer interviews assume; they do not create the experience interviews reward. These concepts only start counting once they exist inside a project someone can open: a scheduled ingest, a star schema, dbt models with tests, a repo with a clean history. If you need a concrete starting point, our list of data portfolio project ideas includes engineering-flavored builds, and the DA, DS, DE, BA breakdown helps if you are still choosing the engineering path at all. Learn the distinctions from the sheets. Then go build the thing that proves you own them.