Free Databricks Certified Data Engineer Professional Sample Questions

Correct answer: A — Use a Lakeflow Spark Declarative Pipeline, since it declaratively infers table dependencies and orchestration order and integrates expectations for quality tracking without extra orchestration code

• A. Correct. Lakeflow Spark Declarative Pipelines infer the dependency graph between declared tables and orchestrate the run order automatically, and expectations provide built-in, queryable data quality tracking, matching both stated requirements directly.
• B. Incorrect. Hand-written Structured Streaming jobs require the engineer to manually sequence and orchestrate bronze, silver, and gold writes; there is no automatic dependency inference between separate `foreachBatch` streams.
• C. Incorrect. Structured Streaming has no built-in expectations mechanism or event log for data quality; any such tracking would need to be custom-instrumented by the engineer, unlike the pipeline framework's native support.
• D. Incorrect. Lakeflow Spark Declarative Pipelines still rely on checkpoints internally to track streaming progress; the framework manages checkpoint locations for the engineer rather than eliminating the underlying need for them.

Correct answer: A — File notification mode, which subscribes to cloud storage event notifications so new files are discovered as they arrive instead of by repeated directory scans

• A. Correct. File notification mode uses cloud provider event notifications to detect new files as they land, avoiding repeated full directory listings and giving lower-latency, lower-cost discovery for high-volume, near-real-time sources.
• B. Incorrect. Directory listing mode is the approach that repeatedly scans the path for new files; it is simpler to set up but is exactly the higher-cost, higher-latency behavior the team is trying to avoid at high volume.
• C. Incorrect. Trigger-once controls how often the streaming query itself runs, not how files are discovered within a run; it does not provide continuous background file discovery between scheduled runs.
• D. Incorrect. Schema inference determines the structure of incoming data by sampling files, not how new file arrivals are detected; it is unrelated to the choice between listing and notification-based discovery.

Correct answer: A — Read the parameter value at module import time and wrap the decorated debug table's definition in an `if` block so the function is only registered with the pipeline when the flag is true

• A. Correct. Because the pipeline graph is built by executing the Python source at graph-construction time, reading the parameter and conditionally registering the decorated function inside an `if` block controls whether that table is included in the graph at all, avoiding any compute cost when the flag is false.
• B. Incorrect. Defining the table unconditionally still creates and maintains it every run, including allocating storage and running refreshes, so filtering rows in the query does not avoid the extra compute the requirement is trying to eliminate.
• C. Incorrect. There is no scheduler feature that automatically skips refreshing tables based on a debug-only tag; every declared table in the graph is maintained according to the pipeline's normal update logic unless conditionally excluded in code.
• D. Incorrect. Wrapping the definition in a try/except to swallow errors is not a reliable or intentional way to control table inclusion; it risks masking real errors and does not deterministically implement the parameter-based condition.

Correct answer: A — Convert the Python UDF to an Arrow-optimized UDF by setting `useArrow=True` during UDF definition or enabling `spark.sql.execution.pythonUDF.arrow.enabled`, which uses Apache Arrow to reduce serialization overhead.

• A. Arrow-optimized Python UDFs use Apache Arrow columnar serialization instead of traditional pickling, significantly reducing per-row overhead. Databricks documentation reports speedups of 1.6–1.9× with this approach while requiring only minimal code change (e.g., adding `useArrow=True`).
• B. Packaging format (egg vs wheel) affects library distribution and loading, not per-row execution speed. The bottleneck is UDF serialization overhead, which is unrelated to package format.
• C. While Java UDFs can avoid Python overhead, a full rewrite requires substantial effort and is not the least-change option. Arrow-optimized Python UDFs efficiently handle large volumes without a language switch.
• D. Caching avoids recomputation but does not eliminate the overhead of the Python UDF execution itself. The per-row Python invocation and serialization remain the primary bottleneck.

Correct answer: A — Move the transformation functions from notebook cells into a separate Python module (e.g., a .py file) within the bundle, then use pytest to test that module in the CI pipeline before deployment.

