Free DP-750 Practice Test Questions and Answers (2026)

The question requires a modular and maintainable design for a data processing pipeline with distinct stages: ingestion, cleansing, and curation. Creating separate tasks for each stage aligns with best practices for building robust data engineering workflows. This approach adheres to the principle of separation of concerns, where each task has a single, well-defined responsibility. This modularity makes the overall job easier to develop, debug, and maintain. If the logic for one stage needs to be changed (as implied by "support the planned changes"), only the corresponding task needs to be updated, minimizing the risk of introducing errors into other parts of the pipeline.

A. A single notebook task creates a monolithic script, which is difficult to maintain, debug, and modify, directly contradicting the requirements for modularity and support for future changes.

B. Creating three tasks with identical logic is functionally incorrect for a multi-stage pipeline and does not perform the distinct steps of ingestion, cleansing, and curation.

C. A single SQL task, similar to a single notebook, is a monolithic approach that violates the requirement for each task to contain only the logic for its specific step.

1. Microsoft Learn, "Orchestrate data processing with Azure Databricks jobs": This official learning path for Databricks explains the structure of jobs. It states, "A job can consist of a single task, or it can be a large, complex workflow with many tasks and dependencies between them. In a multi-task job, Databricks manages the orchestration of the tasks, creating a directed acyclic graph (DAG) of the task dependencies." This directly supports creating separate, dependent tasks for a multi-stage workflow like the one described.

Source: Microsoft Learn, Module: "Orchestrate data processing with Azure Databricks jobs", Unit: "Create and run jobs in Azure Databricks".

2. Databricks Documentation, "What is Azure Databricks Jobs?": The official documentation emphasizes the composition of jobs from one or more tasks. It describes how to "create a job that is a complex workflow with multiple tasks with dependencies." This architectural pattern is precisely what is needed to separate ingestion, cleansing, and curation into distinct, manageable units of work.

Source: Databricks Documentation, Section: "Jobs", Article: "What is Azure Databricks Jobs?".

3. Databricks Documentation, "Create and run Databricks Jobs": This guide provides practical steps for building multi-task jobs, stating, "You can use task dependencies to specify the order of execution of tasks in your job." This feature is essential for implementing a sequential pipeline where the curation task runs only after the cleansing task succeeds, which in turn runs after ingestion.

Source: Databricks Documentation, Section: "Jobs", Article: "Create and run Databricks Jobs", Subsection: "Configure task dependencies".

The correct SQL statement to create a schema within a specific catalog and assign a custom managed location in Unity Catalog is CREATE SCHEMA ... MANAGED LOCATION. The CREATE SCHEMA command initiates the schema creation. The name catalog1.schema2 correctly specifies that schema2 should be created within catalog1. The MANAGED LOCATION clause is the specific Unity Catalog syntax used to override the default storage location inherited from the catalog or metastore, and it designates a new root storage path for all managed tables created within this schema.

B: The CREATE CATALOG statement is used to create a new catalog, not a schema within an existing catalog.

C: The LOCATION keyword is used when creating external tables to specify their data path, not for defining the managed storage location of a schema.

D: The WITH DBPROPERTIES (LOCATION=...) syntax is associated with the legacy Hive metastore, not the standard syntax for Unity Catalog.

1. Microsoft Databricks Documentation, "CREATE SCHEMA (Databricks SQL)": This official documentation provides the exact syntax for creating a schema in Unity Catalog. It explicitly shows the MANAGED LOCATION clause for this purpose.

Reference: Under the "Syntax" section, the structure is defined as: CREATE SCHEMA [ IF NOT EXISTS ] schemaname [ MANAGED LOCATION 'locationpath' ] ....

Reference: Under the "Parameters" section, it defines MANAGED LOCATION 'locationpath': "Specifies the path to a managed storage location for the schema which is different from the root storage location of the catalog or the metastore."

2. Microsoft Databricks Documentation, "Schemas": This document explains the concept of schemas in Unity Catalog and their properties.

Reference: In the section "Create a schema," the documentation provides an example: CREATE SCHEMA . MANAGED LOCATION 'abfss://@.dfs.core.windows.net/';. This example directly matches the structure of the correct answer.

Unity Catalog allows for the enforcement of data quality rules directly on Delta tables through constraints. A NOT NULL constraint on the transactionjd column ensures that any write operation attempting to insert a null value will fail. Similarly, a CHECK constraint, such as CHECK (amount > 0), enforces the rule that the amount must be positive. These constraints are validated whenever data is written or modified. If a record violates any of these constraints, the entire transaction is rejected, which directly fulfills the requirement to prevent invalid records from being written to the Sales table.

A. Use a select statement with where conditions to validate the data before querying.

This is a reactive approach that filters data at read time. It does not prevent invalid data from being written into the table itself.

B. Configure row-level security (RLS) where transactionjd is null or amount is less than or equal to 0.

Row-level security is an access control feature used to filter which rows users can see, not a data quality tool to reject invalid writes.

C. Create a view that filters out rows where transactionjd is null or amount is less than or equal to 0.

A view provides a filtered perspective of the data at query time but does not alter or reject the underlying data being written to the base table.

