Free Microsoft Certified: Azure Databricks Data Engineer Associate (DP-750) Sample Questions

Correct answers: A, B, E — General instructions written in plain language that define ambiguous business terms and clarify how metrics should be calculated.; Example SQL queries, reviewed and accepted from suggested workspace queries, that Genie can reuse as trusted patterns for similar questions.; Reviewing suggested queries surfaced from popular workspace queries associated with the added tables and accepting the relevant ones.

• A. General instructions let the analyst spell out business terminology and calculation rules so Genie consistently interprets ambiguous natural-language phrases the same way.
• B. Accepted example SQL queries become trusted patterns that Genie can reuse for structurally similar questions, improving the accuracy of generated SQL.
• C. Requiring SQL literacy defeats the purpose of a natural-language interface and is not a documented step for improving a Genie space's answer quality.
• D. Broadly granting `MANAGE` to every business user is a permissions escalation unrelated to answer accuracy, and it risks unintended edits to shared instructions.
• E. Reviewing and accepting Genie's suggested queries, drawn from relevant existing workspace query history, is a documented step for building out trustworthy example queries.

Correct answer: A — FOREIGN

• A. `CREATE FOREIGN CATALOG ... USING CONNECTION` is the documented statement for mirroring an external database through Lakehouse Federation.
• B. A shared catalog is created with `USING SHARE` to consume an OpenSharing share, not to mirror a database through a connection.
• C. `MANAGED` is not a catalog type keyword in the `CREATE CATALOG` statement; managed storage is instead configured with the `MANAGED LOCATION` clause on a standard catalog.

Correct answer: A — Azure Databricks does not charge DBUs for idle pooled instances, though the underlying cloud instance provider billing still applies to them.

• A. Databricks doesn't charge DBUs while instances sit idle in a pool, but the cloud provider still bills for the underlying VM capacity.
• B. Idle pooled instances specifically avoid DBU charges; only once a cluster attaches and runs workloads do DBU charges for that usage begin.
• C. Pools don't distinguish idle instances by driver/worker role for DBU purposes; DBU charges are waived across all idle pooled instances alike.
• D. Cloud provider VM billing still applies to idle instances in a pool; only the Databricks DBU portion is waived while they're idle.

Correct answer: B — False

• A. This statement is incorrect, so True does not match how autoscaling limits apply to multi-node compute resources.
• B. This statement is false — a multi-node compute resource cannot be scaled down to zero workers; single-node compute exists specifically for that zero-worker case.

Correct answer: C — Standard

• A. Dedicated access mode restricts the compute resource to a single assigned user or group, which doesn't match a many-user concurrent scenario.
• B. No isolation shared access mode is a legacy configuration that lacks the per-user workload isolation Lakeguard provides under standard access mode.
• C. Standard access mode is the mode that supports many concurrent users attaching to one resource, with Lakeguard isolating each user's workload.

Correct answer: A — Prefix schema names consistently, such as `dev_orders` and `prod_orders`, so environment is visible in the schema name while both stay in the same catalog.

• A. A consistent schema-name prefix like `dev_` or `prod_` gives immediate visual separation of environments within one catalog, while leaving room to promote to catalog-level isolation later.
• B. Table comments describe data for discovery, but they don't create the structural naming boundary needed to tell environments apart at a glance or in access policies.
• C. Broadly granting `MANAGE` increases the blast radius of accidental changes and does nothing to establish a naming convention that distinguishes environments.
• D. Identical, undistinguished names across schemas invite accidental cross-environment queries and provide no naming signal at all.

Correct answer: A — Create an access connector for Azure Databricks, which deploys with a managed identity, and grant that identity a role on the storage account.

• A. An access connector for Azure Databricks deploys with a system-assigned managed identity by default, and granting that identity a role on the storage account lets Unity Catalog authenticate without any credential to store or rotate. This is the credential-free pattern the architect wants.
• B. A service principal's client secret is a credential that must be stored securely and rotated periodically, which is exactly the maintenance burden the architect wants to avoid. This approach still relies on a secret.
• C. A shared access signature token is itself a time-limited credential that must eventually be regenerated and re-embedded, so it does not eliminate credential rotation. It also is not the storage credential mechanism Unity Catalog uses for managed identities.
• D. A storage account access key is a long-lived shared secret that requires careful rotation and distribution to every consuming job. Storing it as a Databricks secret still means the workspace depends on a credential rather than a managed identity.

