Free dbt Labs dbt-Analytics-Engineering Practice Exam with Questions & Answers

This error occurs because the YAML structure is incorrectly indented, causing dbt’s parser (and YAML itself) to misinterpret the test definitions. In dbt, generic tests must be declared as a list under the tests: key, but YAML is extremely sensitive to indentation levels. In the faulty YAML, unique and not_null are indented incorrectly relative to the tests: key, which produces the error: “mapping values are not allowed in this context.”

According to the dbt Testing documentation, valid generic test syntax follows this exact pattern:

columns:

- name: id

tests:

- unique

- not_null

The indentation under tests: must be consistent and aligned so that YAML interprets the items as list elements, not as malformed mappings. When indentation is wrong, YAML attempts to parse list entries as key-value mappings, which leads to the error seen during compilation.

dbt does not require generic test names to be quoted, nor does it expect tests to be a dictionary. The test list format is correct—only the indentation is wrong. Therefore, the root cause is incorrect YAML indentation, making Option D correct.

The correct answer is A: dbt test --select "orders" --indirect-selection=empty".

In dbt, the --indirect-selection flag controls how dbt handles indirectly related resources during selection, such as tests whose parent models may or may not be selected. By default, dbt may include related resources depending on the selection behavior.

indirect-selection=empty is the strictest form of selection. It means that dbt will not run tests whose parent models are not explicitly selected, even if the tests are indirectly related. This prevents executing tests on models that you did not intend to build or include in your workflow, ensuring test execution is tightly scoped.

Other options behave differently:

Option B (no indirect-selection flag) uses dbt’s default behavior, which does include related tests, meaning tests could run even when their parent models were not selected.

Option C: buildable includes resources that can be built (e.g., when downstream dependencies require them).

Option D: cautious runs tests if their parents are selected transitively through dependencies.

Therefore, to prevent tests from running when parent models are unselected, you must use --indirect-selection=empty, making A the correct choice.

The correct answer is A: Information is gathered from the use of source and ref macros.

dbt determines the dependency graph — the DAG — by analyzing calls to ref() and source() inside model SQL files. These macros explicitly declare relationships between models. When a developer writes ref('orders'), dbt interprets this as: “the current model depends on the orders model.” Similarly, source() indicates dependencies on upstream raw data sources. This declarative approach allows dbt to build a structured and deterministic DAG without scanning SQL for implicit table references.

Option B is incorrect because dbt does not query database objects to infer dependencies; it resolves dependencies at compile time through metadata generated from model files. Option C is incorrect because dbt intentionally does not parse SQL to detect table names—this would be brittle and error-prone across warehouses. Instead, dbt requires explicit references to maintain reliability. Option D is incorrect because YAML files define metadata about models and sources but do not create dependency relationships between them.

Thus, the dependency graph is built exclusively by reading ref() and source() macro calls, which ensures clarity, correctness, and maintainability within the analytics engineering workflow.

The correct answers are C: Exposures describe a downstream use of your dbt project and E: You can run, test, and list resources that feed into your Exposure.

Exposures in dbt are documentation constructs that describe how the outputs of your dbt project are used downstream—such as dashboards, machine learning models, applications, reporting layers, or external tools. They exist to provide visibility into the final layer of the analytics workflow, making it easier to track lineage from raw data → models → downstream consumers.

Option C is correct because the official dbt documentation explicitly states that exposures define the downstream use cases of dbt models. They create transparency about dependencies outside the dbt DAG itself.

Option E is also correct. Using commands like dbt ls --select +exposure: or dbt run --select +exposure:, dbt enables users to run, test, and inspect the upstream resources feeding into the exposure. This is extremely valuable for impact analysis and CI workflows.

Option A is incorrect because exposures are downstream, not upstream—meaning models feed into exposures, not the other way around.

Option B is incorrect because exposures are not materialized in the warehouse; they are metadata stored in YAML.

Option D is incorrect because exposures are defined in YAML files, not SQL files.

Thus, C and E are the correct statements.

For models not stored under finance:

✔ reporter and bi

For models inside the finance folder:

✔ finance, reporter, bi, and public

In dbt, grants configured at the root level apply to all models unless overridden by a more specific folder- or model-level configuration.

The root-level grant is:

+grants:

+select: ['reporter', 'bi']

This means all models by default are selectable by:

reporter

bi

Now the finance folder contains its own override:

finance:

+grants:

+select: ['finance']

When dbt merges grants, overrides do not replace the entire list—they add onto inherited grants unless explicitly cleared. Therefore, models inside the finance folder inherit the parent grants and add the finance grant.

So models under finance are accessible to:

finance

reporter

bi

and public (implicit default in most warehouses unless denied)

Models not inside finance use only the root grants:

reporter

bi

Thus the correct dropdown answers are:

reporter and bi

finance, reporter, bi, and public

