Why models are the core of dbt - Visual Breakdown

Concept Flow - Why models are the core of dbt

Write SQL SELECT query

↓

Create a dbt model file (.sql)

↓

dbt compiles model into SQL

↓

dbt runs model to create table/view

↓

Model becomes a reusable dataset

↓

Other models can reference this model

↓

Builds a dependency graph

↓

Enables incremental, testing, documentation

Models in dbt are SQL files that define datasets. They are compiled and run to create tables or views, forming the core reusable data building blocks.

Execution Sample

dbt

select * from raw.sales
where sale_date >= '2024-01-01'

This SQL defines a model that filters sales data from January 1, 2024 onward.

Execution Table

Step	Action	Input/State	Output/Result
1	Write SQL query	Raw sales table	SQL query with filter on sale_date
2	Save as model file	SQL query	File models/sales_filtered.sql created
3	dbt compile	Model file	Compiled SQL ready for execution
4	dbt run	Compiled SQL	Table/view sales_filtered created in warehouse
5	Reference model	sales_filtered	Other models can use sales_filtered as source
6	Build dependency graph	All models	Graph showing model dependencies
7	Enable testing and docs	Models and graph	Tests and docs generated for models

💡 All models compiled and run, dependency graph built, enabling testing and documentation

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
SQL query	None	select * from raw.sales where sale_date >= '2024-01-01'	Same	Same
Model file	None	models/sales_filtered.sql created	Same	Same
Compiled SQL	None	None	Compiled SQL ready	Same
Table/view in warehouse	None	None	sales_filtered created	Same
Dependency graph	Empty	Empty	Empty	Graph with sales_filtered node

Key Moments - 3 Insights

Why do we write SQL files as models instead of running SQL directly?

Because dbt compiles and runs these SQL files to create reusable tables or views, enabling dependency management and testing, as shown in steps 1-4 of the execution table.

How does referencing one model in another help?

Referencing builds a dependency graph (step 6), so dbt knows the order to run models and can manage incremental updates and testing.

What happens after dbt runs a model?

The model creates a table or view in the data warehouse (step 4), which becomes a dataset other models or analysts can use.

Visual Quiz - 3 Questions

Look at the execution table, what is created after step 4?

A A table or view in the warehouse

B A compiled SQL file

C A dependency graph

D A test report

💡 Hint

Check the Output/Result column at step 4 in the execution table

At which step does dbt build the dependency graph?

A Step 3

B Step 6

C Step 5

D Step 7

💡 Hint

Look for 'Build dependency graph' in the Action column of the execution table

If you change the SQL query in the model file, which step must you run again to update the table?

A Step 1

B Step 3

C Step 4

D Step 7

💡 Hint

Step 4 runs the compiled SQL to create or update the table/view

Concept Snapshot

dbt models are SQL files defining datasets.
They compile into SQL run in your warehouse.
Models create tables or views.
Models build a dependency graph.
This enables testing, docs, and incremental builds.

Full Transcript

In dbt, models are the core because they are SQL files that define datasets. You write a SQL query and save it as a model file. dbt compiles this SQL and runs it to create tables or views in your data warehouse. These tables become reusable datasets. Other models can reference these datasets, which builds a dependency graph. This graph helps dbt run models in the right order and supports testing and documentation. The execution steps show writing SQL, saving as a model, compiling, running to create tables, referencing models, building the graph, and enabling tests and docs. Understanding this flow helps beginners see why models are central to dbt's power.