BEGINNER · 8 MODULES · 64 LESSONS

dbt and Analytics Engineering

Turn scattered SQL transformations into a versioned, tested, and documented data project with dbt that runs end to end with a single command.

For you if
You write transformation SQL by hand, in loose scripts, with no tests or version control.
By the end
You'll know how to build dbt models, write data tests, track history with snapshots, and run reliable incremental loads.
You need
Intermediate SQL, a dimensional model (star schema), and Python 3.13 or 3.14. Everything runs locally for free.
  1. 01Your First Dbt Project8 LESSONS
    1. Guide introduction: from loose SQL to a software project
    2. What is analytics engineering?
    3. dbt and the T in ELT
    4. Installing dbt-core and dbt-duckdb
    5. Anatomy of a dbt project
    6. Connecting to Kiosko with `profiles.yml`
    7. Your first model and `dbt run`
    8. Mini-project: Kiosko's first dbt project
  2. 02Sources And Staging Models8 LESSONS
    1. Module introduction: from a toy model to Kiosko's real data
    2. Declaring Kiosko's raw data as sources
    3. The `source()` function and why it matters
    4. Reading files directly with `external_location`
    5. Staging models: one model per source table
    6. Naming staging models: the `stg_` prefix
    7. Building `stg_orders` and `stg_events`
    8. Mini-project: Kiosko's complete staging layer
  3. 03Ref Marts And Materializations8 LESSONS
    1. Module overview: from staging views to the star schema with `ref()`
    2. The `ref()` function and the DAG it builds
    3. Materializations: `view` versus `table`
    4. Rebuilding `dim_store` and `dim_date`
    5. Rebuilding `fact_orders` with `ref()`
    6. Choosing materializations for Kiosko
    7. Inspecting the DAG with `dbt ls`
    8. Mini-project: Kiosko's star schema in dbt
  4. 04Testing Your Models8 LESSONS
    1. Module overview: from a star schema that runs to a star schema you trust
    2. What a data test actually checks
    3. Generic tests: `unique` and `not_null` on `fact_orders`
    4. Generic tests: `accepted_values` and `relationships`
    5. Writing your own generic test: `test_is_positive`
    6. Singular tests for business rules
    7. Reading `dbt test`'s report
    8. Mini-project: Kiosko's test suite
  5. 05Snapshots And Scd Type 28 LESSONS
    1. Module overview: from a star schema you trust to a star schema that remembers its past
    2. What a dbt snapshot actually does
    3. `timestamp` vs `check`: a snapshot's two strategies
    4. Configuring `dim_product_snapshot`
    5. Running the first snapshot
    6. Changing the source and snapshotting again
    7. Querying the historized `dim_product`
    8. Mini-project: Kiosko's SCD type 2 in dbt
  6. 06Incremental Models And Idempotency8 LESSONS
    1. Module 6: Incremental models and idempotency
    2. Why incremental models exist
    3. The `is_incremental()` macro
    4. Choosing an incremental strategy
    5. Making `fact_orders` incremental
    6. Proving idempotency by running twice
    7. `--full-refresh` when you need to rebuild
    8. Mini-project: Kiosko's incremental `fact_orders`
  7. 07Macros Docs And Lineage8 LESSONS
    1. Module 7: Macros, documentation, and lineage
    2. Writing your first macro
    3. A reusable revenue macro for Kiosko
    4. Documenting models and columns
    5. Generating docs with `dbt docs generate`
    6. Reading the lineage graph
    7. When a dbt project needs a scheduler
    8. Mini-project: Kiosko's documented project
  8. 08Project Kioskos Dbt Warehouse8 LESSONS
    1. Module 8: Project, Kiosko's first dbt warehouse
    2. The brief: Kiosko needs a versioned warehouse
    3. Porting the rest of data-modeling's marts
    4. Assembling the complete project structure
    5. Running `dbt build` end to end
    6. Querying the final mart
    7. What Kiosko still needs
    8. Project: Kiosko's first dbt warehouse
Reviews

What students say

These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.

No approved reviews yet.

Be the first to share your experience!

SEC. 06 · THE STUDIO

Why this studio exists

For decades, building software belonged to technical profiles with years of training, and getting a digital product into the real world took companies months or years. No-code and AI have narrowed that gap, but the knowledge is still held by a few.

Tech Benders exists to open that knowledge up, so business teams and non-technical teams can put their ideas into production with the right technical decisions behind them. AI does what you ask of it. Without a technical base, what it builds may not scale with your company’s ecosystem, and its costs can run away over time.

The team knows the pains of large organizations and the speed at which they have to move. It brings solution architecture, data engineering, product built end to end from back end to front end, and daily work with AI. Software that solves what you need in days, not months, with the cost of AI kept in check.

Founders

The studioRead about Tech Benders →

Write to ushi@techbenders.io

Made with Wislab