How dbt's core materialization types differ
Materializations control how dbt turns a model's SELECT statement into objects in your warehouse, balancing build time, storage cost, and query performance. dbt supports four core materializations—view, table, incremental, and ephemeral—configurable per model, folder, or project via the materialized config. Choosing the right one is central to optimizing model performance and warehouse spend.
Must-know
- Views are the default materialization; dbt wraps the SELECT in a CREATE VIEW statement, so no data is stored but every query re-runs the full logic against the underlying tables.
- Table materialization runs a CREATE TABLE AS (or equivalent) each run, fully rebuilding the table from scratch, which is simple and fast to query but can be slow and costly to build for large datasets.
- Incremental materialization builds a table once, then on subsequent runs only inserts/updates new or changed rows using a configurable
unique_keyandis_incremental() macro logic, dramatically reducing processing time for large, append-heavy datasets. - Ephemeral models are not built as database objects at all; dbt inlines their SQL as a CTE into downstream models, useful for lightweight reusable logic but they cannot be queried directly and add complexity to compiled SQL if overused.
- Incremental models require careful handling of schema changes and late-arriving/updated data (via strategies like merge, delete+insert, or append) and often need a full-refresh run to rebuild correctly when logic changes.
- Materialization choice should be driven by downstream query patterns and rebuild cost: staging/light-transform models often use views or ephemeral, marts/reporting layers often use tables, and large fact tables typically use incremental.
You have a lightweight staging model that filters and renames columns from a source table. It contains no heavy aggregations, and three downstream models each reference it. You want the SQL logic reused wherever it's referenced without dbt creating any persistent database object for the staging model itself. Which materialization should you configure, and what mechanism makes it work?
What you have tried across dbt Analytics Engineering's objectives, not a readiness score.
Developing and optimizing dbt models
- Tracing and confirming a model's upstream raw sources
- How dbt's core materialization types differ
- Keeping models modular and avoiding repeated logic
- What each core dbt command actually does
- Shaping a model's dependency graph so it stays readable
- Setting project-wide configuration in dbt_project.yml
- Pulling in and using a dbt package
- Writing a model in Python instead of SQL
- Granting model access through the grants config
- Configuring a snapshot to track slowly changing data
- Picking the right incremental strategy for a dataset
- Dry-running a model to check its logic and schema before a real build
- Sampling a model run before a full build
- What microbatch and other advanced materializations are for
Managing dbt models governance
Debugging data modeling errors
Troubleshooting and optimizing dbt pipelines
Implementing dbt tests
Implementing and maintaining external dependencies
Coverage checked against the published exam guide on Aug 4, 2026.
These are independent practice questions, written against this certification's published exam guide. They are not the certification vendor's own questions, and not the real exam.