Correct answer: A — True

• A. This statement is correct: column masks can take other columns as inputs to vary the masking behavior based on multiple attributes of the same row, such as masking `salary` differently depending on a `department` column.
• B. This statement is factually accurate, so labeling it false would be incorrect. Column masks are documented as supporting multiple input columns, not just the masked column alone.

Correct answer: A — True

• A. This statement is correct: Azure Key Vault-backed secret scopes are documented as a read-only interface to the vault, so secret values themselves must be managed in Azure, not through Databricks secret-writing commands.
• B. This statement matches the documented behavior of Key Vault-backed scopes, so labeling it false would be incorrect. Only Databricks-backed scopes support creating and deleting secrets directly through the Databricks CLI.

Correct answer: A — Attach an ABAC policy at the catalog level that matches columns via a governed tag, so newly tagged tables are covered automatically.

• A. Attaching a policy at the catalog level lets Unity Catalog evaluate governed tag conditions dynamically, so any table or column later tagged as PII is protected without further action. This is the ABAC approach and it scales because policy authors and data stewards can work independently.
• B. Manually running the mask statement on each new table depends on every owner remembering to do it, which does not meet a hands-off, automatic requirement and does not scale as table volume grows.
• C. A nightly scan-and-alter job still leaves PII columns unmasked for up to a day after creation, and it duplicates work that a tag-driven policy already automates without a custom scheduler.
• D. A dynamic view can hide identifier columns, but it only protects consumers who are redirected to query the view; anyone who still queries the base table directly sees the unmasked PII, so it does not enforce the mask automatically at the table level.

Correct answer: A — Apply table-level row filters with `ALTER TABLE ... SET ROW FILTER` so each owner manages logic directly.

• A. Table-level row filters are bound to a single table with `ALTER TABLE ... SET ROW FILTER` and are managed directly by the table owner, which fits a small, stable set of tables where each one needs its own tailored logic.
• B. A schema-level ABAC policy is designed for consistent, tag-driven enforcement across many tables and takes decision-making away from individual owners, which conflicts with the requirement that each owner manage their own filter.
• C. Building a tag taxonomy is the ABAC path, which trades per-table owner control for centralized, automatic coverage — the opposite of what a small set of independently managed tables needs here.
• D. A dynamic view can encode custom logic, but it introduces a new object that consumers must be redirected to query, and it does not let the owner manage protection on the original table the way a bound row filter does.

Correct answer: A — Group events are captured only in the audit log system table, not through Azure diagnostic settings, so the admin must query `system.access.audit` for that category.

• A. Some categories, including group events, cluster policy events, and certain account-level activity, are recorded in the audit log system table but are not among the subset of categories exported through Azure diagnostic settings, so the system table must be queried directly.
• B. Azure Databricks does audit group creation and membership changes; the gap is about which delivery channel carries that category, not whether the platform tracks it at all.
• C. Diagnostic settings forward events continuously as they occur rather than applying a rolling 24-hour cutoff, so an age-based drop does not explain a category being absent entirely.
• D. The audit log system table is a Databricks Premium-plan feature, not a feature gated by a separate Azure AD Premium license, so licensing at that layer is not the cause of the missing events.

Correct answer: A — One row per expense line item, since that is the lowest level of detail the reports require.

• A. Because reports must show partial approvals within a single expense report, the table needs to preserve the line-item level of detail rather than summarizing it away.
• B. One row per report hides the individual line items and their separate approval states, which the requirement explicitly needs to see.
• C. Summarizing to employee-per-month discards both the report and line-item detail needed to show partial approvals accurately.
• D. Grouping by approval batch mixes line items from potentially different reports into one row and still loses the required line-item granularity.

Correct answer: A — Both formats can use liquid clustering, though Iceberg support requires a newer Databricks Runtime and remains in public preview.

