As a contract knowledge engineer, I typically expertise — ahem — let’s simply say, intervals of inactivity. After I browse the net marketplace for appropriate roles throughout these instances, some of the in-demand abilities I preserve seeing is expertise with a instrument known as dbt.
So, to provide myself the absolute best likelihood of acquiring work, I made a decision to study as a lot about dbt as I assumed I wanted to, to no less than be assured sufficient to speak about it normally phrases to a fellow techie at an interview stage ought to the necessity come up. This text distils that course of and what I’ve learnt. In fact you may’t study a topic simply by studying about it, in order normal, I am going to present loads of sensible code and real-world examples.
To be clear, I’ve no affiliation or business affiliation with dbt, DuckDB, or their creators.
dbt Core is a free open-source software program launched beneath the Apache 2.0 licence, and you’ll run it domestically with no dbt account. DuckDB can be free to make use of beneath the permissive MIT licence.
dbt offers a broad vary of capabilities, however as that is an introduction to the subject, I’m concentrating on explaining the fundamentals. This contains utilizing dbt fashions and sources, and utilizing it to check knowledge and create documentation. Extra about all of those later.
In the event you’ve labored on any fairly sized analytics or knowledge engineering undertaking, you’ve in all probability ended up with a folder stuffed with SQL scripts.
When your undertaking first begins up, the whole lot feels manageable. You run the scripts manually or schedule them in no matter orchestration instrument your organization makes use of. Every part is sweet.
Then the undertaking grows.
A column will get renamed in a single desk, and out of the blue some downstream report or dashboard stops working or, worse nonetheless, your nightly 10 million report knowledge ingestion job fails, and your entire system grinds to a halt. The record of points {that a} wrongly utilized little bit of SQL or a desk change can do to a database system is horrifying. And you realize what, it occurs on a regular basis.
A part of the issue is that, historically, SQL has been handled as a set of remoted scripts quite than as a software program undertaking.
If this sounds all too acquainted, the parents behind dbt suppose they’ve an answer.
What’s dbt?
dbt (knowledge construct instrument) was created within the mid 2010s by a gaggle now generally known as dbt Labs. It grew from an inside analytics workflow right into a broadly used open-source, free (on the developer plan) CLI instrument known as dbt Core, alongside a totally managed, paid model known as dbt Platform. I’ll be utilizing the free model.
dbt is used to remodel knowledge already saved in a database, warehouse or lakehouse. It does this by creating tables or views based mostly on user-supplied SQL, but it surely additionally handles the next:
Testing knowledge high quality
Documenting datasets and lineage
Reusing SQL by macros
Managing growth, testing and manufacturing environments
Operating transformations by scheduled jobs or CI/CD pipelines
dbt is broadly utilized by groups working enterprise-grade knowledge storage platforms reminiscent of Snowflake, BigQuery, Redshift and Databricks. However for my examples, I’m going to be utilizing an area DuckDB database.
Why do knowledge groups use dbt?
Primarily as a result of it’s good at what it does.
Think about you’re constructing a gross sales reporting platform. Uncooked order knowledge lands in your knowledge warehouse each hour, say. You write one SQL script to wash the information, one other to calculate buyer totals, one other to construct each day gross sales figures, and one other to generate govt dashboards.
At first, the undertaking has 4 or 5 SQL recordsdata, and it’s simple to maintain observe of them. Six months later, there are fifty, and the order wherein they run is not apparent.
Which script runs wherein order?
What breaks if somebody renames a column?
How do you test that the information continues to be legitimate?
May a brand new developer perceive the undertaking with out opening each SQL file?
Usually, analytics groups solved these issues with naming conventions, handwritten notes handed round and numerous shared techniques information.
As organisations turned extra data-driven, analytics initiatives began wanting increasingly like software program initiatives. Groups wanted model management, automated testing, documentation and dependency administration as a result of they had been writing hundreds of traces of SQL.
Quite than treating SQL scripts as unbiased recordsdata, dbt treats them as elements of a single undertaking, the place each transformation has an outlined objective, and each dependency is known.
Conditions
I’m utilizing Home windows as my working system and have Python 3.13 put in. Every part ought to work in the identical means in the event you’re on Linux or macOS however you positively must have Python put in. You’ll additionally want entry to an appropriate database for dbt to behave on. Every database can have variations in the way you set it up to make use of dbt. I will be utilizing DuckDB as my database and can present you the arrange for that. Seek the advice of the dbt docs (linked on the finish) in the event you’re utilizing a distinct knowledge retailer.
Putting in dbt
Now that now we have a greater understanding of dbt, in the remainder of this text I’ll present you the way to set up it and, by means of instance code, show the most typical dbt instructions you’ll use in your day-to-day job.
The very first thing we should always do is about up a separate Python growth atmosphere to maintain our initiatives siloed.
PS C:Usersthoma> cd initiativesPS C:Usersthomaprojects> mkdir dbt-demo Listing: C:UsersthomaprojectsMode LastWriteTime Size Title---- ------------- ------ ----d----- 03/08/2026 16:21 dbt-demoPS C:Usersthomaprojects> cd dbt-demoPS C:Usersthomaprojectsdbt-demo> python3 -m venv .venvPrecise atmosphere location could have moved as a result of redirects, hyperlinks or junctions. Requested location: "C:Usersthomaprojectsdbt-demo.venvScriptspython3.exe" Precise location: "D:Usersthomaprojectsdbt-demo.venvScriptspython3.exe"PS C:Usersthomaprojectsdbt-demo> ..venvScriptsActivate.ps1(.venv) PS C:Usersthomaprojectsdbt-demo>(.venv) PS C:Usersthomaprojectsdbt-demo>(.venv) PS C:Usersthomaprojectsdbt-demo>
You possibly can set up dbt utilizing a easy pip command just like the one proven beneath. To attach dbt to a knowledge supply, we use one thing known as an adapter. dbt has many various kinds of adapters, for instance, BigQuery, AWS Redshift, Snowflake, and many others. For this demo, I’m going to be utilizing an area DuckDB database.
Most adapters need to be put in individually from the dbt-core product, however for DuckDB, dbt offers a one-file set up.
The following factor we wish to do is initialise a dbt undertaking. We do that utilizing the dbt init command.
(.venv-core) PS C:Usersthomaprojectsdbt-demo> dbt init15:48:36 Operating with dbt=1.12.0Enter a reputation to your undertaking (letters, digits, underscore): my-dbt-demomy-dbt-demo is just not a sound undertaking title.Enter a reputation to your undertaking (letters, digits, underscore): my_dbt_demo15:49:02 Establishing your profile.Which database would you want to make use of?[1] duckdb(Do not see the one you need? https://docs.getdbt.com/docs/available-adapters)Enter a quantity: 115:49:05 Profile my_dbt_demo written to C:Usersthoma.dbtprofiles.yml utilizing goal's pattern configuration. As soon as up to date, you can begin creating with dbt.15:49:05 Operating dbt debug to validate the undertaking...15:49:05 dbt model: 1.12.015:49:05 python model: 3.13.1415:49:05 python path: C:Usersthomaprojectsdbt-demo.venv-coreScriptspython3.exe15:49:05 os information: Home windows-11-10.0.22621-SP015:49:05 Utilizing profiles dir at C:Usersthoma.dbt15:49:05 Utilizing profiles.yml file at C:Usersthoma.dbtprofiles.yml15:49:05 Utilizing dbt_project.yml file at C:Usersthomaprojectsdbt-demomy_dbt_demodbt_project.yml15:49:05 adapter kind: duckdb15:49:05 adapter model: 1.10.115:49:05 Configuration:15:49:05 profiles.yml file [OK found and valid]15:49:05 dbt_project.yml file [OK found and valid]15:49:05 Required dependencies:15:49:05 - git [OK found]15:49:05 Connection:15:49:05 database: dev15:49:05 schema: foremost15:49:05 path: dev.duckdb15:49:05 config_options: None15:49:05 extensions: None15:49:05 settings: {}15:49:05 external_root: .15:49:05 use_credential_provider: None15:49:05 connect: None15:49:05 filesystems: None15:49:05 distant: None15:49:05 plugins: None15:49:05 disable_transactions: False15:49:05 Registered adapter: duckdb=1.10.115:49:05 Connection check: [OK connection ok]15:49:05 All checks handed!15:49:05 Your new dbt undertaking "my_dbt_demo" was created!Initialized new undertaking in C:Usersthomaprojectsdbt-demomy_dbt_demomy_dbt_demoFor extra data on the way to configure the profiles.yml file,please seek the advice of the dbt documentation right here: https://docs.getdbt.com/docs/configure-your-profileYet one more factor:Need assistance? Do not hesitate to achieve out to us by way of GitHub points or on Slack: https://group.getdbt.com/Joyful modeling!
Operating the above command will create various folders and recordsdata. It’s going to look one thing like this,
The fashions/instance folder reveals two instance mannequin recordsdata and a schema file. We’ll discuss extra about mannequin recordsdata in a bit, however for now you may safely delete the complete instance folder and its contents.
One of the vital necessary recordsdata that the dbt init course of creates is known as profiles.yml. This holdsyour database connection properties, however you gained’t see it in your dbt undertaking construction. As an alternative, in Home windows, its full path is,
Now we will see what dbt expects our database to be known as and the place it ought to reside. In fact, you may edit this file and alter these particulars if you need. The trail is relative to your HOME listing. I would like my duckDB knowledge file to be in,
C:Usersthomaprojectsdbt-demodatamy_dbt_demo
So I up to date my profiles.yml file to appear to be this
Now we will create our DuckDB database. To try this, we have to set up the DuckDB CLI. Click on the hyperlink beneath and comply with the directions related to your atmosphere.
Run the duckdb CLI and go it the title of an acceptable file to completely retailer your database. It’s also possible to run it with no parameter in the event you’re not bothered about preserving the information if you exit. Sort within the following command.
Creating and working a dbt mannequin with a supply
Now that now we have knowledge in our database, we will begin to use dbt. Two of an important ideas to know in dbt are these of fashions and sources.
A mannequin is just a file containing a snippet of SQL that dbt makes use of to create a brand new desk or view in your goal database.
A supply is an present desk or view in your knowledge retailer that dbt did not create, reminiscent of uncooked knowledge loaded by an software or ingestion instrument. Sources are how fashions seek advice from present tables in your database/schema. You outline a supply utilizing a YAML configuration file. As we’re working with an orders desk, we’ll name ours orders.yml.
For our instance, we’re going to create a mannequin that builds a desk to carry accomplished orders. It will seek advice from our present orders database desk, so it is smart to create a supply YAML file for it. That appears like this:
-- customer_orders_summary.sql{{ config(materialized='desk') }}with completed_orders as ( choose order_id, customer_name, order_date, amount, amount * unit_price as order_value from {{ supply('uncooked', 'orders') }} the place decrease(order_status) = 'accomplished')choose customer_name, depend(*) as completed_order_count, sum(amount) as total_units_purchased, spherical(sum(order_value), 2) as total_revenue, spherical(avg(order_value), 2) as average_order_value, min(order_date) as first_order_date, max(order_date) as most_recent_order_datefrom completed_ordersgroup by customer_name
Create each the mannequin SQL file and supply YAML file beneath the fashions folder in your dbt undertaking.
Hopefully you may instantly see the good thing about utilizing a supply in our mannequin file. As a result of the FROM clause within the SQL makes use of a reference quite than an precise desk title, if the supply desk title had been to vary sooner or later sooner or later, you’ll solely must replace that change in a single place — the supply file. Any and all SQLs utilizing the supply file would run unchanged.
Okay, now that these recordsdata are in place, we will run our dbt transformation. You do this utilizing the dbt run command.
(.venv-core) PS C:Usersthomaprojectsdbt-demomy_dbt_demo> dbt run20:33:39 Operating with dbt=1.12.020:33:40 Registered adapter: duckdb=1.10.120:33:40 Unable to do partial parsing as a result of profile has modified20:33:41 [WARNING]: Configuration paths exist in your dbt_project.yml file which don't apply to any sources.There are 1 unused configuration paths:- fashions.my_dbt_demo.instance20:33:41 Discovered 1 mannequin, 1 supply, 486 macros20:33:4120:33:41 Concurrency: 1 threads (goal='dev')20:33:4120:33:41 1 of 1 START sql desk mannequin uncooked.customer_order_summary ........................ [RUN]20:33:41 1 of 1 OK created sql desk mannequin uncooked.customer_order_summary ................... [OK in 0.11s]20:33:4120:33:41 Completed working 1 desk mannequin in 0 hours 0 minutes and 0.23 seconds (0.23s).20:33:4120:33:41 Accomplished efficiently20:33:4120:33:41 Executed. PASS=1 WARN=0 ERROR=0 SKIP=0 NO-OP=0 REUSED=0 TOTAL=1(.venv-core) PS C:Usersthomaprojectsdbt-demomy_dbt_demo> .duckdb $HOMEprojectsdbt-demomy_dbt_demodataduckdb.devDuckDB v1.5.5 (Variegata)Enter ".assist" for utilization hints.duckdb D present all tables;┌──────────┬─────────┬────────────────────────┬─────────────────────────────┬──────────────────────────────┬───────────┐│ database │ schema │ title │ column_names │ column_types │ momentary ││ varchar │ varchar │ varchar │ varchar[] │ varchar[] │ boolean │├──────────┼─────────┼────────────────────────┼─────────────────────────────┼──────────────────────────────┼───────────┤│ duckdb │ uncooked │ customer_order_summary │ [customer_name, │ [VARCHAR, BIGINT, HUGEINT, │ false ││ │ │ │ completed_order_count, │ 'DECIMAL(38,2)', DOUBLE, │ ││ │ │ │ total_units_purchased, │ DATE, DATE] │ ││ │ │ │ total_revenue, │ │ ││ │ │ │ average_order_value, │ │ ││ │ │ │ first_order_date, │ │ ││ │ │ │ most_recent_order_date] │ │ │├──────────┼─────────┼────────────────────────┼─────────────────────────────┼──────────────────────────────┼───────────┤│ duckdb │ uncooked │ orders │ [order_id, customer_name, │ [INTEGER, VARCHAR, VARCHAR, │ false ││ │ │ │ product_name, order_date, │ DATE, INTEGER, │ ││ │ │ │ quantity, unit_price, │ 'DECIMAL(10,2)', VARCHAR] │ ││ │ │ │ order_status] │ │ │└──────────┴─────────┴────────────────────────┴─────────────────────────────┴──────────────────────────────┴───────────┘duckdb D choose * from uncooked.customer_order_summary;┌───────────────┬───────────────────────┬───┬─────────────────────┬──────────────────┬────────────────────────┐│ customer_name │ completed_order_count │ … │ average_order_value │ first_order_date │ most_recent_order_date ││ varchar │ int64 │ … │ double │ date │ date │├───────────────┼───────────────────────┼───┼─────────────────────┼──────────────────┼────────────────────────┤│ Charlie │ 1 │ … │ 89.0 │ 2026-02-06 │ 2026-02-06 ││ Alice │ 4 │ … │ 102.0 │ 2026-01-03 │ 2026-03-01 ││ Bob │ 1 │ … │ 59.98 │ 2026-01-04 │ 2026-01-04 ││ Diana │ 3 │ … │ 92.99 │ 2026-01-10 │ 2026-03-05 │└───────────────┴───────────────────────┴───┴─────────────────────┴──────────────────┴────────────────────────┘
The output is as anticipated. A brand new abstract desk is created with the required information. That’s all I’m going to say on fashions and sources. What I’ve proven might sound a little bit of a faff for only one desk, and it’s, however belief me, if you’re coping with dozens or lots of of tables and transformations, you gained’t remorse the time spent on creating fashions and sources.
Utilizing dbt for testing your knowledge
One other advantage of utilizing dbt is its skill to automate your SQL testing cycle. Exams are outlined (in YAML) alongside your fashions and sources and could be executed independently or at any time when the undertaking is constructed. You possibly can write your individual SQL assessments, however dbt additionally offers 4 built-in check circumstances:
distinctive
not_null
relationships
accepted_values
We’ll demo two of those assessments to provide you a flavour of what you are able to do with them.
Not null check
Our check shall be run towards the customer_name column of the customer_order_summary desk. As we’re testing a desk that dbt is creating, we add the check YAML to a fashions part in our orders.yml file. It now seems like this:
Now, to run our check, we will merely kind the dbt construct command like this, which runs and validates the chosen elements of a dbt undertaking in dependency order.
(.venv-core) PS C:Usersthomaprojectsdbt-demomy_dbt_demo> dbt construct08:43:19 Operating with dbt=1.12.008:43:20 Registered adapter: duckdb=1.10.108:43:20 [WARNING]: Configuration paths exist in your dbt_project.yml file which don't apply to any sources.There are 1 unused configuration paths:- fashions.my_dbt_demo.instance08:43:20 Discovered 1 mannequin, 1 check, 1 supply, 486 macros08:43:2008:43:20 Concurrency: 1 threads (goal='dev')08:43:2008:43:20 1 of two START sql desk mannequin uncooked.customer_order_summary ........................ [RUN]08:43:20 1 of two OK created sql desk mannequin uncooked.customer_order_summary ................... [OK in 0.14s]08:43:20 2 of two START check not_null_customer_order_summary_customer_name ................ [RUN]08:43:20 2 of two FAIL 1 not_null_customer_order_summary_customer_name .................... [FAIL 1 in 0.02s]08:43:2008:43:20 Completed working 1 desk mannequin, 1 check in 0 hours 0 minutes and 0.24 seconds (0.24s).08:43:2008:43:20 Accomplished with 1 error, 0 partial successes, and 0 warnings:08:43:2008:43:20 [ERROR]: in check not_null_customer_order_summary_customer_name (modelsorders.yml)08:43:20 Obtained 1 end result, configured to fail if != 008:43:2008:43:20 compiled code at targetcompiledmy_dbt_demomodelsorders.ymlnot_null_customer_order_summary_customer_name.sql08:43:2008:43:20 Executed. PASS=1 WARN=0 ERROR=1 SKIP=0 NO-OP=0 REUSED=0 TOTAL=2
The problem is caught and reported on. dbt would not delete or roll again a mannequin when its subsequent knowledge check fails. Nevertheless, fashions downstream of the failed check are usually skipped in the course of the construct. If you wish to run the check with out re-creating any tables, and many others., simply use the dbt check command.
Accepted values check
This does precisely what it appears like. It allows you to check {that a} column accommodates solely particular values. If we take a look at our orders desk, we will see that the order_status column ought to solely include both accomplished,processing, returned or cancelled values. So let’s replace the desk and alter one of many values to be one thing else.
duckdb D choose * from uncooked.orders the place order_id = 10;┌──────────┬───────────────┬──────────────┬────────────┬──────────┬───────────────┬──────────────┐│ order_id │ customer_name │ product_name │ order_date │ amount │ unit_price │ order_status ││ int32 │ varchar │ varchar │ date │ int32 │ decimal(10,2) │ varchar │├──────────┼───────────────┼──────────────┼────────────┼──────────┼───────────────┼──────────────┤│ 10 │ Bob │ Mouse │ 2026-02-14 │ 1 │ 24.99 │ cancelled │└──────────┴───────────────┴──────────────┴────────────┴──────────┴───────────────┴──────────────┘duckdb D replace uncooked.orders set order_status = 'invalid' the place order_id = 10;duckdb D choose * from uncooked.orders the place order_id = 10;┌──────────┬───────────────┬──────────────┬────────────┬──────────┬───────────────┬──────────────┐│ order_id │ customer_name │ product_name │ order_date │ amount │ unit_price │ order_status ││ int32 │ varchar │ varchar │ date │ int32 │ decimal(10,2) │ varchar │├──────────┼───────────────┼──────────────┼────────────┼──────────┼───────────────┼──────────────┤│ 10 │ Bob │ Mouse │ 2026-02-14 │ 1 │ 24.99 │ invalid │└──────────┴───────────────┴──────────────┴────────────┴──────────┴───────────────┴──────────────┘
As we’re testing a supply desk, we should always put our check YAML config within the sources part of our YAML file. You possibly can go away or take away the unique null check if you need. I’ve saved it in.
We’re working the check on an present desk, so we needn’t run the construct command. We are able to simply use dbt check.
(.venv-core) PS C:Usersthomaprojectsdbt-demomy_dbt_demo> dbt check09:08:04 Operating with dbt=1.12.009:08:04 Registered adapter: duckdb=1.10.109:08:04 [WARNING]: Configuration paths exist in your dbt_project.yml file which don't apply to any sources.There are 1 unused configuration paths:- fashions.my_dbt_demo.instance09:08:04 Discovered 1 mannequin, 2 knowledge assessments, 1 supply, 486 macros09:08:0409:08:04 Concurrency: 1 threads (goal='dev')09:08:0409:08:04 1 of two START check not_null_customer_order_summary_customer_name ................ [RUN]09:08:04 1 of two FAIL 1 not_null_customer_order_summary_customer_name .................... [FAIL 1 in 0.03s]09:08:04 2 of two START check source_accepted_values_raw_orders_order_status__completed__processing__returned__cancelled [RUN]09:08:04 2 of two FAIL 1 source_accepted_values_raw_orders_order_status__completed__processing__returned__cancelled [FAIL 1 in 0.02s]09:08:0409:08:04 Completed working 2 knowledge assessments in 0 hours 0 minutes and 0.11 seconds (0.11s).09:08:0409:08:04 Accomplished with 2 errors, 0 partial successes, and 0 warnings:09:08:0409:08:04 [ERROR]: in check not_null_customer_order_summary_customer_name (modelsorders.yml)09:08:04 Obtained 1 end result, configured to fail if != 009:08:0409:08:04 compiled code at targetcompiledmy_dbt_demomodelsorders.ymlnot_null_customer_order_summary_customer_name.sql09:08:0409:08:04 [ERROR]: in check source_accepted_values_raw_orders_order_status__completed__processing__returned__cancelled (modelsorders.yml)09:08:04 Obtained 1 end result, configured to fail if != 009:08:0409:08:04 compiled code at targetcompiledmy_dbt_demomodelsorders.ymlsource_accepted_values_raw_ord_0932c13ab9fb3a73a9e3e3c87c81af50.sql09:08:0409:08:04 Executed. PASS=0 WARN=0 ERROR=2 SKIP=0 NO-OP=0 REUSED=0 TOTAL=2(.venv-core) PS C:Usersthomaprojectsdbt-demomy_dbt_demo>
The opposite two kinds of built-in check are equally simple to arrange and run, so I am going to go away it at that.
Utilizing dbt to doc your system
The ultimate introductory dbt matter we’re going to take a look at is arguably certainly one of its greatest options. Most documentation begins life with good intentions earlier than quietly changing into old-fashioned. dbt approaches documentation in a different way.
As a result of your fashions, assessments and metadata all dwell alongside your SQL, dbt can generate undertaking documentation robotically. Extra importantly, it additionally creates a visible lineage graph exhibiting precisely how your fashions depend upon each other.
That is invaluable when somebody new joins your undertaking as a result of they don’t must reverse-engineer lots of of SQL recordsdata. They’ll see the complete transformation pipeline virtually instantly.
It’s a kind of options that doesn’t appear significantly thrilling till you’ve inherited another person’s analytics undertaking.
Proper off the bat, dbt can do some automated documentation for you, but it surely’s a kind of issues that the extra you set into it, the higher documentation you’re going to get out. With out doing something further to our undertaking, right here is the naked documentation you get. We use the dbt docs generate command to create the documentation like this.
(.venv-core) PS C:Usersthomaprojectsdbt-demomy_dbt_demo> dbt docs generate09:21:19 Operating with dbt=1.12.009:21:19 Registered adapter: duckdb=1.10.109:21:19 [WARNING]: Configuration paths exist in your dbt_project.yml file which don't apply to any sources.There are 1 unused configuration paths:- fashions.my_dbt_demo.instance09:21:19 Discovered 1 mannequin, 2 knowledge assessments, 1 supply, 486 macros09:21:1909:21:19 Concurrency: 1 threads (goal='dev')09:21:1909:21:19 Constructing catalog09:21:19 Catalog written to C:Usersthomaprojectsdbt-demomy_dbt_demotargetcatalog.json
Now that we’ve generated the documentation, we will visualise it in an online browser utilizing the dbt docs serve command.
(.venv-core) PS C:Usersthomaprojectsdbt-demomy_dbt_demo> dbt docs serve09:24:48 Operating with dbt=1.12.0Serving docs at 8080To entry out of your browser, navigate to: http://localhost:8080Press Ctrl+C to exit.127.0.0.1 - - [04/Aug/2026 10:24:48] "GET / HTTP/1.1" 200 -127.0.0.1 - - [04/Aug/2026 10:24:48] "GET /manifest.json?cb=1785835488811 HTTP/1.1" 200 -127.0.0.1 - - [04/Aug/2026 10:24:48] "GET /catalog.json?cb=1785835488811 HTTP/1.1" 200 -127.0.0.1 - - [04/Aug/2026 10:24:49] code 404, message File not discovered127.0.0.1 - - [04/Aug/2026 10:24:49] "GET /%7Bpercent7Bpercent20getIcon(merchandise.kind,%20'on')%20percent7Dpercent7D HTTP/1.1" 404 -127.0.0.1 - - [04/Aug/2026 10:24:49] code 404, message File not discovered127.0.0.1 - - [04/Aug/2026 10:24:49] "GET /%7Bpercent7Bpercent20getIcon(merchandise.kind,%20'off')%20percent7Dpercent7D HTTP/1.1" 404 -
You must see a browser window open that appears one thing like this,
As I discussed, it’s fairly bare-bones however nonetheless helpful. To see the true energy, you need to add your individual descriptive documentation textual content within the type of YAML to your orders.yml file. Right here is an instance.
model: 2sources: - title: uncooked description: "Uncooked demonstration knowledge created instantly in DuckDB earlier than dbt transformations run." schema: uncooked tables: - title: orders description: "Pattern buyer orders used because the enter to the client order abstract mannequin." columns: - title: order_id description: "Distinctive identifier assigned to every order." - title: customer_name description: "Title of the client who positioned the order." - title: product_name description: "Product bought by the client." - title: order_date description: "Date on which the order was positioned." - title: amount description: "Variety of product items ordered." - title: unit_price description: "Value of 1 product unit on the time of the order." - title: order_status description: "Present order state; restricted to the 4 supported standing values." data_tests: - accepted_values: arguments: values: - accomplished - processing - returned - cancelledfashions: - title: customer_order_summary description: > A dbt-created desk containing one row per buyer. It contains solely accomplished orders and summarises order counts, items bought, income and order dates. columns: - title: customer_name description: "Buyer represented by the abstract row." data_tests: - not_null - title: completed_order_count description: "Variety of accomplished orders positioned by the client." - title: total_units_purchased description: "Whole variety of items throughout the client's accomplished orders." - title: total_revenue description: "Whole worth of the client's accomplished orders." - title: average_order_value description: "Common worth of the client's accomplished orders." - title: first_order_date description: "Earliest accomplished order date for the client." - title: most_recent_order_date description: "Most up-to-date accomplished order date for the client."
Now, once we run the 2 dbt documentation instructions, we get a a lot richer output like this.
Subsequent levels
dbt is a big ecosystem, and as I defined, I solely needed to the touch on among the fundamentals of its operation. As issues stand, I’m proud of the information I’ve on utilizing dbt. If you wish to take issues additional, you may wish to dive deeper into the next subjects, which construct on what I’ve talked about right here.
Incremental fashions: Course of solely new or modified information as an alternative of rebuilding a whole desk on each run.
Jinja: A templating language that permits you to add variables, circumstances, loops and reusable features to SQL.
Macros: Reusable items of Jinja and SQL logic that may settle for parameters and generate SQL.
Snapshots: Document how supply information change over time, permitting you to retain their historic values.
Reusable packages: Use fashions, macros and assessments created by different dbt initiatives as an alternative of constructing the whole lot your self.
Here’s a hyperlink to the official dbt Labs house web page the place you will discover all the data you could learn about dbt.
