dbt

The transformation layer that runs inside your warehouse — what dbt replaces, what it deliberately is not, and the honest cases where it is the wrong tool.

From an empty folder to a materialized table: project config, connection profiles, adapters, and why `dbt build` is almost always the command you want.

A model is a SELECT. `ref()` is what turns a folder of queries into a dependency graph — and node selection is how you run just the part you care about.

The DDL each materialization emits, the cost/latency/freshness triangle behind the choice, and the promotion path from view to table to incremental.

Declaring raw tables as sources, catching stale data before any model runs, and the one-model-per-source convention that keeps a project navigable.

What happens between your SQL file and the query the warehouse runs: the Jinja context, the parse/compile/run phases, macros, and how to debug them.

The SQL every built-in test compiles to, severity and thresholds, writing your own generic test — and the wrong numbers that no test will ever catch.

Fixture-driven tests that run without warehouse data, so dedup rules, null handling, and window boundaries are proven before the model ever ships.

is_incremental(), unique keys, and all five strategies compared on real row counts — plus late-arriving data, schema change, and the drift nobody notices.

Capturing history from a source that overwrites itself — strategies, the generated validity columns, hard deletes, and why a snapshot can never be rebuilt.

Static lookups that belong in git, docs that stay accurate because they live beside the model, and lineage that reaches all the way to the dashboard.

The layering convention and the reasoning behind it, one grain per model, and how to decompose an 800-line query without changing a single row.

Making a model a promise: enforced column types, constraints your warehouse may or may not honour, versioned migrations, and who is allowed to ref you.

Dev, CI, and prod without editing code; a throwaway schema on every PR; and slim CI that builds only what changed and defers the rest to production.

One task or forty: how dbt gets invoked in production, what each option costs in parse time and blast radius, and what a half-finished run means downstream.

Why sixteen threads is not sixteen times faster, finding the model that owns your critical path, and the warehouse knobs that actually move the bill.

A symptom-to-fix runbook for analytics engineering — including the worst failure of all: the run that goes green while the numbers are wrong.

Standing on other people’s macros: the packages worth adopting, proving a refactor row-for-row with audit_helper, and building your own internal package.

Splitting one project into several with contracts as the interface — and the honest answer to whether your team is anywhere near needing it.

Defining a metric once and letting every tool ask for it at any grain — semantic models, metric types, and the trade-off against a plain wide mart.

When a model should not be SQL: the Python model contract, the platforms that support it, the cost profile, and when a separate Spark job is the right call.

What the Fusion engine changes, how a migration actually goes, the anti-pattern catalogue with fixes, and a review checklist you can hand to a team.