1. Official Databricks Documentation - Constraints on Azure Databricks: This document explicitly details the use of NOT NULL and CHECK constraints. It states, "When a constraint is violated, the transaction fails with an error." This confirms that constraints are enforced at write time.

Source: Databricks Documentation > Azure Databricks > Data governance > Unity Catalog > Constraints on Azure Databricks.

Section: "Add a check constraint" and "Add a not null constraint".

2. Official Databricks Documentation - ALTER TABLE: This page provides the SQL syntax for adding constraints to an existing Delta table managed by Unity Catalog.

Source: Databricks Documentation > Azure Databricks > Reference > SQL language reference > Data definition language > ALTER TABLE.

Section: "ADD CONSTRAINT".

3. Official Databricks Documentation - Row filters and column masks: This document explains that row filters are for implementing row-level security, which filters data at query time based on user identity, confirming it is not a data integrity feature.

Source: Databricks Documentation > Azure Databricks > Data governance > Unity Catalog > Row filters and column masks.

Section: "What are row filters and column masks?".

To implement the specified 30-day data retention policy, you must configure two key Delta Lake table properties. First, delta.logRetentionDuration controls how long the transaction log history is kept. Setting this to 30 days ensures that you can use Delta Time Travel to query any version of the table from the past 30 days, which is essential for auditing deleted data.

Second, delta.deletedFileRetentionDuration specifies the time that must pass before an unreferenced data file can be permanently deleted by the VACUUM command. Setting this to 30 days prevents the premature removal of data files required for Time Travel within the audit window. When VACUUM runs (which is automatic for Unity Catalog managed tables), it will permanently purge files and log entries older than this 30-day threshold, fulfilling all requirements with minimal administrative effort.

A. delta.timeUntilArchived: This property is for managing data archiving to a different storage tier, not for configuring retention and permanent deletion of historical versions.

C. delta.autoOptimize.autoCompact: This property is a performance optimization feature that compacts small files into larger ones. It does not control data retention or deletion timelines.

E. delta.enableDeletionVectors: Deletion vectors are a performance feature that optimizes how deletions are recorded. It does not govern the retention period for historical data or its eventual cleanup.

---

1. Databricks Documentation, "Remove unused data files with vacuum": This document explicitly states, "To control the time travel retention period for a table, configure the delta.logRetentionDuration and delta.deletedFileRetentionDuration table properties." It also confirms that for Unity Catalog managed tables, VACUUM is triggered automatically, satisfying the minimal effort requirement.

Source: Microsoft / Databricks Official Documentation. Section: "Configure data retention for time travel".

2. Databricks Documentation, "Delta Lake table properties reference": This reference details the purpose of each property.

delta.logRetentionDuration: "Controls how long the history for a table is kept... Databricks automatically cleans up log entries older than this retention interval."

delta.deletedFileRetentionDuration: "Controls how long ago a file must have been deleted before being a candidate for VACUUM."

Source: Microsoft / Databricks Official Documentation. Section: "Delta Lake table properties reference".

To meet the requirements for interactive development clusters in Azure Databricks:

• Autoscaling allows the cluster to automatically add or remove worker nodes based on the current workload demand. This ensures you have enough compute power during heavy processing and saves resources when the load is light.
• Auto termination is used to automatically shut down the cluster after a specified period of inactivity (idle time). This is a crucial cost-saving feature for interactive clusters, ensuring you do not pay for compute resources when developers step away or finish their tasks.