• A. Extracting functions into a standalone module decouples them from the notebook environment, allowing pytest to run in CI without deploying to the workspace. Databricks bundles support Python files and can import these modules, making the logic reusable, maintainable, and testable with standard unit testing practices.
• B. This command validates only the bundle’s YAML schema and references—not the transformation logic itself. It ensures correct configuration but does not test Python functions or their behavior.
• C. Nightly runs verify the entire pipeline in the workspace but do not provide rapid, pre-deployment feedback in CI. They also do not use pytest, and failures after code is merged defeat the purpose of early testing.
• D. This option performs runtime validation of a deployed job or pipeline, but it requires prior deployment to the workspace. It does not allow running pytest against isolated transformation functions before deployment.

Correct answer: A — New files are discovered through cloud provider event notifications rather than by repeatedly listing the entire directory tree, which scales better as file counts grow

• A. File notification mode subscribes to cloud provider event notifications (such as queue-based file-arrival events) instead of repeatedly listing the full directory, which avoids the growing listing cost and latency that directory listing incurs as file counts scale into the millions.
• B. Auto Loader still requires a checkpoint location to track processing progress and state even in notification mode; the notification queue supplements file discovery but does not replace checkpointing.
• C. Notification-based systems can still experience duplicate or occasionally missed events depending on the cloud provider's delivery guarantees, so Auto Loader's downstream processing still needs to handle such cases rather than assuming a perfect guarantee.
• D. Notification mode only changes how new files are discovered; it does not convert source file formats to Delta or eliminate the schema inference step for the ingested data.

Correct answer: A — Structured Streaming with Auto Loader offers maximum low-level customization, while using Auto Loader inside a pipeline provides more automation with somewhat less manual control

• A. Current guidance describes a layered approach where standalone Structured Streaming with Auto Loader gives maximum customization, while embedding Auto Loader inside a Lakeflow Spark Declarative Pipeline trades some manual control for more built-in automation such as managed checkpointing and orchestration.
• B. The two approaches differ meaningfully in automation and control trade-offs; treating them as functionally identical misrepresents the layered guidance Databricks provides for choosing between them.
• C. Auto Loader is fully supported as a standalone Structured Streaming source outside of any pipeline context, so this claim of exclusivity to pipelines is incorrect.
• D. There is no indication that standalone Structured Streaming usage of Auto Loader is being deprecated; both usage patterns remain supported as complementary options at different levels of the ETL stack.

Correct answer: A — NTILE(4) OVER (PARTITION BY region ORDER BY total_spend), which divides each region's ordered rows as evenly as possible into four numbered buckets.

• A. NTILE(4) is designed exactly for this use case: it splits the ordered rows within each partition into four groups of as-equal-as-possible size and labels each row with its bucket number, giving the requested spend tiers.
• B. PERCENT_RANK produces a continuous relative-rank value between 0 and 1 for each row rather than assigning rows to one of a fixed number of discrete tiers, so it does not directly answer the tiering requirement.
• C. CUME_DIST computes the cumulative distribution fraction up to and including the current row's value, which describes relative standing but does not partition customers into four labeled groups.
• D. ROW_NUMBER only produces a unique running position for each customer within the region and carries no notion of grouping rows into a fixed number of tiers.

Correct answer: A — A left anti join of orders against shipments on order_id, which returns only the orders rows that have no matching shipments row.

• A. A left anti join returns exactly the rows from the left table that find no matching key on the right side, and it never includes any right-side columns, which matches both requirements precisely.
• B. A left semi join is the opposite filter: it keeps only orders rows that do have a match in shipments, which returns the shipped orders rather than the unshipped ones the engineer needs.
• C. A full outer join keeps unmatched rows from both orders and shipments plus all matched rows, so it must be filtered afterward and also temporarily carries shipments columns, adding unnecessary shuffle and complexity.
• D. An inner join followed by NOT IN filtering starts from only the matched rows, so it cannot recover the unmatched orders at all since they were excluded before the filter runs.

Correct answer: A — Define two flows from the same source: one flow with an expect_or_drop expectation writing only valid rows to the main table, and a second flow with the inverse condition writing only the invalid rows to a separate quarantine table.

