DP-750 · Study cards
Every objective, one card each
77 cards, about 40 minutes of reading. Each card explains one objective from the official outline of October 19, 2026, names the trap, and ends with a question.
1 Set up and configure an Azure Databricks environment
15-20%
▾
Select and configure compute in a workspace
- Choose compute type Match compute to workload shape, isolation needs, and who should manage the infrastructure.
- Configure compute performance Size and scale compute around workload demand, then stop idle resources to control cost.
- Configure compute features Select runtime capabilities such as Photon, Spark runtime, and ML support to match the workload.
- Install compute libraries Install dependencies at the scope that matches who needs them and how the compute is managed.
- Configure compute permissions Grant the lowest compute permission that lets a principal perform the required operation.
Create and organize objects in Unity Catalog
- Unity Catalog naming Design catalog and schema names around governance boundaries, environments, teams, and sharing needs.
- Create a catalog Create the catalog type that matches standard storage, federation, or received shared data requirements.
- Create a schema Use schemas to group related objects inside a catalog and apply storage, ownership, and permissions at that level.
- Create volumes Use Unity Catalog volumes for governed access to non-tabular files without registering each file as a table.
- Tables and views Choose persisted tables, logical views, or materialized views based on storage and freshness requirements.
- Foreign catalogs Use a connection plus a foreign catalog to query supported external systems without first copying their data.
- DDL for tables Use DDL to create and alter managed or external tables while preserving the intended storage ownership model.
- Genie instructions Improve Genie discovery by curating metadata, business semantics, verified examples, and concise global instructions.
2 Secure and govern Unity Catalog objects
15-20%
▾
Secure Unity Catalog objects
- Grant UC privileges Grant privileges to users, groups, or service principals on the smallest securable scope that meets the need.
- Fine-grained access Combine grants with row filters, column masks, or governed policies to limit visible data inside a table.
- Azure Key Vault secrets Use a Key Vault-backed secret scope to reference secrets from Databricks without embedding credentials in code.
- Service principal auth Use service principals with OAuth for unattended Databricks automation instead of relying on a human identity.
- Managed identity access Use Azure managed identities for credential-free access from Unity Catalog to supported Azure resources such as storage.
Govern Unity Catalog objects
- Definitions and descriptions Document tables and columns with durable comments so people and tools can discover and interpret data correctly.
- ABAC with tags Use governed tags and centralized ABAC policies to scale consistent access rules across many Unity Catalog objects.
- Row filters and masks Attach UDF-based row filters and column masks when a table needs fine-grained query-time access logic.
- Data retention Balance recovery and time-travel needs against storage cleanup, then apply retention settings deliberately.
- Catalog lineage Use Catalog Explorer lineage and history to understand ownership, dependencies, and how data moves between assets.
- Audit logging Use audit data to investigate who performed actions, on which workspace or resource, and when.
- Secure data sharing Share only required governed assets with explicit recipients and revoke access centrally when it is no longer needed.
3 Prepare and process data
30-35%
▾
Design and implement data modeling in Unity Catalog
- Design ingestion logic Choose extraction and file handling from source behavior, freshness, change tracking, and downstream requirements.
- Choose ingestion tool Select managed connectors, notebooks, or external orchestration based on source support and control requirements.
- Batch or streaming Choose batch for bounded periodic work and streaming when data must be processed incrementally as it arrives.
- Choose data format Prefer Delta for governed lakehouse tables; use Parquet, CSV, JSON, or Iceberg when interoperability needs justify them.
- Partitioning strategy Partition only when scale and access patterns justify it; prefer liquid clustering for most modern Databricks tables.
- Choose SCD type Use SCD Type 1 for current state only and Type 2 when historical versions of changing dimension records must be preserved.
- Choose granularity Set row and column granularity from the business event being modeled and the detail consumers actually need.
- Temporal history tables Preserve prior business states with version rows and effective periods when point-in-time reconstruction is required.
- Clustering strategy Use liquid clustering for adaptable data layout; use Z-order only for older compatible patterns that are not liquid clustered.
- Managed or external Choose managed tables for the default governed lifecycle; use external tables when files must remain independently managed.
Ingest data into Unity Catalog
- Lakeflow Connect ingestion Use managed Lakeflow Connect connectors for supported batch or streaming sources and write governed destination streaming tables.
- Notebook ingestion Use notebooks when ingestion needs custom code, APIs, parsing, or control beyond managed connectors.
- SQL ingestion methods Use CTAS for query-created tables, REPLACE for atomic table replacement, and COPY INTO for incremental file loading.
- CDC ingestion Apply inserts, updates, and deletes from a change feed in event order instead of repeatedly reloading full snapshots.
- Structured Streaming ingestion Build fault-tolerant incremental ingestion with streaming DataFrames, checkpoints, triggers, and state controls.
- Event Hubs ingestion Consume Azure Event Hubs through its Kafka-compatible endpoint with Structured Streaming and keep credentials outside code.
- Pipelines with Auto Loader Use Auto Loader inside Lakeflow pipelines for scalable incremental file ingestion with schema handling and managed operations.
Cleanse, transform, and load data into Unity Catalog
- Profile data Profile datasets before transformation to expose nulls, cardinality, ranges, frequent values, and unusual distributions.
- Choose column types Use the narrowest type that preserves required values, semantics, precision, and downstream operations.
- Clean duplicates and nulls Resolve duplicates and missing values using business keys and column meaning instead of one blanket cleansing rule.
- Filter, group, aggregate Use filters to reduce rows, groupBy to define aggregation keys, and aggregate functions to summarize each group.
- Joins and set operations Use joins to combine columns by keys and set operations to combine or compare compatible row sets.
- Reshape data Denormalize to reduce joins for consumption, pivot rows into columns, and unpivot wide columns back into long form.
- Load table changes Use MERGE for matched updates and inserts, INSERT for explicit new rows, and append writes for additive DataFrame loads.
Implement and manage data quality constraints in Unity Catalog
- Validation checks Turn business rules into explicit checks for required values, uniqueness or cardinality, and valid ranges.
- Data type checks Validate and cast incoming values to the target schema, handling unsafe conversions as quality failures instead of silent assumptions.
- Schema enforcement and drift Enforce stable target contracts while configuring each ingestion, parser, streaming, and table layer for expected schema changes.
- Pipeline expectations Use Lakeflow expectations to declare data rules and choose whether violations are monitored, dropped, or fail the update.
4 Deploy and maintain data pipelines and workloads
30-35%
▾
Design and implement data pipelines
- Pipeline operation order Model dependencies from data requirements so independent work runs in parallel and dependent work starts only when prerequisites finish.
- Notebook or pipeline Use notebooks for custom imperative workflows and Lakeflow pipelines for declarative batch or streaming data transformations with managed operations.
- Design job task logic Compose jobs from focused tasks, explicit dependencies, runtime values, conditions, and retry behavior.
- Pipeline error handling Design for transient retries, explicit failure paths, cleanup, quality failures, and resumable processing.
- Notebook task pipeline Build notebook-based workflows as Lakeflow Jobs tasks with explicit dependencies and conditional precedence.
- Create Lakeflow pipeline Declare streaming tables, materialized views, flows, and dependencies in SQL or Python, then let Lakeflow manage execution.
Implement Lakeflow Jobs
- Create Lakeflow Job Create a job as an orchestrated collection of tasks, compute, parameters, dependencies, and operational settings.
- Configure job triggers Choose time, table-update, file-arrival, model-update, continuous, manual, or external triggers based on the event that should start work.
- Schedule a job Use a scheduled trigger for calendar-based execution and choose timezone and cadence to match the business requirement.
- Configure job alerts Send operational notifications for meaningful job events so failures and unhealthy durations reach the right responders.
- Automatic restarts Use task retries for transient failures and continuous execution when an always-on workload should restart after completion or failure.
Implement development lifecycle processes in Azure Databricks
- Git best practices Keep Databricks source in Git, work in isolated branches, commit focused changes, review them, and automate tests before promotion.
- Branches and conflicts Develop on branches, review changes through pull requests in the Git provider, then merge and resolve conflicting edits deliberately.
- Testing strategy Layer unit, integration, end-to-end, and user acceptance tests so defects are caught at the cheapest appropriate stage.
- Configure bundles Package source, Databricks resources, variables, artifacts, and environment targets into a version-controlled Declarative Automation Bundle.
- Deploy bundle with CLI Validate bundle configuration, authenticate to the intended target, then deploy from the bundle root with the Databricks CLI.
- Deploy with REST APIs Automate Databricks resource deployment through authenticated REST calls that create or update the jobs, pipelines, and objects represented by project configuration.
Monitor, troubleshoot, and optimize workloads in Azure Databricks
- Monitor compute use Right-size compute from CPU, memory, task, shuffle, and I/O metrics instead of assuming more nodes always improve performance.
- Repair Lakeflow Jobs Inspect failed task context, repair only unsuccessful dependencies when appropriate, and use restart, stop, or run based on desired lifecycle behavior.
- Troubleshoot Spark workloads Use task errors, driver and executor logs, Spark UI, and compute metrics to separate code failures from resource bottlenecks.
- Diagnose Spark bottlenecks Read the DAG, Spark UI, and query profile to locate skewed tasks, spill, excessive shuffle, and ineffective caching.
- Optimize Delta tables Use OPTIMIZE to improve file layout and VACUUM to remove expired unreferenced files, with predictive optimization preferred for managed tables.
- Stream logs to Log Analytics Configure Azure Monitor diagnostic settings on the Databricks workspace to send selected diagnostic log categories to a Log Analytics workspace.
- Azure Monitor alerts Create Azure Monitor alert rules with the correct resource scope, signal condition, evaluation behavior, and action group.