Pass the dbt Labs Analytics Engineers dbt-Analytics-Engineering Questions and answers with CertsForce

In dbt’s recommended layered modeling architecture, the staging layer is intended to provide a clean, one-to-one representation of raw source tables. Each stg_ model should depend only on sources, not on other staging models. This ensures staging remains a simple, transparent layer where data is renamed, recast, standardized, and lightly transformed before being passed to intermediate and mart layers.

In the DAG shown, at least one staging model (for example, stg_line_items or stg_tpch_line_items) appears downstream of another staging model, meaning a stg_ model is referencing another stg_ model. This violates dbt’s recommended modeling practice, because it creates unnecessary complexity in the staging layer and reduces modularity and transparency. Downstream layers such as intermediate (int_) and marts (fct_) should be used to combine, enrich, or join multiple staging outputs.

When staging models depend on each other, it becomes harder to trace lineage, reduces clarity about where transformations occur, and complicates the entire DAG. The proper pattern is:

Sources → Staging (stg_) → Intermediate (int_) → Marts (fct_)

Since the DAG shows staging models referencing other staging models, the rules have indeed been violated.

dbt model contracts enforce that the column names, data types, and number of columns defined in the contract exactly match the columns produced by the compiled SQL. If any column appears in one location (the contract or the SQL) but not in the other, dbt raises an enforcement error.

In this scenario, the error message shows:

ORDER_ID is missing in the model definition, meaning the SQL no longer contains a column named order_id, but the contract still expects it.

ORDER_KEY is missing in the contract, meaning the model SQL now contains a new column, but this column has not been added to the contract.

To fix the mismatch, you must remove columns from the contract that no longer exist in the SQL and add to the contract any new columns that now appear in the SQL.

Therefore:

Option A — Remove order_id from the contract — is correct because the column no longer exists in the model SQL.

Option D — Add order_key to the contract — is correct because the SQL now produces this column.

Options B and C incorrectly alter the wrong side of the definition, and Option E would create a mismatch in the opposite direction.

Thus, the correct fixes are A and D.

The correct answer is D: Declare the external table as a source using the external configuration.

When data arrives in an external storage system such as S3, many warehouses (like Snowflake, BigQuery, and Databricks) support external tables that reference data stored outside the warehouse. dbt fully supports external tables by allowing them to be declared as sources using the external: configuration block inside sources: in a YAML file. This tells dbt that the upstream object exists outside the warehouse and should not be materialized or transformed by dbt directly. It also enables dbt to include external data in lineage graphs, freshness checks, and downstream model dependencies.

Option A is not ideal because you still need to formally register the external table as a source; simply querying it in a model breaks the data lineage structure. Option B is unnecessary and operationally brittle—temporary tables are not required for external data ingestion. Option C is incorrect because dbt seed is intended for uploading local static CSV files, not files arriving via S3 or controlled by external vendors. Seeds do not support dynamic ingestion patterns.

Thus, the correct and documented method is to declare the external table as a source with the external configuration, allowing dbt to consume the data appropriately while maintaining proper governance and lineage.

The --fail-fast flag tells dbt to stop scheduling any new nodes as soon as one node fails. Importantly, dbt does not kill models that are already running; in-flight nodes are allowed to finish.

Here’s what happens step by step with 2 threads:

Roots model_a and model_b start first.

model_a finishes successfully. That makes model_c eligible to run.

dbt now runs model_b and model_c in parallel.

While they are running, model_b fails.

Because --fail-fast is set, dbt immediately stops scheduling any additional models (like model_d, model_e, or model_f).

model_c was already running when model_b failed, so it is allowed to complete successfully.

Downstream models of either branch (model_d, model_e, and model_f) never start, because fail-fast prevents any further nodes from being queued after the first failure.

So, the only models that successfully build during this run are:

model_a (completed before model_b failed)

model_c (already running at the time of failure and allowed to finish)

Hence the correct choice is B: model_a, model_c.

The true root cause is not related to run hooks or regular expressions. The warning clearly indicates that dbt found a configuration path that does not match any actual model path inside the project. In this case, the config block uses the key models.jaffle-shop, which is incorrect because dbt model paths must match the folder structure and cannot contain hyphens unless the folder itself contains a hyphen. Since the project folder is named jaffle_shop (with an underscore), dbt cannot map the configuration to any model.