• A. Liquid clustering is generally available for Delta Lake tables and available in public preview for managed Apache Iceberg tables on a newer Databricks Runtime, so both formats support it today under different maturity levels.
• B. Unity Catalog supports managed Apache Iceberg tables directly, so Iceberg data does not have to be registered only as an external table.
• C. Delta Lake tables do support ACID transactions through their transaction log, so this is not a real advantage Iceberg holds over Delta.
• D. Liquid clustering has already been extended to managed Iceberg tables in preview, so it is not an exclusively Delta capability.

Correct answer: A — `create_auto_cdc_from_snapshot_flow`, comparing each new export against the previous one to derive the changes.

• A. `create_auto_cdc_from_snapshot_flow` is designed for exactly this case: it compares successive in-order snapshots to derive inserts, updates, and deletes when no CDC feed exists, and can store the result as SCD Type 2.
• B. `create_auto_cdc_flow` processes an existing change feed; a nightly full-table export is a snapshot, not a change feed, so there is nothing for this API to consume without first deriving changes.
• C. `AUTO CDC INTO` expects a stream of already-identified change records with keys and a sequence column; raw full-table exports do not carry per-row change type or sequencing information on their own.
• D. Appending each night's full export to one table produces a stack of duplicate snapshots rather than a computed history of what changed between them.

Correct answer: A — True

• A. Databricks documentation states that `AUTO CDC` replaces `APPLY CHANGES` with identical syntax, and that `APPLY CHANGES` remains available even as `AUTO CDC` becomes the recommended API.
• B. This statement matches documented behavior, so treating it as false would misrepresent how Databricks handles the API transition and backward compatibility.

Correct answers: B, D, F — It automatically detects schema drift and can rescue data that would otherwise be dropped or lost.; It uses native cloud APIs, and file notification mode can avoid directory listing entirely to reduce cost.; It can scale to ingesting billions of files, including asynchronous backfills, without wasting compute resources.

• A. Auto Loader is a Structured Streaming source (`cloudFiles`) that writes into Delta tables like any other streaming source; it does not remove the need for a Delta target or add native JDBC sink support.
• B. Auto Loader can detect schema drift as new columns appear and rescue data that doesn't match the expected schema instead of silently dropping or losing it.
• C. Auto Loader explicitly does not guarantee the order in which files are discovered or processed, whether using directory listing or file notification mode.
• D. Auto Loader uses native cloud APIs to list files, and file notification mode can avoid directory listing altogether, which further reduces cloud API costs.
• E. Auto Loader still requires a checkpoint location to persist ingestion progress in a scalable key-value store; it does not eliminate this requirement.
• F. Auto Loader is built to scale to billions of files and supports asynchronous backfills so that large-scale historical loads don't waste ongoing compute resources.

Correct answer: A — It allows a write to fully replace the table's schema, including changing a column's data type or removing columns, rather than only adding new ones.

• A. Correct — overwriteSchema replaces the table's schema entirely with the schema of the incoming write, which is how column type changes, renames, or removals are applied by rewriting the table.
• B. Incorrect — additive column growth without touching existing columns describes mergeSchema behavior, not overwriteSchema.
• C. Incorrect — checkpoint recovery and resuming a stream is a Structured Streaming concept unrelated to a table write option that governs schema replacement.
• D. Incorrect — overwriteSchema controls how a write's schema is applied to the table, not how concurrent writers partition or coordinate incoming data.

Correct answer: A — The entire update is rolled back atomically, so none of the batch's rows, valid or invalid, are committed to the target table.

• A. Correct — the FAIL UPDATE action stops execution immediately on a violation and atomically rolls back the transaction, so nothing from that batch is committed.
• B. Incorrect — partially committing valid rows while excluding only the invalid one describes the drop action, not fail, which rolls back the whole update instead.
• C. Incorrect — a fail expectation never rewrites a record's values to force it to pass; it stops the update instead of silently correcting data.
• D. Incorrect — Lakeflow does not send email alerts as part of expectation handling; the failure is surfaced through the pipeline's error message and event log, not email.