Official Microsoft Azure Documentation: "Compute configuration reference" -> "Autoscaling". This section confirms that enabling autoscaling allows Databricks to dynamically reallocate workers based on job characteristics and demand. (Available at: [https://learn.microsoft.com/en-us/azure/databricks/compute/configure#autoscaling](https://learn.microsoft.com/en-us/azure/databricks/compute/configure#autoscaling))

Official Microsoft Azure Documentation: "Compute configuration reference" -> "Auto termination". This section details how auto termination automatically terminates clusters after a set period of inactivity to save costs. (Available at: [https://learn.microsoft.com/en-us/azure/databricks/compute/configure#auto-termination](https://learn.microsoft.com/en-us/azure/databricks/compute/configure#auto-termination))

Data-entry mistakes by the equipment manufacturers require a Type 1 Slowly Changing Dimension (SCD). SCD Type 1 directly overwrites the existing data with new values without retaining any history, which perfectly aligns with the requirement stating that historical values are not needed for correcting simple data entry errors. Conversely, changes to IoT sensor ownership require a Type 2 SCD. SCD Type 2 preserves historical data by creating a new version of the record (often tracking start and end dates) for each change. This satisfies the business need for analysts to track the complete ownership history of the sensors over time.

Microsoft Learn: Change data capture and snapshots - Azure Databricks

Reference: "SCD Type 1: Current state only. SCD Type 1 overwrites old data with new data whenever changes occur, keeping only the latest version of each record. History is not retained."

URL: https://learn.microsoft.com/en-us/azure/databricks/data-engineering/what-is-cdc

Microsoft Learn: Change data capture (CDC) in Copy Job - Microsoft Fabric

Reference: "SCD Type 2 preserves historical data by creating new rows for changes while keeping previous versions of records... [It is used for] Historical analysis, audit trails, compliance."

URL: https://learn.microsoft.com/en-us/fabric/data-factory/cdc-copy-job

Auto Loader is specifically designed for incremental, exactly-once processing of file-based data from cloud storage (like ADLS Gen2) and features built-in schema inference and evolution. This makes it the ideal choice for both the file-based telemetry data (Event Hub captures) and the incremental, drift-prone maintenance logs. Lakeflow Connect provides native, managed connectors to directly and reliably ingest structured data from enterprise systems, including PostgreSQL, directly into the Lakehouse. For the external weather data, using A Databricks notebook allows engineers to write custom Python code (e.g., using the requests library) to retrieve data from REST APIs. This approach integrates seamlessly with Databricks Workflows, satisfying the requirement for centralized orchestration without relying on external tools like Azure Data Factory.

Microsoft Learn - Azure Databricks Documentation: "What is Auto Loader?" Details Auto Loader's capability to incrementally process files in ADLS Gen2 and its native support for schema evolution (cloudFiles.schemaEvolutionMode), which matches the requirement for handling telemetry and maintenance log schema drift.

Reference: https://learn.microsoft.com/en-us/azure/databricks/ingestion/auto-loader/

Databricks Official Documentation: "Lakeflow Connect." Outlines the managed connectors available for enterprise databases, explicitly listing PostgreSQL as a supported source for native ingestion into Unity Catalog.

Reference: https://docs.databricks.com/en/ingestion/lakeflow-connect/index.html

Microsoft Learn - Azure Databricks Patterns: "Read data from REST APIs." Highlights the standard architectural pattern of utilizing Python within Databricks notebooks to call REST APIs, write results to cloud storage, and orchestrate the process via Databricks Workflows.

Reference: https://learn.microsoft.com/en-us/azure/databricks/ingestion/orchestration/rest-api

Optimizing Query Performance: Liquid clustering is the recommended data layout optimization technique in Azure Databricks that replaces traditional Hive-style partitioning and Z-ordering. Since Table1 filters frequently on two columns (CustomerId and EventDate) and is expected to grow significantly, Liquid clustering provides an efficient, incremental, and flexible multi-column data layout that dynamically adapts over time without rewriting large blocks of existing data files.

Optimizing Updates and Deletions: Enabling deletion vectors drastically reduces write amplification and processing effort for frequent row-level updates and compliance deletes. Instead of executing a full copy-on-write operation (rewriting entire Parquet data files for a few modified rows), deletion vectors use a merge-on-read mechanism that records these modifications via lightweight metadata bitmaps.

Microsoft Learn / Azure Databricks Documentation:

Use liquid clustering for tables: Describes how liquid clustering replaces partitioning and ZORDER, automatically handles high-cardinality filtering columns, and accommodates growing tables with changing query patterns.

Deletion vectors in Databricks: Documents how deletion vectors accelerate DELETE and UPDATE operations by utilizing metadata-based soft deletes instead of full file rewrites, thereby minimizing modification effort.

Concurrency setting: Setting the concurrency limit to one ensures that only a single instance of the job executes at any given time. This directly satisfies the requirement to prevent overlapping runs and eliminate the risk of concurrent write conflicts or data corruption.

Execution behavior: When a job is scheduled to run hourly but a previous run takes longer than an hour, the next scheduled run triggers while the first is still active. Choosing Queue the new run ensures the new run waits in a queued state (for up to 48 hours) until the running instance completes. This aligns with Contoso's business requirement to "improve ingestion reliability" by preventing missed data intervals or skipped runs without overlapping the executions.

Microsoft / Databricks Official Vendor Documentation:

Configure and edit Lakeflow Jobs | Databricks on AWS, Section: "Configure maximum concurrent runs" & "Queueing is enabled by default for jobs..."

Get a single job run | Jobs REST API reference, Section: "life_cycle_state (QUEUED)" & "queue_reason"

Exam & Curriculum Blueprint:

Microsoft DP-750: Implementing Data Engineering Solutions Using Azure Databricks, Objective Domain: Orchestrate multi-step data pipelines and manage workspace concurrency and execution behavior thresholds.

Apply to Table1: Attribute-Based Access Control (ABAC) in Unity Catalog uses governed tags as centrally managed metadata attributes applied to securable objects like catalogs, schemas, tables, and columns to form the foundation of policy evaluation.

To control user access: To enforce security based on those attributes, you must define a Unity Catalog access policy (such as row filter or column mask policies). These policies automatically evaluate the tag values at query time to permit or restrict data access dynamically without relying on static privileges or manual view-based workarounds.

Microsoft Learn & Official Databricks Documentation: Attribute-based access control in Unity Catalog (Section: Core concepts for attribute-based access control).

Microsoft Learn & Official Databricks Documentation: Governed tags - Azure Databricks (Section: Why use governed tags?).

Microsoft Learn & Official Databricks Documentation: When to use ABAC vs table-level row filters and column masks (Section: ABAC policies vs. Dynamic views).