roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for dbt interview questions on turning warehouse SQL into a tested, documented graph of models. Covers ELT, refs and materializations, tests, Jinja macros, snapshots and dimensional marts.
62 of 62 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 62 new. 0 cut, outside your plan.
dbt comes up most in analytics engineer loops, where it often carries the whole technical half, and in data engineer loops, usually inside a modeling or pipeline round. The common shape is a live SQL screen, then a take-home that turns a few raw tables into a small tested project or a modeling case on a whiteboard, then a conversation that walks back through what you built.
The questions are built from failures. An incremental model filters on the newest updated_at already in {{ this }}, and rows that arrive late never load. Every test is green and revenue is still doubled, because a join to a dimension with two rows per customer fanned out the orders. A macro that calls run_query breaks compilation until it checks execute, since nothing is queried while the project is parsed. A daily snapshot loses the middle value of a customer who changed tier twice between runs.
What separates levels is who owns the consequence. An entry-level candidate names the config that fixes the case. An experienced one says how the project should have caught it first: a uniqueness test on the declared grain, a lookback window on the incremental filter, a CI job that builds only changed models and their children with state:modified+ and defers the rest to production.
The opening module is the argument dbt rests on. Transformation placement explains why raw data is loaded into the warehouse first and reshaped there in SQL, and the same argument draws the tool's boundary: dbt transforms what has already landed, on the warehouse's own compute, and leaves extraction to other tools.
The dbt module follows the graph a project builds. Models and ref come first, because run order and the switch between development and production schemas both follow from replacing table names with a function call. Materializations decide what each node becomes, and incremental models are where most later failure questions begin. Sources and seeds then fix the graph's raw end, with freshness checks on what the loaders delivered.
Tests and documentation need a graph to attach to, so they follow it. Jinja and macros follow the tests, a placement that suits them: a macro is easiest to justify once you have pasted the same expression into several models, and you have been calling Jinja in every ref without asking when it is rendered. Snapshots close the module and bridge to the next, since the type 2 history they record is what a slowly changing dimension is built from.
The last module turns from the tool to what it should produce. Grain leads, since fact table design and most double counting come down to what one row means. Star and snowflake layouts follow as the question of how far to normalize dimensions, and marts with a semantic layer end the plan where the consumer starts: tables shaped for one team, metrics defined once instead of in every dashboard.
Two backgrounds arrive here with opposite gaps. An analyst with strong SQL knows models and refs from use and is thinnest where dbt borrows from software practice: tests in CI, macros, incremental configuration. An engineer from Spark or orchestrated Python reads the dbt module quickly and gets caught in the last one, where a modeling case asks for a grain before any column. If you have never run a project, the [dbt hub](/topics/data-dbt) shows how its parts depend on each other. Close to the loop, read the grain topic whole before anything else, because a modeling case that starts without a declared grain rarely recovers; then let importance, raised to must know, and level, narrowed to the band in the posting, decide what else gets drilled. With a month or more, build a small project as you study, on a free warehouse tier or a local DuckDB file, and switch study order to by topics, so the questions on each feature arrive about when your project first needs it. The plan assumes the SQL the models are written in, and stops short of the orchestrator that schedules a dbt run after the loads it depends on. Window functions and join behavior belong to the [SQL roadmap](/roadmaps/sql); the [Data Engineer roadmap](/roadmaps/data-engineer) places this plan inside the rest of that loop.
Two backgrounds arrive here with opposite gaps. An analyst with strong SQL knows models and refs from use and is thinnest where dbt borrows from software practice: tests in CI, macros, incremental configuration. An engineer from Spark or orchestrated Python reads the dbt module quickly and gets caught in the last one, where a modeling case asks for a grain before any column. If you have never run a project, the dbt hub shows how its parts depend on each other.
Close to the loop, read the grain topic whole before anything else, because a modeling case that starts without a declared grain rarely recovers; then let importance, raised to must know, and level, narrowed to the band in the posting, decide what else gets drilled. With a month or more, build a small project as you study, on a free warehouse tier or a local DuckDB file, and switch study order to by topics, so the questions on each feature arrive about when your project first needs it.
The plan assumes the SQL the models are written in, and stops short of the orchestrator that schedules a dbt run after the loads it depends on. Window functions and join behavior belong to the SQL roadmap; the Data Engineer roadmap places this plan inside the rest of that loop.