Correct answer: A — Keep the null values as-is and add a derived boolean column flagging whether `phone_number` is null.

• A. Adding a derived flag preserves every customer row while giving marketing a clean way to filter on missing contact information, which matches the stated requirement exactly.
• B. `dropna` on `phone_number` would discard roughly 5% of legitimate customer records, violating the requirement to keep every customer row.
• C. Replacing nulls with empty strings hides the missing-data signal instead of flagging it, and downstream filters would need extra logic to distinguish empty strings from real values.
• D. Deleting the column removes information the marketing team explicitly wants to use for flagging incomplete records.

Correct answer: A — A `LEFT ANTI JOIN` from `customers` to `orders` on the customer key, returning only unmatched customers.

• A. `LEFT ANTI JOIN` is purpose-built to return only rows from the left table that have no match in the right table, giving exactly the unmatched customers with no order columns at all.
• B. A plain `LEFT OUTER JOIN` alone returns both matched and unmatched customer rows with null order columns for the unmatched ones; without a further filter it does not isolate only the customers with no orders.
• C. An `INNER JOIN` returns only customers that do have a matching order, which is the opposite of what is needed here.
• D. A `FULL OUTER JOIN` followed by discarding matched rows would still require extra filtering logic and would also include unmatched order rows that have no customer, which is out of scope for this request.

Correct answer: A — NOT MATCHED BY SOURCE

• A. `WHEN NOT MATCHED BY SOURCE` fires for target rows that have no matching source row, and only supports `UPDATE` or `DELETE` actions on those target rows.
• B. `WHEN NOT MATCHED BY TARGET` (or plain `WHEN NOT MATCHED`) fires for unmatched source rows and inserts them, which is the opposite side of the merge from what this clause describes.
• C. `MATCHED BY DEFAULT` is not a real `MERGE INTO` clause; the valid clause keywords are `MATCHED`, `NOT MATCHED [BY TARGET]`, and `NOT MATCHED BY SOURCE`.

Correct answer: A — Perform a full extract of the source table on each run and land it as Parquet files, then overwrite the target table from the latest extract.

• A. Since the source offers no reliable change-tracking mechanism, extracting the full table each run and overwriting the target with the latest snapshot avoids relying on data that doesn't exist, and Parquet's columnar format loads efficiently.
• B. The scenario states the source cannot provide a change log, so designing extraction around a change data feed will not work against this ERP system.
• C. Appending a full extract every run without overwriting duplicates every previous day's rows in the target table instead of reflecting only the current day's snapshot.
• D. The scenario gives no indication that a trustworthy `modified_date` column exists on the source, so an incremental extract built around it risks missing or double-counting rows.

Correct answer: A — The write is rejected because Delta's schema enforcement checks that incoming types match the column's declared type, and "N/A" cannot be cast to DOUBLE.

• A. Correct — Delta's schema enforcement validates that every incoming value matches the target column's declared type before it commits a write, so a non-numeric string cannot be written into a DOUBLE column and the transaction fails with a schema mismatch error.
• B. Incorrect — Delta does not silently widen a column's type to accept mixed values; enforcement blocks the type mismatch rather than accommodating it.
• C. Incorrect — Delta does not convert unparseable strings to NULL on write; the transaction fails so the engineer can address the malformed value.
• D. Incorrect — the _rescued_data column is an Auto Loader ingestion feature that captures unparsed data during schema inference from files, not a behavior of a direct write against an already-typed Delta table.

Correct answer: A — That the task's write logic is idempotent, for instance using `MERGE` or overwrite, since a repair re-runs the task from the very beginning.

• A. Databricks documentation warns that a repair re-runs each unsuccessful task from the beginning, and because Lakeflow Jobs doesn't make tasks idempotent, an append-style write that already wrote partial output before failing can duplicate that data on repair.
• B. Repair runs are not blocked by the maximum concurrent runs setting queuing behind the original run; that setting limits how many separate runs of the same job can be active, which is unrelated to the safety of re-running a single failed task.
• C. Repair runs are supported on job clusters; in fact a repair on a shared job cluster creates a new versioned cluster rather than requiring a switch to all-purpose compute.
• D. The retry count and the Repair run feature are independent controls; a nonzero retry count governs automatic re-attempts during the original run and does not disable the ability to manually repair the run afterward.