dbt evaluates configuration paths based on directory names under the models/ folder. A mismatch between the folder name and the configuration key causes dbt to ignore the configuration entirely. This results in the warning:

“Configuration paths exist in your dbt_project.yml file which do not apply to any resources.”

This warning is specifically triggered when dbt identifies unused configuration paths due to typos, incorrect nesting, or invalid identifiers. dbt does not interpret hyphens (-) as valid Python identifiers for resource names, so a config path like models.jaffle-shop will never be applied.

Therefore, the assertion that the cause is a "run hook with an incorrect regular expression" is incorrect. The actual root cause is that the configuration path uses the wrong name (jaffle-shop instead of jaffle_shop).

When converting a model-specific SQL query into a generic test, dbt expects the test macro to accept the two standard arguments used across all generic tests: model and column_name. These arguments allow dbt to automatically pass the correct table and the correct column when the test is applied in YAML.

The argument model represents the actual relation (table/view) being tested. dbt compiles the reference itself—so instead of writing ref('stg_orders'), generic tests always use {{ model }} to represent the referenced relation.

The argument column_name represents the actual column being tested. In this case, the hard-coded column amount_usd becomes the dynamic argument {{ column_name }}, allowing you to apply the logic to any numeric or validated column across multiple models.

So the generic version of your SQL becomes:

select *

from {{ model }}

where {{ column_name }} < 0

The other options are incorrect:

source is not the standard argument for generic tests.

model_name is not automatically passed by dbt.

field is not a recognized standard test argument.

Thus, the two correct standard arguments are model and column_name.

The correct answers are A: schema and C: tags.

In dbt, the dbt_project.yml file is the central configuration file that defines model-level settings. Under the models: section, you can specify a wide range of model configurations such as schema, materialized, tags, alias, and custom meta fields. The schema configuration allows you to control which database schema a model should be built in, giving analytics engineers the flexibility to organize models by domain or environment. The tags configuration is also valid under models: and is widely used to group models logically for selection, documentation, or orchestration workflows.

Option B (source) is incorrect because sources are defined under YAML files in the sources: section, not under models: in dbt_project.yml. Option D (test) is incorrect because tests must be defined in model or source YAML files, not inside the project configuration. Option E (target) is not a configuration that applies to models; rather, it refers to dbt runtime environments and cannot be configured under the models: block.

dbt's project configuration system ensures that model-level behavior is managed centrally and consistently, and schema and tags are two of the officially supported configuration keys under models:.

In dbt, a singular test is any SQL file placed directly inside the tests/ directory—not inside the tests/generic/ folder. Singular tests contain a custom SQL query where returning any rows means failure. They are distinct from generic tests, which are YAML-defined and live inside the generic directory, often referencing macros.

Looking at the folder structure:

In tests/generic/

furniture_customers_test.sql → This is a generic test, not a singular test.

In the root tests/ directory

macro_stg_tpch_orders_assert_pos_price.sql → singular test

macro_stg_tpch_suppliers_assert_pos_acct_bal.sql → singular test

stg_tpch_orders_assert_positive_price.sql → singular test

When you run:

dbt test --select 'test_type:singular'

dbt selects only singular tests, meaning tests that are individually written SQL files in the top-level tests/ directory.

Therefore, dbt will run:

macro_stg_tpch_orders_assert_pos_price

macro_stg_tpch_suppliers_assert_pos_acct_bal

stg_tpch_orders_assert_positive_price

It will not run furniture_customers_test, because that file is inside tests/generic/, which is reserved for template-based generic tests and is not classified as singular.

Thus, the correct answer is Option C.

Check your terminal or log file for the output from the most recent dbt run.

Look for specific error messages associated with the models that failed.

3️⃣ Isolate the problem by dbt run --select model_name to run a single model and confirm whether the issue is localized to that model.

4️⃣ Use dbt run --select model_name+ to run the model and its downstream dependencies, ensuring that your fix works across the DAG.

Brief Explanation

First, you always inspect the latest run output (step 1).

Then, identify the exact failing models and error messages (step 2).

Next, you reproduce the issue on the individual model to be sure the fix works locally (step 3).

Finally, you re-run the model plus its downstream dependencies to validate the fix across the DAG (step 4).