• A. Splitting the source into two flows, one dropping invalid rows into the main table and a second one applying the opposite validation logic to isolate only the invalid rows, is the documented quarantine pattern that preserves bad records for investigation without contaminating the main table.
• B. The pipeline event log only stores aggregate violation counts and metadata, not the actual row content, so it cannot serve as a queryable quarantine table containing the failing records themselves.
• C. Using warn mode leaves invalid rows mixed into the main table, which contaminates the production dataset with bad data rather than isolating it, defeating the purpose of a quarantine table.
• D. Fail mode halts the entire update on the first bad row, which stops processing of all remaining rows in the batch rather than continuing to route only the invalid ones to a quarantine table.

Correct answer: A — Add the Unity Catalog volume as a shared object on the share, since Delta Sharing directly supports sharing non-tabular assets such as volumes

• A. Delta Sharing has expanded beyond tables to support sharing Unity Catalog volumes and other non-tabular assets directly through a share, which avoids reformatting the files or building separate infrastructure.
• B. Converting files into binary table rows is unnecessary rework; Delta Sharing can add a volume as a shared object directly, preserving the files in their native form.
• C. Granting direct storage credentials bypasses Unity Catalog governance and the share's access controls, and it is not required since volumes can be shared as first-class objects.
• D. Emailing compressed archives is a manual, ungoverned process that does not provide live access, audit trails, or revocation, all of which sharing a volume through Delta Sharing already provides.

Correct answer: A — Add the entire schema as a shared object on the share, so tables created in that schema afterward are included without additional share edits

• A. A share can include an entire schema as a shared object, and tables subsequently created in that schema are automatically covered, removing the need to edit the share for every new table.
• B. Shares are not limited to referencing tables one at a time; adding the schema itself is the supported way to avoid manual per-table additions going forward.
• C. Creating a new share and re-granting access for every future table adds unnecessary administrative overhead when a single schema-level share object already covers this case.
• D. A nightly job that rewrites the share definition duplicates functionality that adding the schema as a shared object already provides natively and continuously, not just once a day.

Correct answer: B — False

• A. This is false: Lakehouse Federation provides governed, read-only access to external systems through foreign catalogs, so write operations back to the source are not supported.
• B. This is correct: foreign catalogs created through Lakehouse Federation are read-only, so users can query external data but cannot write changes back into the source system through that connection.

Correct answer: A — The Databricks CLI, which wraps the REST API with commands such as jobs list-runs and jobs get-run

• A. The Databricks CLI provides subcommands like jobs list-runs and jobs get-run that wrap the same REST API but present a scriptable command-line interface, which is exactly what a shell script needs without hand-building HTTP calls.
• B. The Query Profile UI is a browser-based visualization for a single query's execution plan; it has no scripting or curl-export feature intended for job-run automation.
• C. The event_log table-valued function must be run as SQL against a pipeline identifier and returns pipeline event rows, not job run status, and it still requires a SQL execution context rather than shell scripting.
• D. compute.clusters can be queried via JDBC/ODBC or the SQL API from many clients, not only a shell-bound JDBC driver, and it returns cluster configuration rows rather than job run status.

Correct answer: A — Contextual source metadata about the event, such as cloud region, pipeline identifier, and update identifier

• A. The origin field is documented as JSON metadata describing where an event came from, including details like cloud provider, region, and identifiers for the pipeline and update, which is contextual source information rather than event content.
• B. Data quality pass and drop counts live inside the details field for flow_progress events, not in origin, since origin describes where the event originated rather than what it measured.
• C. The human-readable summary of what happened is carried in the message field, which is a separate column from origin.
• D. Ordering information for events is carried in the sequence field, which is distinct from origin and specifically exists to identify and order events.

Correct answer: A — Use Repair run to re-execute only the failed task and its downstream dependents, but first confirm the failed task's write logic is idempotent so partial output is not duplicated.

• A. Correct. Repair run re-executes only the unsuccessful task and any tasks that depend on it, leaving already-successful tasks untouched, but because a repair reruns the failed task from the beginning, non-idempotent writes risk duplicating the partial output it already wrote before failing.
• B. Incorrect. Databricks Jobs explicitly supports repairing multi-task runs by re-executing only unsuccessful and dependent tasks, so recreating the entire job is unnecessary extra work that discards the benefit of partial success.
• C. Incorrect. Truncating tables written by tasks that already succeeded is wasteful and risky, since Repair run is specifically designed to avoid re-running tasks that completed successfully.
• D. Incorrect. Raising max_concurrent_runs allows multiple independent runs of the same job to execute simultaneously; it does not repair or resume a specific failed run and could cause conflicting concurrent writes to the same table.