Correct answer: A — True

• A. This statement is correct: a pipeline task is one of the supported task types in Lakeflow Jobs, letting a job orchestrate a materialized view or streaming table pipeline as a dependency alongside notebook tasks and other task types in the same DAG.
• B. This statement is not the false case here; pipeline tasks are a documented, supported way to include a Lakeflow Spark Declarative Pipeline as a node in a job's task graph.

Correct answer: A — `databricks bundle validate`, which checks the configuration files and prints a summary of the bundle's identity without deploying resources.

• A. Correct. `bundle validate` checks that configuration files are syntactically correct and outputs the resolved bundle identity, and it never writes anything to the remote workspace.
• B. `bundle plan` does build the bundle and preview planned actions, but it requires the direct deployment engine and reports pending changes against remote state rather than acting purely as a syntax check.
• C. `bundle summary` depends on resources that have already been deployed; it reads back existing state and deep links, so it cannot validate configuration for a change that has not been deployed yet.
• D. The `bundle deploy` command has no `--dry-run` flag; deploy either performs the deployment (subject to `--force`/`--auto-approve`) or fails outright, so this option does not exist.

Correct answer: A — It exercises a single function or transformation in isolation, using controlled inputs and asserting a specific expected output.

• A. Correct. A unit test targets one function or transformation in isolation with controlled inputs, which keeps it fast and lets failures be attributed to a single piece of logic.
• B. Running the same checks across every target describes a cross-environment validation approach, not the defining characteristic of a unit test, which is isolation of one component.
• C. Checking how two or more tasks interact and hand off data describes integration testing, which sits above the unit level rather than testing a single function alone.
• D. Running against production-scale data for stakeholder sign-off describes user acceptance testing, not a unit test, which stays small and isolated by design.

Correct answer: A — `--auto-approve`

• A. Correct. This flag skips interactive approvals that might otherwise be required for deployment, which is exactly what an unattended pipeline needs.
• B. This flag causes the deployment to fail if there are active runs, a safety check unrelated to suppressing interactive approval prompts.
• C. This flag forces acquisition of the deployment lock left over from a crashed prior deployment; it does not suppress interactive approval prompts.

Correct answers: A, B, C — If the original run used a shared job cluster, the repair run provisions a new job cluster with a version suffix rather than reusing the exact original cluster instance.; Repair is only available for jobs that orchestrate two or more tasks; a failed single-task job must instead be triggered again with Run now.; Because Lakeflow Jobs does not make tasks idempotent by default, re-running a task that partially wrote output before failing can duplicate that data.

• A. A new job cluster with a version suffix is correct because when tasks share a job cluster, the repair run provisions a fresh cluster instance rather than reattaching to the original one, so the initial and repaired runs stay distinguishable.
• B. Repair being limited to jobs with two or more tasks is correct because a single-task job has no dependent tasks to selectively rerun, so recovering it simply means triggering it again with Run now.
• C. The idempotency caution is correct because Lakeflow Jobs reruns each unsuccessful task from the beginning without guaranteeing exactly-once writes, so a task that already wrote partial output before failing can produce duplicate data on repair.
• D. Repair run does not force parameters back to the first attempt's values; it re-runs unsuccessful tasks with the current job and task settings, and any parameters entered in the repair dialog override those current values.
• E. Repair run does not delete run history; the matrix view keeps the original failed attempt visible alongside the new repair column so both are still available to review.

Correct answer: A — 50

• A. 50 is correct because the Spark UI guide specifically calls out that a Max duration at least 50% higher than the 75th percentile is the threshold at which skew becomes a reasonable suspicion.
• B. 5 is incorrect because a gap that small is well within normal task-to-task variance and does not indicate the kind of imbalance the guide associates with skew.
• C. 500 is incorrect because that far overstates the guide's threshold; requiring a five-times gap would miss skew that is already clearly affecting the stage's runtime at more moderate gaps.

