The correct answer is C: Underlying data must be accessible on your data platform.

dbt does not perform data ingestion or data loading. Instead, dbt operates after raw data is already available in your warehouse. This means that before dbt can build any models—whether staging, intermediate, or mart-layer models—the underlying source data must already exist and be accessible in the connected data platform (Snowflake, BigQuery, Redshift, Databricks, etc.). dbt uses SQL to transform existing relations; therefore, if the data platform cannot access the underlying tables or external sources, model execution will fail.

Option A is incorrect because sources do not need to be defined before building models. Models can be built without using sources at all. Source definitions are optional metadata and lineage declarations, not prerequisites.

Option B is incorrect because service accounts are not required; dbt can connect through any credential mechanism supported by the warehouse (OAuth, user accounts, tokens, etc.).

Option D is incorrect because dbt itself performs transformations on raw data—cleaning raw data beforehand is not required; in fact, that is one of dbt’s main responsibilities.

Thus, the only true prerequisite is that the warehouse must contain accessible underlying data.

The goal in this scenario is:

Select only models, tests, and snapshots that were modified in development, using:state:modified

Use already-built production objects whenever possible, so development does not need to rebuild everything. This is done with:--defer

Compare development code against production artifacts, which requires:--state

Run everything (models + tests + snapshots) in a single command. This is exactly what dbt build does.

dbt build = run models + run tests + run snapshots + run seeds.

Putting it all together, the correct command is:

dbt build --select state:modified --defer --state

This single command satisfies all requirements:

It runs only modified resources.

It uses the production state artifacts for comparison.

It defers to production-built models where possible.

It runs all resource types automatically.

Why the other options are incorrect:

A → Missing --state, so state:modified cannot function.

B → Splits run + test separately; question asks which single command you will invoke.

D → Missing --defer, which defeats the purpose of using production objects.

E → Also missing --defer.

Thus, Option C is the only correct answer.

The correct answers are A and C.

dbt clone is a command introduced to efficiently replicate existing relations (tables/views) from one schema/environment to another within the same warehouse without fully rebuilding them. It typically leverages warehouse-level “clone” functionality (e.g., Snowflake zero-copy clone). To know what to clone, dbt needs information about previously built models; this is stored in artifacts like manifest.json. Therefore, A is correct: it requires a reference to a previous manifest/state to know which models and locations to operate on.

C is also correct because cloning a production schema into a development schema enables you to test code changes while pointing downstream tools (like BI dashboards) at the cloned data. That way, BI or ML systems can exercise new dbt logic without impacting real production objects.

Option B describes state:modified / state comparison behavior, but dbt clone does create (or clone) objects, so B is false.

Option D is incorrect because clone works within a warehouse, not across different warehouses.

Option E is wrong: _v# suffixing is for model versioning, not cloning.

Thus, A and C correctly describe the behavior and purpose of dbt clone.

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.

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.

The correct answer is B: By adding the configurations in dbt_project.yml within the package’s namespace.

dbt packages are installed as read-only code, meaning you should never modify files inside /dbt_packages, nor should you attempt to overwrite generated artifacts inside /target. Instead, dbt provides a clean and officially supported method for overriding or extending configurations on models from packages: using the dbt_project.yml file.

Each package comes with its own namespace, and users can override model-level configurations by referencing that namespace inside the models: section of dbt_project.yml. dbt merges project-level configurations with package-level defaults, and configurations defined in dbt_project.yml take precedence. This is the only correct and recommended way to override settings such as materializations, tags, schema, or custom config blocks on models imported through a package.

Option A is incorrect because packages.yml is used only to declare package dependencies—not to configure package models. Option C is incorrect because the ./target folder contains compiled and ephemeral artifacts that should never be edited. Option D is incorrect because modifying code in /dbt_packages violates dbt best practices and will be overwritten each time packages are reinstalled.

Therefore, overriding configurations must be done exclusively through dbt_project.yml.

Hook 1

on-run-end: "{{ macro_x() }}"

Answer: macro_1

Hook 2

models:

:

post-hook: "{{ macro_x() }}"

Answer: macro_2

Hook 3

on-run-start: "{{ macro_x() }}"

Answer: macro_3

Hook 4

{{

config(

pre-hook: "{{ macro_x() }}"

)

}}

Answer: macro_4

dbt supports run-level hooks and model-level hooks. Run-level hooks fire once per invocation, while model-level hooks fire around each individual model.

on-run-end is a run-level after hook that executes once after the entire dbt command completes. Because macro_1() must run after every dbt run, it correctly belongs here.

The post-hook configured under the models: section runs after each model in that scope finishes building. This matches the requirement for macro_2() to execute after a model runs.

on-run-start is a run-level before hook and fires once before dbt begins executing any models for that command, making it the right place for macro_3() which must run before every dbt run.

Finally, the pre-hook specified inside a model’s config() block runs before that specific model is built. Since macro_4() must execute before a model runs, it belongs in the pre-hook configuration.

Thus the correct mapping is:

on-run-end → macro_1

model post-hook → macro_2

on-run-start → macro_3

model pre-hook → macro_4.