Correct answer: A — Both the webhook to the system destination and the email to the distribution list are sent independently for the same on_failure event.

• A. Correct. email_notifications and webhook_notifications are independent fields on a job, and configuring both for the same event, such as on_failure, results in both notification paths firing separately when that event occurs.
• B. Incorrect. Adding a webhook destination does not disable or override email notifications; the two mechanisms coexist and are evaluated independently for each configured event.
• C. Incorrect. There is no built-in escalation delay that waits for an email to be read before sending a webhook; both configured notifications are dispatched at the time the event occurs.
• D. Incorrect. Databricks does not merge email and webhook notifications into a single payload routed only to one destination type; each configured channel receives its own notification for the event.

Correct answer: A — Create a Databricks SQL alert on a query that counts rows with negative revenue in the aggregated table, with a condition that triggers when the count is greater than zero.

• A. Correct. A SQL alert querying for the count of negative-revenue rows directly targets the specific data quality condition described, firing a notification when the aggregation logic produces an impossible value, independent of whether the job itself completed successfully.
• B. Incorrect. A negative revenue value is a valid numeric result as far as the job engine is concerned; it does not cause an exception or task failure, so on_failure would not fire in response to this specific data quality issue.
• C. Incorrect. There is no inherent reason a negative revenue value would cause the aggregation query to run longer than normal, so a duration-based notification would not reliably detect this data quality problem.
• D. Incorrect. Skipped runs occur when a job's trigger conditions are not met and the run never executes at all; they are unrelated to a data quality defect produced by a run that did execute.

Correct answer: A — All downstream readers must run Databricks Runtime 12.2 LTS or above, since older runtimes cannot interpret deletion vector metadata.

• A. Reading a table with deletion vectors requires a runtime that understands how to apply the deletion vector bitmap to reconstruct the current table state, and Databricks documents Runtime 12.2 LTS as the minimum version capable of reading such tables. Jobs on older runtimes would fail or return stale data.
• B. Deletion vectors are supported on both classic clusters and serverless SQL warehouses as long as the runtime version requirement is met; there is no restriction requiring serverless-only compute. This constraint does not exist.
• C. Photon supports reading tables with deletion vectors and does not need to be disabled; in fact Photon can accelerate the merge-on-read process used to apply deletion vector bitmaps. This is not a real limitation.
• D. Deletion vector support is a Delta protocol and runtime capability, not a language-specific limitation, so Python-based Delta readers on a supported runtime handle deletion vectors the same as Scala readers. Rewriting jobs in Scala is unnecessary.

Correct answer: A — Partition pruning eliminates entire partition directories using the region predicate, while data skipping uses per-file min/max statistics to skip individual files within a partition based on the order_date predicate.

• A. Partition pruning uses the physical directory structure created by a partitioning column like region to skip whole directories before even reading file metadata, while data skipping is a finer-grained mechanism that reads file-level min/max statistics stored in the transaction log to skip individual files based on a predicate like order_date. This correctly separates the two complementary mechanisms.
• B. Partition pruning and data skipping are distinct mechanisms operating at different granularities — one at the directory level based on partition values, the other at the file level based on stored statistics — so treating them as identical mischaracterizes how Delta query planning actually works.
• C. This reverses the two mechanisms: partition pruning is what uses the physical partition scheme (region), while data skipping is what uses file-level statistics (such as on order_date); pruning also does not physically delete files, it simply avoids reading them for a given query.
• D. Both partition pruning and data skipping apply to Delta tables generally and are independent of whether deletion vectors are enabled, and neither mechanism is restricted to being usable only with raw Parquet files outside of Delta. This statement misattributes both constraints.

Correct answer: A — Enable Change Data Feed on the source table so the stream can read row-level insert, update, and delete events instead of only append-only changes.