Modularity in dbt means breaking transformations into small, reusable steps that are easy to reason about, test, and reuse. In this DAG, two staging models (stg_detail_categories and stg_details) feed into two mart-level models (skills_with_details and lessons_with_details). If there is repeated logic in those two mart models—such as common joins, filters, or derived fields—that logic is a good candidate to be extracted into an intermediate model.

Option E follows dbt best practices: inspect the SQL of lessons_with_details and skills_with_details and identify shared logic to move into a new intermediate model (for example, int_details_with_categories). Both downstream models can then reference this intermediate model using ref(), centralizing logic and improving maintainability.

Options A and B push joins/unions into the staging layer, which should focus on clean, 1:1 representations of sources—not combining multiple sources. Option C collapses distinct staging models into one, reducing clarity and breaking the source-to-staging contract. Option D creates an overly wide, less reusable final table instead of focusing on shared reusable logic.

Therefore, the action that truly increases modularity is Option E: creating an intermediate model based on common SQL patterns.

Will always point to the latest version of the source schema

Correct Match: ✔ defer

Allows to use objects built in the target schema with any downstream tool

Correct Match: ✔ dbt clone

3️⃣ Allows to safely modify objects built in the target schema

Correct Match: ✔ defer

4️⃣ Is a point-in-time operation

Correct Match: ✔ dbt clone

defer and dbt clone serve very different purposes in dbt, and understanding their behavior is essential for choosing the right command.

The --defer flag tells dbt to use already-built objects from a previous environment (often production) instead of rebuilding them. Because it always references the existing target schema’s most recent objects, it “always points to the latest version of the source schema.” Since no objects are overwritten when using defer, it also “allows safely modifying objects built in the target schema”—your development environment uses production objects without altering them.

By contrast, dbt clone creates a point-in-time copy of existing relations. This cloned schema is static; it does not auto-update when source data changes. Therefore, clone is classified as a “point-in-time operation.” Since clone copies physical tables/views into a new schema, downstream tools (BI dashboards, ML pipelines) can safely query the cloned environment without affecting production, making “allows to use objects built in the target schema with any downstream tool” the correct match.

Thus, defer is used for logic substitution without copies, while clone is used for replicable, point-in-time snapshots.

The purpose of this question is to determine how to validate that the input values in the state column support the business logic that determines the is_active field. Since the logic checks whether state = 'Active', it is critical that the state column only contains values that the business process expects. In the example shown, acceptable states appear to be: 'active', 'churned', and 'trial'.

The correct way to enforce this expectation is to apply an accepted_values test on the state column. This ensures that any unexpected state (e.g., 'inactive', 'pending', 'deleted', or NULL) will cause the test to fail, alerting the team that the upstream system is producing unexpected or invalid values. Additionally, adding not_null ensures every user record contains a valid state.

Option A is the only configuration that applies the accepted values test to the correct column (state) and reflects the expected domain of values.

Options B and D incorrectly apply tests to the derived column is_active, not the source column that needs validation. Option C only checks nullability and uniqueness, which does not validate the range of allowed values and thus does not protect the business logic.

Therefore, Option A is the only correct answer.

The correct answers are C and D.

dbt supports two main categories of tests: generic tests and singular tests. Generic tests are defined in YAML and applied to models or columns, while singular tests are written as SQL files placed in the /tests/ directory. This makes Option C correct—singular tests must be created as .sql files inside that folder, and dbt will execute each file as a test query.

Option D is also correct. dbt includes four built-in generic tests: unique, not_null, relationships, and accepted_values. These are considered “native” tests and are available without requiring any additional packages. They cover the most common data quality checks and are applied through YAML configurations on models or columns.

Option A is incorrect because dbt does not automatically apply any tests. All tests—native or custom—must be explicitly defined in YAML or created manually. Nothing is inferred from primary keys.

Option B is incorrect because dbt’s package hub contains community packages, not the list of native tests. Native tests are documented directly within dbt’s core functionality.

Option E is incorrect because the constraints configuration is used to create database-level constraints on supported warehouses, not to run dbt tests. Tests still require YAML test definitions or .sql files.

Thus, only C and D accurately describe dbt's testing behavior.

The behavior described—dbt running the orders model as a view despite being explicitly configured as a table—indicates that dbt is not correctly detecting or applying the model-level configuration during compilation. dbt relies heavily on the target-path directory to write compiled SQL, manifest files, and run artifacts. If the target-path is misconfigured, pointing to a location that dbt does not handle correctly or that overlaps with another folder used internally, dbt may fail to load the correct configuration from the merged project settings.

When dbt cannot locate the compiled configuration for a model, it defaults to its standard materialization type, which is view. This explains why the logs show:

“Finished running 1 view model”

even though the dbt_project.yml clearly declares:

materialized: table.

Additionally, the logs indicate no warnings or parsing errors, meaning dbt ran successfully but with incorrect settings—another indicator of configuration metadata being overridden or misplaced due to an incorrect target-path.

By resolving the target-path issue, dbt will successfully load the model configuration and materialize the orders model as a table as intended.