DBT (Data Build Tool) Course

Lesson 1 • DBT Core vs. DBT Cloud

Distinguishes the open-source CLI tool from the managed cloud platform. Students choose the right deployment mode for their environment.

Lesson 2 • Setting Up Your DBT Environment

Guides installation of DBT Core and connection to a data warehouse. Students finish with a working local environment ready for project creation.

Lesson 3 • What Is DBT and Why It Matters

Covers DBT's core value proposition and how it transforms SQL-based data transformation. Grounds students in the problem DBT solves before any hands-on work.

Lesson 1 • Initializing a DBT Project

Walks through dbt init and the generated file structure. Students understand every auto-generated file's purpose before modifying anything.

Lesson 2 • Source Control and Project Conventions

Establishes Git-based workflows and naming conventions for scalable DBT projects. Students apply consistent standards that support team collaboration.

Lesson 3 • Managing Profiles and Targets

Covers multi-environment profile setup for dev, staging, and production targets. Students safely switch contexts without hardcoding credentials.

Lesson 1 • Organizing Models into Layers

Introduces staging, intermediate, and mart layer conventions for model organization. Students structure a multi-layer project that mirrors real analytics engineering practice.

Lesson 2 • Materializations in Depth

Explains table, view, incremental, and ephemeral materializations with trade-offs. Students select the right materialization for each model's performance needs.

Lesson 3 • Selecting and Executing Model Subsets

Covers node selection syntax for running targeted subsets of the DAG. Students efficiently rebuild only the models they need during development.

Lesson 4 • Writing Your First DBT Model

Introduces the SQL SELECT-based model syntax and the ref() function. Students write and execute a working model against a real warehouse table.

Lesson 1 • Source Freshness and Data Contracts

Teaches freshness thresholds and how to enforce data arrival SLAs at the source layer. Students configure alerts that surface stale data before it reaches marts.

Lesson 2 • Declaring and Using Sources

Covers source YAML declarations and the source() function for referencing raw tables. Students replace hardcoded table names with governed source references.

Lesson 3 • Capturing History with Snapshots

Introduces DBT snapshots for tracking slowly changing dimension records over time. Students implement timestamp and check strategies for SCD Type 2 patterns.

Lesson 1 • Third-Party Testing Packages

Surveys popular packages like dbt-expectations and dbt-utils for extended test coverage. Students install and apply package-based tests to close gaps in built-in coverage.

Lesson 2 • Writing Custom Generic Tests

Teaches how to author reusable Jinja-based generic tests for project-specific rules. Students extend the test library beyond built-in options.

Lesson 3 • Singular Tests for Complex Logic

Introduces singular SQL-based tests for assertions that cannot be expressed generically. Students write targeted tests for business-rule validation.

Lesson 4 • Test Severity and Failure Handling

Explains warn vs. error severity levels and how to handle expected test failures. Students configure tests that alert without blocking pipeline execution.

Lesson 1 • Understanding and Using the DAG

Explains the directed acyclic graph view and how to use it for impact analysis. Students trace data lineage from raw source to final mart model.

Lesson 2 • Using doc() Blocks for Reuse

Introduces Markdown doc blocks for writing long-form, reusable descriptions. Students eliminate duplicate documentation across shared column definitions.

Lesson 3 • Writing Model and Column Descriptions

Covers inline YAML descriptions for models, columns, and sources. Students document every asset so that generated docs are immediately useful.

Lesson 1 • Jinja Templating Fundamentals

Introduces Jinja syntax including variables, loops, and conditionals within SQL models. Students write dynamic SQL that adapts to runtime context.

Lesson 2 • DBT Variables and Runtime Flags

Explains project-level and CLI-passed variables for parameterizing model behavior. Students build models that change behavior based on runtime inputs.

Lesson 3 • Writing and Using Macros

Covers macro definition, arguments, and invocation for reusable SQL logic. Students replace repeated SQL patterns with single-source macro calls.

Lesson 4 • Hooks and Operations

Introduces pre-hook, post-hook, and on-run-end hooks for executing SQL around model runs. Students automate warehouse maintenance tasks within the DBT lifecycle.

Lesson 1 • Continuous Integration for DBT Projects

Covers slim CI patterns using state comparison to test only modified models on pull requests. Students configure a CI pipeline that runs fast, targeted checks.

Lesson 2 • Orchestrating DBT with Workflow Tools

Surveys integration patterns with orchestration platforms such as Airflow and Prefect. Students trigger DBT runs from an orchestrator with proper dependency management.

Lesson 3 • Monitoring DBT Run Health

Covers run artifacts, metadata API, and alerting for failed runs and stale models. Students build an observability layer that surfaces pipeline issues proactively.

Lesson 4 • Environment Promotion Strategies

Explains dev-to-staging-to-production promotion workflows and schema isolation. Students deploy changes safely without overwriting production data during development.