• A. By default, Structured Streaming against a Delta table only supports append-only sources and cannot represent row updates or deletes as stream events; enabling Change Data Feed exposes every row-level insert, update, and delete as a distinct change record with _change_type metadata that a stream can consume, which is exactly the capability needed here. This is the documented purpose of the feature.
• B. maxFilesPerTrigger only controls how many new files are considered per micro-batch for an append-only streaming read; it does not change what kinds of row modifications the stream is capable of representing, so updates and deletes upstream still would not surface as events. This does not solve the limitation.
• C. Trigger.AvailableNow changes how frequently and in what batches a stream processes available data, but it does not add support for consuming update or delete events from a standard Delta source; that capability specifically requires Change Data Feed. This trigger mode is unrelated to the described limitation.
• D. Repartitioning a table changes the physical file layout for performance purposes but has no effect on what change types Structured Streaming can detect from a Delta source; it does not introduce any new event semantics. This does not address the streaming limitation described.

Correct answer: B — False

• A. False is the correct answer, so True is incorrect: Unity Catalog row filters and column masks explicitly cannot be applied to streaming tables, which is one of the documented limitations of the feature.
• B. False is correct because streaming tables are explicitly excluded from row filter and column mask support in Unity Catalog; the engineer would need an alternative such as a dynamic view over the streaming table's downstream materialization.

Correct answer: A — The second ALTER TABLE statement replaces the existing row filter, since only one row filter can be bound to a table at the table level at any time

• A. This is correct because Unity Catalog only supports one row filter per table at the table level, so issuing a new SET ROW FILTER statement replaces whichever filter function was previously bound to that table.
• B. This is incorrect because ALTER TABLE ... SET ROW FILTER is a valid, re-runnable statement; it does not error out simply because a filter was previously set, it instead updates the binding.
• C. This is incorrect because table-level row filters are limited to one filter per table; the engine does not combine multiple table-level row filter functions into an AND condition.
• D. This is incorrect because the statement is not silently ignored; it is a valid DDL operation that updates the table's metadata to bind the new filter function, replacing the previous one.

Correct answer: A — A column mask function can accept additional columns as parameters, letting the masking logic branch on the value of another column in the same row in addition to the querying user's attributes.

• A. Unity Catalog column masks can be defined to take multiple columns as parameters, allowing the masking function to use the value of another column in the same row — such as a country code — to decide how to transform the masked column, which is exactly the row-varying behavior described.
• B. Column masks are not restricted to a single-column input; they support additional row column parameters specifically so masking behavior can vary based on other data in the row, which is a documented and commonly used capability rather than a limitation requiring a row filter.
• C. Multi-column mask parameters are a generally available capability of Unity Catalog masking, not a preview feature disabled in production; this option invents a restriction that does not reflect current documented behavior.
• D. Column masks are SQL UDFs evaluated at query time for each row returned, not cached once at table creation; this per-row, per-query evaluation is what allows the mask to branch dynamically on another column's value like `country_code`.

Correct answer: A — The materialized view automatically reflects the deletion through incremental or full recomputation as needed, without requiring the team to manually re-run a DELETE against the view itself.

• A. Materialized views in the Lakeflow framework are designed to automatically stay consistent with their source tables, applying incremental recomputation where possible or falling back to full recomputation, so a delete on the source table is reflected in the materialized view without any manual reapplication of the delete.
• B. Materialized views are not static snapshots that permanently freeze data from creation time; they are refreshed to reflect changes in their source, so a deleted row's contribution does not persist indefinitely without the drastic step of dropping and rebuilding the entire view.
• C. Materialized views are explicitly designed to handle upstream changes including deletes, updates, and inserts as part of normal refresh processing; encountering a deleted row upstream does not cause a hard failure on every subsequent refresh.
• D. Unlike streaming tables, which are append-oriented and can require explicit handling of non-insert changes, materialized views are built specifically to reconcile with arbitrary source changes automatically, so manually re-running the same DELETE against the view is not the documented or necessary behavior.

Correct answer: A — BROWSE, which surfaces metadata for objects in Catalog Explorer without granting SELECT on the underlying data.