Correct answers: A, B, C — OPTIMIZE reduces the number of small files a query must open, which lowers per-file read overhead and speeds up subsequent queries.; VACUUM reclaims storage cost by physically deleting old, unreferenced data files once they fall outside the configured retention window.; If predictive optimization is enabled for the table, Azure Databricks can trigger this same compaction and cleanup automatically without the weekly job.

• A. Reduced per-file read overhead from OPTIMIZE is correct because compacting small files into larger ones means queries open fewer files, directly speeding up subsequent reads.
• B. Reclaimed storage cost from VACUUM is correct because it physically deletes data files that are no longer referenced by the transaction log once they age past the retention window, freeing up storage that was otherwise billed.
• C. Predictive optimization automating this maintenance is correct because when it is enabled for a table, Azure Databricks can trigger OPTIMIZE and VACUUM operations itself, reducing the need to schedule this weekly job manually.
• D. Constant-time future queries is incorrect because OPTIMIZE compacts the files that exist at the time it runs; newly appended data after that point can reintroduce small files, so query time is not permanently fixed.
• E. Immediately deleting every version older than the current one is incorrect because VACUUM respects the configured retention window, defaulting to seven days, rather than deleting all history the instant it runs.

Correct answer: A — The task is marked Timed Out at ten minutes, and each retry attempt gets its own ten-minute timeout

• A. When both a timeout and retries are configured, the timeout is documented to apply to each retry individually, so the first attempt stops at ten minutes and every later retry gets its own fresh ten-minute window.
• B. Configuring retries does not disable or override the timeout; the two settings are documented to work together rather than one canceling out the other.
• C. Letting the task run indefinitely past its configured timeout would defeat the purpose of setting one, and the timeout is documented to apply to the first attempt just as it does to retries.
• D. A timeout that ends an attempt counts as a failure like any other, and a configured retry policy still applies retries after a timeout-caused failure rather than skipping them outright.

Correct answers: A, B, C — Clicking Pause stops the trigger from starting new runs, while any run already active keeps running to completion; Clicking Resume causes the trigger to continue on the same schedule or event configuration it had before pausing; If a run is still active when a continuous trigger is resumed, the scheduler waits for it to finish first

• A. Pausing an active trigger is documented to stop it from starting new runs going forward, while any run that is already active is allowed to continue running to completion.
• B. Resuming a trigger is documented to continue the previously configured schedule or event behavior rather than resetting to some different default configuration.
• C. If a run is still active when a continuous trigger is resumed, the job scheduler is documented to wait until that run completes before triggering a new run.
• D. Deleting a trigger removes it from starting future runs; it does not retroactively cancel or erase runs that already occurred in the past under that trigger.
• E. A trigger's configuration can be edited using Edit trigger regardless of whether the trigger is currently active or paused, so pausing first is not a prerequisite for editing it.
• F. A job has a single trigger configuration at any given time, chosen from types such as Scheduled, Table update, File arrival, Model update, or Continuous, not several active simultaneously.

Correct answers: A, B, C — A Failure notification so they are alerted whenever a run ends in an unsuccessful state; A Duration warning tied to a configured expected completion time before the six-AM deadline; Mute notifications for skipped runs so intentional maintenance-freeze skips stay quiet

• A. A failure notification is the direct mechanism for being alerted the moment a run ends unsuccessfully, matching the team's first stated requirement.
• B. Configuring a duration warning against an expected completion time is how a team gets alerted when a run risks missing a hard deadline like six AM, without waiting for outright failure.
• C. Muting notifications for skipped runs specifically suppresses alerts for runs skipped due to reasons like a maintenance freeze, directly addressing the team's concern about alert flooding.
• D. A streaming backlog notification concerns backlog metrics on streaming sources; this nightly batch ETL scenario has no streaming backlog dimension described, so it does not address the stated requirements.
• E. A model update trigger starts new runs based on registered model changes and has nothing to do with alerting on failures, durations, or skipped runs for an existing scheduled job.
• F. Muting until the last retry only suppresses notifications for intermediate retry attempts; it does not touch run history visibility and does not address the team's stated failure, duration, or skip-noise goals.