• A. Correct. BROWSE is designed exactly for this case: it lets users view metadata for catalogs, schemas, tables, and volumes in Catalog Explorer to support self-service discovery, without granting SELECT or any other data-access privilege.
• B. Incorrect. USE SCHEMA is a traversal privilege required to reference a schema in a query path; it does not by itself expose metadata browsing, and it is not a substitute for BROWSE.
• C. Incorrect. This still requires granting SELECT plus building and maintaining a row filter function, which is significantly more setup than necessary and does not match the standard discovery pattern.
• D. Incorrect. MANAGE is an administrative privilege for managing the object and its permissions; granting it to end users for browsing purposes is far broader than needed and is not its intended purpose.

Correct answer: A — The user loses access to the catalog's tables, because Unity Catalog evaluates group membership dynamically at query time against current grants.

• A. Correct. Unity Catalog checks group membership at query execution time against the identity provider, so once a user is removed from a group, any access that depended solely on that group's grants is lost immediately, without needing to touch the grant itself.
• B. Incorrect. There is no permission cache that needs refreshing by revoking and re-granting; access evaluation already reflects current group membership at query time.
• C. Incorrect. Unity Catalog has no built-in grace period for retaining privileges after a group membership change; access reflects the identity provider's current state.
• D. Incorrect. If the user's only path to the privilege was through the group they were removed from, no unrelated nested subgroup membership would independently preserve that specific catalog grant.

Correct answer: A — Apply a governed "certified" tag to each table once it passes review, so the status is visible consistently across catalogs in Catalog Explorer.

• A. Correct. A governed "certified" tag applied consistently across tables gives a standardized, centrally controlled status indicator that shows up wherever the asset is browsed, without needing to touch the table's identity or location.
• B. Incorrect. Embedding status in the table name is brittle, requires renaming (and potentially breaking downstream references) if certification status ever changes, and doesn't scale as well as a tag.
• C. Incorrect. Physically relocating certified tables into a separate catalog requires costly data movement and breaks the natural organizational structure of the existing catalogs for no governance benefit over tagging.
• D. Incorrect. Unity Catalog does support asset status concepts through tags such as certified and deprecated; relying solely on an external ticketing system disconnects the status from the object itself.

Correct answer: A — The cluster event log, since it records lifecycle events such as init script failures, capacity errors, and library install errors before any Spark application starts.

• A. The cluster event log tracks lifecycle events at the infrastructure level, including init script and library installation failures and cloud provider errors, which is exactly what happens before a Spark application ever begins, matching this scenario.
• B. The Stages tab only populates once a Spark application has started and stages have been scheduled; a cluster that never launched any executors has no Spark application to report stage-level detail for.
• C. system.query.history records SQL query executions on warehouses and clusters, not cluster provisioning or init script failures, so it would not contain the startup error being sought.
• D. Corrupted table metadata can cause query failures once a job is running, but it has no bearing on whether a cluster's underlying compute nodes and init scripts succeed during provisioning.

Correct answer: C — Databricks provisioned a new job cluster instance for the repair attempt, since repairing tasks that share a job cluster creates a fresh cluster for the repair, distinct from the original run's cluster.

• A. This mischaracterizes the cluster as an unrelated autoscaling artifact, when in fact Databricks does deliberately provision a distinct job cluster instance for a repair attempt when a shared job cluster is in use.
• B. The repair does not fall back to a general-purpose all-purpose cluster; it provisions a new job cluster instance of the same configuration for the repair, which is a normal and expected part of the repair workflow, not a failure.
• C. When a repair run affects tasks sharing a job cluster, Databricks provisions a new cluster instance for those tasks so the original run's cluster and the repair's cluster remain distinguishable in the cluster list, which matches the suffixed naming the engineer observed.
• D. This new cluster instance is a direct and expected consequence of the repair action itself, not an unrelated duplicate created by cluster policy enforcement, and it does not need to be manually terminated for the repair to proceed.

Correct answer: A — Under development mode the pipeline is marked development: true automatically, while production mode requires it to be explicitly set to development: false

• A. Development mode automatically marks deployed Lakeflow pipelines as development: true for faster iteration, while production mode validation requires pipelines to be explicitly set to development: false, enforcing a clear separation between iterative and production pipeline runs.
• B. The development field is a real bundle-managed pipeline property that deployment modes actively set or validate; it is not ignored by the CLI or left solely to a post-deployment UI toggle.
• C. The two modes apply opposite expectations for this field rather than standardizing on the same value, since production mode specifically requires false while development mode sets true.
• D. Bundles do not reject pipeline resources that declare the development field explicitly; declaring it is compatible with both modes, though production mode enforces which value it must hold.

Correct answer: A — Bundles cover common job, pipeline, and Unity Catalog resource types well, but Terraform may still be used for infrastructure outside the bundle schema

• A. Bundles support a growing but bounded set of resource types (jobs, pipelines, Unity Catalog objects, and more), while broader cloud infrastructure provisioning outside that schema is still commonly handled with the Terraform provider, making a mixed approach realistic during and after migration.
• B. Bundles support deploying to multiple workspaces by defining multiple targets, each pointing at a different workspace, so a multi-workspace organization is not forced to rely exclusively on Terraform for that reason.
• C. Bundle resources are defined in YAML, not HCL, and do not require an internal Terraform representation from the author; the bundle CLI has its own deployment engine independent of writing Terraform configuration.
• D. Bundles and Terraform can coexist, since teams commonly manage some resources with bundles and others with Terraform depending on scope; adopting bundles for jobs does not force an all-or-nothing migration of every resource type.

Correct answer: C — The Repair Run option is not available, because repair is only supported for jobs orchestrating two or more tasks, so the engineer must trigger the job again with Run Now instead.

• A. Incorrect. This answer reflects a common misconception. Databricks documentation explicitly states: 'Repair is supported only with jobs that orchestrate two or more tasks.' For a single-task job, the Repair Run option is not present; the only way to re-execute the failed task is to trigger the job again using 'Run Now'.
• B. Incorrect. The availability of Repair Run is determined solely by the number of tasks in the job, not by the cause of the failure. Single-task jobs do not show the Repair Run option at all, even for transient network timeouts. Multi-task jobs allow repair for any failed or skipped task.
• C. Correct. Despite user feedback suggesting otherwise, the official Databricks documentation confirms: 'Repair is supported only with jobs that orchestrate two or more tasks.' For a single‑task job, the Repair Run button does not appear. The recommended approach is to manually re‑run the job via 'Run Now' or to configure automatic task‑level retries for transient failures. This design limits repair functionality to directed acyclic graph (DAG) workflows where re‑executing only failed and downstream tasks saves time and cost.
• D. Incorrect. While retry policies enable automatic re‑attempts after a failure, they do not make the manual 'Repair Run' button appear for single‑task jobs. The Repair Run feature is intrinsically unavailable for any job that contains only one task, irrespective of retry settings. Automatic retries and manual repair are distinct recovery mechanisms.

Correct answer: A — Run `OPTIMIZE sales FULL` to force a complete reclustering of all existing data files under the newly defined clustering keys.

• A. `OPTIMIZE ... FULL` is the documented way to force liquid clustering to rewrite all existing data files to match newly defined clustering keys, rather than only incrementally clustering new writes.
• B. Standard incremental `OPTIMIZE` prioritizes newly written or poorly clustered files and is not guaranteed to fully recluster all historical data in a predictable timeframe.
• C. Recreating the table and reloading all historical data is far more disruptive and costly than using the built-in full reclustering command, and it discards table history unnecessarily.
• D. `VACUUM` removes stale files no longer referenced by the table's transaction log; it does not reorganize or recluster the current active data files.

Correct answer: A — Keep `order_number` as a degenerate dimension stored directly as a column on `fact_orders`, since it has no additional attributes that would justify a separate dimension table.

• A. An identifier that lives in the fact table with no accompanying attributes, used only for grouping or counting, is the textbook definition of a degenerate dimension and is correctly kept as a plain column on the fact table rather than split into its own dimension.
• B. Creating a dimension table that holds nothing but the identifier and a surrogate key adds an unnecessary join for no descriptive benefit, which is precisely the case degenerate dimension modeling is meant to avoid.
• C. Removing the identifier would eliminate the ability to group or count order lines by order, which is valuable analytically even though the column itself carries no separate descriptive attributes.
• D. Placing an order-level identifier inside the customer dimension conflates order-level and customer-level grain and would require repeating or awkwardly aggregating order numbers within a customer record.