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

Correct answer: A — Serverless SQL Warehouse

• A. Serverless SQL warehouses are specifically designed for SQL workloads and BI tools like Power BI. They provide near-instant startup times and handle all infrastructure management, satisfying the requirement to avoid cluster configurations.
• B. Job compute is used for automated tasks and batch processing. It involves a cold start time for the cluster and is not intended for interactive BI analysis.
• C. All-purpose compute is designed for data engineering and data science notebooks. It requires manual configuration and typical start-up times are significantly longer than serverless options.
• D. Shared compute refers to an access mode on a cluster. It still requires manual setup and management of the underlying compute resources and does not offer the instant-start benefits of serverless.

Correct answer: A — Autoscaling

• A. Correct. Autoscaling allows Azure Databricks to dynamically adjust the number of worker nodes in a cluster based on the workload. By setting a minimum and maximum range, Databricks can scale down and decommission worker nodes when they are underutilized, directly optimizing compute costs while maintaining performance during peak periods.
• B. Incorrect. Auto-termination is a cost-saving feature that shuts down the entire cluster after a specified period of inactivity. While it helps manage overall costs, it does not adjust the number of worker nodes within a running cluster based on resource demand.
• C. Incorrect. Instance Pools are designed to reduce cluster start and scale-out times by maintaining a pre-allocated set of idle virtual machine instances. While they facilitate faster autoscaling, the logic for reducing the number of nodes based on workload is a function of the Autoscaling feature itself, not the Pool.

Correct answer: A — Spot instances

• A. Spot instances utilize unused Azure compute capacity at a significant discount compared to standard pricing. Because they can be evicted when Azure needs the capacity back, they are best suited for fault-tolerant workloads like batch processing jobs that can handle interruptions and retries without failing the entire process.
• B. On-demand instances provide guaranteed compute availability and steady performance at a fixed price. While they are the standard choice for most workloads, they are more expensive than spot instances and are not the most cost-effective option for jobs that are specifically designed to be fault-tolerant.
• C. Dedicated hosts provide physical server isolation and are typically used for specific compliance, security, or licensing requirements. They are generally the most expensive option and are unnecessary for standard batch processing cost-reduction strategies.

Correct answer: B — catalog.schema.table

• A. Incorrect. The metastore is the top-level container for metadata in Unity Catalog, but it is not part of the 3-level identifier used to reference a table in queries. The hierarchy starts at the catalog level.
• B. Correct. Unity Catalog uses a standard 3-level namespace format: catalog.schema.table. This format allows for clear object identification and governance across different catalogs and environments.
• C. Incorrect. Workspace is the environment where users work, but it is not a level in the Unity Catalog object hierarchy. Unity Catalog is designed to allow objects to be shared across multiple workspaces.
• D. Incorrect. While 'database' is a term commonly associated with Hive metastore-style organization, Unity Catalog specifically uses the term 'schema' as the second level in its 3-level namespace.

Correct answer: A — table

• A. Correct. In Azure Databricks Unity Catalog, the three-level namespace hierarchy for referencing tables is catalog.schema.table. This structure allows for clear data governance and organization, where the catalog is the container for schemas, and the schema is the container for tables.
• B. Incorrect. In the context of Unity Catalog, 'schema' and 'database' are synonymous and represent the second level of the namespace. The third level, which follows the schema, is the table name itself.
• C. Incorrect. While Unity Catalog volumes do follow a three-level namespace (catalog.schema.volume), they are specifically used for managing non-tabular data files. The scenario specifically asks for the format used to reference a table.

Correct answer: C — An external volume

• A. Incorrect. A managed table stores its data in the Unity Catalog metastore and is fully managed by Databricks. Creating a managed table would require ingesting the raw files and converting them into a Delta table, which contradicts the requirement to govern access without converting into Delta tables.
• B. Incorrect. An external table registers tabular data stored in an external location, but it still requires defining a schema and typically involves some transformation or schema inference. The team wants to govern access to the raw files directly, without table abstractions.
• C. Correct. An external volume in Unity Catalog provides governance over non-tabular data files stored in external locations like ADLS Gen2. It allows access control directly on the raw files without requiring conversion into Delta tables, making it ideal for governing access to raw JSON and CSV files.
• D. Incorrect. A materialized view is a precomputed result set from a query that is stored for performance. It is not used for governing access to raw files and would not apply to files that haven't been loaded into a table.

Correct answer: A — spark.executorEnv.API_KEY {{secrets/app-secrets/api-key}}

• A. Correct. In Databricks cluster Spark configuration, environment variables are set for executors using the `spark.executorEnv.[VARIABLE_NAME]` prefix. The value is securely referenced using the Databricks secret interpolation syntax `{{secrets/<scope-name>/<secret-key>}}`.
• B. Incorrect. `dbutils.secrets.get()` is a programmatic method used within notebooks or job code (Python/Scala) to retrieve secret values at runtime. It cannot be parsed when placed inside the static Spark configuration text area of a cluster.
• C. Incorrect. This syntax is intended for the 'Environment Variables' field in the Databricks Cluster UI, not the 'Spark Config' field. Items in the Spark configuration field must be valid Spark properties (beginning with `spark.`).
• D. Incorrect. This option uses Kubernetes-specific configuration keys and a non-standard secret reference format. Azure Databricks uses the double-curly brace syntax for secret interpolation in cluster configurations.

Correct answers: A, B — The Databricks workspace does not have the necessary Key Vault access policy or RBAC role assignment to read secrets from the Key Vault.; The developer does not have the READ permission on the secret scope's ACL in Databricks.

• A. Correct. For an Azure Key Vault-backed secret scope, the Databricks service principal must be authorized to access the Key Vault. This requires an Access Policy with 'Get' and 'List' permissions or an Azure RBAC role assignment (such as Key Vault Secrets User). If the workspace identity lacks these permissions, the Key Vault will return a 403 Forbidden error to Databricks.
• B. Correct. Secret scopes in Databricks enforce their own Access Control Lists (ACLs). Even if the service-level connection to the Key Vault is valid, the specific user or group must be granted the READ permission on the Databricks secret scope itself. If this permission is missing, Databricks denies the request with a 403 error.
• C. Incorrect. The method used to create the secret scope (CLI, API, or UI) does not impact the authorization logic at runtime. Both the CLI and UI result in the same functional secret scope configuration.
• D. Incorrect. Azure Key Vault access is not restricted by region; a Databricks workspace in one region can access a Key Vault in another, provided networking and permissions are correctly configured. A region mismatch is not a cause for a 403 Forbidden error.
• E. Incorrect. Secret values are stored as strings. Special characters within the secret content do not affect the authorization handshake between Databricks and Key Vault, and would not trigger a 403 error.

Correct answers: A, B, C — Access Connector for Azure Databricks; User-Assigned Managed Identity; Storage Blob Data Contributor role assignment on the target storage account

• A. Correct. The Access Connector for Azure Databricks is a required Azure resource that acts as a bridge, hosting the managed identity that Unity Catalog uses to securely access storage accounts.
• B. Correct. A User-Assigned Managed Identity is the identity assigned to the Access Connector. It provides the security principal that Unity Catalog assumes to authenticate against Azure storage.
• C. Correct. The Managed Identity must be granted the Storage Blob Data Contributor role (or similar) on the target storage account or container. Without this RBAC assignment, the identity lacks the necessary permissions to read or write data.
• D. Incorrect. Azure Key Vault secret scopes are used for managing secrets like tokens or passwords. Managed Identity-based credentials in Unity Catalog do not require secret scopes, as they rely on Azure's native identity platform.
• E. Incorrect. Databricks Cluster Policies govern the configuration and sizing of compute resources. They are not involved in the infrastructure setup of Unity Catalog storage credentials.
• F. Incorrect. Azure Data Factory linked services are used to define connection strings within ADF pipelines and are unrelated to the security and governance of Unity Catalog objects.

Correct answer: B — Apply a column mask to the email column

• A. Incorrect. A row filter is used to restrict access to entire rows based on specific conditions (e.g., geographical region). It does not provide the ability to transform or mask specific column values within a row.
• B. Correct. A column mask in Unity Catalog allows for dynamic data masking. You can define a function that checks the user's group membership (e.g., using IS_ACCOUNT_GROUP_MEMBER) to return either the masked value ('***') or the actual email address based on their role.
• C. Incorrect. Unity Catalog does not utilize 'data redaction policies' at the catalog level for this type of granular masking. Column-level security is specifically handled through column masks.
• D. Incorrect. Encrypting a column using customer-managed keys (CMK) secures data at rest and protects against unauthorized access at the storage level, but it does not facilitate the dynamic, role-based display masking required for this scenario.

Correct answer: B — The RDD API is not supported for automated lineage capture in Unity Catalog

• A. Incorrect. Unity Catalog lineage is not limited to SQL queries; it also captures lineage from supported Spark and Python operations using high-level APIs like DataFrames and Datasets.
• B. Correct. Unity Catalog captures lineage by intercepting the logical plans of high-level Spark APIs (SQL, DataFrames, and Datasets). Because the RDD API operates at a lower level and bypasses these structured execution plans, automated lineage capture is not supported for RDD-based transformations.
• C. Incorrect. While a lack of permissions might prevent a user from viewing existing lineage, the reason the lineage is completely missing from the system for this specific operation is the use of an unsupported API. Furthermore, READ_LINEAGE is not a standard Unity Catalog privilege; VIEW MATERIALIZED VIEW or similar permissions might apply to viewing, but not capturing.
• D. Incorrect. Lineage information in Unity Catalog is captured in near real-time and typically appears in Catalog Explorer shortly after the job completion, not after a 24-hour delay.

Correct answers: A, B, C — Create a Share object; Add the table to the Share; Create a Recipient object

• A. Correct. A Share object is a Unity Catalog object that serves as a container for the tables, views, or other assets you intend to share with external recipients.
• B. Correct. After creating a Share, you must explicitly add the target Delta tables to that Share to make the data available for distribution.
• C. Correct. A Recipient object represents the external entity receiving the data. In open Delta Sharing (where the recipient does not use Databricks), creating the Recipient object is the step that generates the activation link used by the vendor to download the sharing credentials.
• D. Incorrect. While a Provider object exists in the Delta Sharing architecture, it is used by the data recipient to represent the entity sharing the data. The data sharer (provider side) manages Shares and Recipients.
• E. Incorrect. Cluster policies are used to manage and enforce configurations for compute resources within a Databricks workspace and are not part of the data sharing workflow.
• F. Incorrect. External Locations define access to cloud storage in Unity Catalog. While the data being shared might reside in an external location, creating one is not a specific step in the Delta Sharing setup process for a table.

Correct answer: A — Partition the table by transaction_date.

• A. Correct. Partitioning by transaction_date is the most effective approach because the table is primarily filtered by this column. With a 50 TB dataset, partition pruning allows the engine to skip large amounts of irrelevant data, significantly improving performance. Since data volume is evenly distributed across dates, this strategy minimizes the risk of partition skew.
• B. Incorrect. Partitioning by transaction_id is inappropriate due to its high cardinality. Creating partitions based on a unique identifier results in a massive number of tiny partitions, leading to significant metadata overhead and the 'small file problem,' which degrades performance.
• C. Incorrect. Partitioning by customer_id is sub-optimal because it does not align with the primary query filter (transaction_date). While partitioning by a frequently filtered column is beneficial, choosing the wrong column prevents the engine from leveraging partition pruning for the most common query patterns.
• D. Incorrect. Z-ordering by customer_id does not address the primary access pattern of transaction_date. While Z-ordering is a powerful data skipping technique, for a 50 TB table frequently queried by date, physical partitioning is the standard practice to reduce the data scan size effectively.

Correct answer: A — Create a materialized view that aggregates the data to the store-month grain.

• A. Correct. A materialized view can pre-aggregate receipt-line data into the store-month grain, which matches the dashboard’s query pattern. This physically stores the results and reduces runtime computation during dashboard refreshes, making it the ideal solution for frequently accessed summary data.
• B. Incorrect. Changing the base table to a store-month grain would result in the permanent loss of granular transaction data. In a standard data architecture, you should preserve detail in the base (Silver) layer and use specialized objects like Materialized Views for high-level (Gold) reporting.
• C. Incorrect. Partitioning by receipt ID involves a high-cardinality column and does not align with the dashboard's aggregation pattern (store and month). This would likely lead to the 'small file problem' and inefficient partition pruning, potentially worsening performance.
• D. Incorrect. While Liquid Clustering improves data skipping for filters and point lookups, it does not pre-calculate the aggregates required by the dashboard. Since the performance bottleneck is caused by recalculating monthly totals from millions of rows, pre-computation via a materialized view is the superior optimization.

Correct answer: A — An external (unmanaged) table

• A. Correct. An external (unmanaged) table in Unity Catalog allows you to create a metadata layer over existing data files without moving them. This references data stored in its existing location in ADLS Gen2, meaning Unity Catalog can govern the table metadata and permissions while preserving access for existing non-Databricks applications that read the Parquet files directly from the storage path.
• B. Incorrect. A managed table in Unity Catalog stores data in a Databricks-managed storage location. Creating a managed table would require moving the data, which would break existing applications that currently read files from specific paths in the original ADLS Gen2 container.
• C. Incorrect. Delta Live Tables (DLT) is a framework for building and managing data processing pipelines. It is not designed for the purpose of simply governing existing Parquet files in place without data movement or transformation.
• D. Incorrect. A materialized view is a physical storage of a query's result set, typically used for performance optimization. It is not used to govern existing source data files in their current location.

Correct answers: A, C — df.summary(); df.summary("25%", "50%", "75%")

• A. Correct. In PySpark, the `df.summary()` method provides a comprehensive set of statistics by default, including count, mean, stddev, min, max, and the approximate 25%, 50%, and 75% percentiles.
• B. Incorrect. The `df.describe()` method returns basic descriptive statistics including count, mean, stddev, min, and max, but it does not include percentiles.
• C. Correct. The `df.summary()` method accepts specific statistics as string arguments. Passing "25%", "50%", and "75%" will return a DataFrame containing exactly those requested percentile rows.
• D. Incorrect. `df.stat.crosstab()` is used for computing pair-wise frequency tables (contingency tables) for categorical columns, not for calculating summary statistics or percentiles of numeric data.
• E. Incorrect. `df.explain()` is used to display the logical and physical query execution plans of the DataFrame, which is useful for optimization but does not perform data analysis or calculate statistics.

Correct answer: B — MapType

• A. Incorrect. ArrayType is used for ordered collections of elements of the same type. It does not natively support key-value mapping required for sensor readings where each value needs an associated identifier or key for retrieval.
• B. Correct. MapType is specifically designed for dynamic key-value structures. It is the ideal choice for IoT telemetry data because it allows the keys (sensor names) to vary between records while storing the data in a single column, providing the necessary flexibility without requiring a schema change for every new sensor type.
• C. Incorrect. StructType is used to represent a structured type with a fixed, predefined schema. While it can store multiple fields, it is rigid and not suitable for scenarios where the keys are dynamic or unknown at the time the schema is defined.

Correct answer: B — Left Anti Join

• A. Incorrect. A Left Outer Join returns all rows from the left DataFrame and matching rows from the right. While you could filter the result where the right-side keys are null, it is not the join type itself that performs the exclusion; a Left Anti Join is the direct solution.
• B. Correct. A Left Anti Join returns only the rows from the left DataFrame (`df_users`) that have no matching keys in the right DataFrame (`df_logins`). This is the most efficient and direct way to identify users who are in the registry but did not appear in the login logs today.
• C. Incorrect. A Left Semi Join returns rows from the left DataFrame where a match exists in the right DataFrame. This would effectively find only those users who DID log in today.
• D. Incorrect. A Full Outer Join returns all rows from both DataFrames, matching them where possible. It includes users who logged in and users who didn't, requiring additional complex filtering to isolate the target group.

Correct answer: B — .option("overwriteSchema", "true")

• A. The mergeSchema option is used for schema evolution, which allows for adding new columns to an existing table. It does not support dropping columns or changing existing data types, making it unsuitable for a full schema replacement.
• B. The overwriteSchema option, when used in conjunction with .mode("overwrite"), allows you to completely replace the existing table schema with the schema of the new DataFrame. This is the correct choice when columns need to be dropped or data types need to be changed.
• C. There is no replaceSchema option in Delta Lake. This is an invalid configuration and will not achieve the desired outcome.
• D. The append mode is used to add new data to an existing table without altering its schema. It does not replace the existing data or schema and would typically fail if the DataFrame schema does not match the table schema.

Correct answer: B — The entire transaction fails and is aborted; no rows are inserted.

• A. Incorrect. Unity Catalog enforces CHECK constraints at the transaction level during write time. It does not support 'partial success' where valid rows are kept and invalid ones are dropped within a single batch insert or update operation.
• B. Correct. When a row violates a CHECK constraint in Unity Catalog, the entire write operation fails and the transaction is aborted. This ensures strict data integrity by preventing any invalid data from entering the table; as a result, none of the 10,000 rows are committed.
• C. Incorrect. Constraint enforcement does not automatically repair, coerce, or modify invalid values (such as setting them to NULL). If the data does not satisfy the boolean expression defined in the CHECK constraint, the entire write is rejected.
• D. Incorrect. While the violation is surfaced as an error and logged, the data is not inserted. A CHECK constraint is a hard gate that prevents the transaction from completing rather than a passive monitoring tool that allows invalid rows through.

Correct answer: B — False

• A. The statement is false because the @expect_or_drop decorator is designed to handle data quality issues by filtering out non-compliant records while allowing the pipeline to continue processing and writing valid data.
• B. The statement is false because @expect_or_drop removes only the specific rows that violate the constraint from the target dataset; it is @expect_or_fail that would cause the entire pipeline update to stop and fail upon encountering an invalid record.

Correct answers: A, B, C — Append; Complete; Update

• A. Append mode is the default and most common output mode for Delta sinks in Structured Streaming. It adds new records to the target table without modifying existing rows.
• B. Complete mode is supported by Delta sinks for queries that include aggregations. In this mode, the entire result table is recalculated and overwritten in the target table with each trigger.
• C. Update mode is supported for stateful streaming queries where only the rows that have changed since the last trigger are emitted. This is compatible with Delta Lake sinks when the query semantics allow updates.
• D. Overwrite is a save mode used in batch processing (DataFrameWriter). Spark Structured Streaming (DataStreamWriter) uses specific output modes (Append, Complete, Update) rather than batch SaveModes.
• E. Merge is a Delta Lake-specific DML operation used for upserting data. While it can be used within a foreachBatch sink, it is not an official Spark Structured Streaming output mode.
• F. Upsert is a data manipulation pattern, not a native Spark Structured Streaming output mode. This logic is typically implemented using a Merge operation, not as a standalone streaming mode.

Correct answer: A — True

• A. The statement is true because when file notification mode is enabled, Auto Loader can automatically provision and configure the required Azure infrastructure (Event Grid subscription and Storage Queue) if the service principal or managed identity has the necessary RBAC permissions, such as Contributor or specific resource management roles.
• B. The statement is false because Auto Loader is designed to handle the orchestration and lifecycle of notification services automatically, provided the identity has the correct permissions, rather than requiring the user to manually create these resources in the Azure portal beforehand.

Correct answer: A — failOnNewColumns

• A. Correct. Setting `cloudFiles.schemaEvolutionMode` to `failOnNewColumns` causes Auto Loader to stop processing immediately when it detects a column that was not previously part of the schema. This behavior is ideal when strict schema control and manual review are required before allowing data with new fields to be ingested.
• B. Incorrect. The `rescue` mode is used to capture unexpected data in a `_rescued_data` column without failing the pipeline. This allows ingestion to continue smoothly, which contradicts the requirement for the pipeline to fail for manual review.
• C. Incorrect. The `none` mode disables schema evolution, meaning that any new columns are ignored and not added to the schema. It does not provide the immediate failure behavior needed for manual intervention upon schema changes.

Correct answers: B, C, E — Running the entire pipeline from data ingestion to model registration in a staging environment.; Validating that the final model is successfully registered in the MLflow Model Registry with the correct tags.; Using a representative subset of production-like data to execute the pipeline.

• A. Incorrect. Mocking the MLflow registry avoids exercising real integration points. End-to-end (E2E) tests should validate that the pipeline works across actual components and external dependencies to catch integration-specific failures.
• B. Correct. Running the full pipeline in a staging environment is a standard E2E approach. It validates the complete workflow across ingestion, transformation, training, and registration, identifying issues that unit tests might miss.
• C. Correct. Verifying that the model is registered in MLflow with the correct metadata and tags confirms the pipeline successfully completed its final operational step and produced the expected output.
• D. Incorrect. Testing an isolated function is a unit test. While important for code quality, it does not validate the flow of data or interaction between different pipeline stages required for E2E testing.
• E. Correct. Using a representative, production-like subset of data ensures the test remains realistic and mimics production behavior while keeping the runtime and cost of the E2E suite manageable.
• F. Incorrect. Bypassing feature engineering means the pipeline is no longer being tested end-to-end. This skips a critical stage where logic errors or data format mismatches could occur.

Correct answers: B, C, E — Databricks Jobs; Delta Live Tables (DLT) pipelines; Model serving endpoints

• A. Databricks Workspaces are the target environments where bundles are deployed, not resources defined within the bundle configuration itself. Workspace provisioning is typically handled via Azure Portal, CLI, or Infrastructure-as-Code tools like Terraform.
• B. Databricks Jobs are a core resource type supported by Databricks Asset Bundles. They can be defined in the `databricks.yml` to orchestrate notebooks, JARs, or Python scripts as part of a version-controlled deployment.
• C. Delta Live Tables (DLT) pipelines are natively supported in Databricks Asset Bundles, allowing developers to manage the lifecycle and deployment of data engineering pipelines alongside other project assets.
• D. Unity Catalog Metastore creation is an account-level governance task. While Bundles can interact with UC assets, the creation of the metastore itself is not managed within the bundle's `databricks.yml` configuration.
• E. Model serving endpoints can be included in Databricks Asset Bundles. This enables the consistent deployment and management of machine learning serving infrastructure as part of the application lifecycle.
• F. Azure Resource Groups are Azure platform-level resources. Databricks Asset Bundles are designed to manage Databricks-native assets and do not provision or manage underlying Azure cloud infrastructure like resource groups.

Correct answer: B — False

• A. The statement is false because pure Python unit tests do not have dependencies on the Spark engine or the Databricks Runtime, allowing them to be executed on standard CI/CD build agents or local environments without a cluster.
• B. The statement is false because a Databricks cluster is only required for tests that utilize Spark-specific functionalities or Databricks-specific APIs; decoupling pure logic allows for faster and more cost-effective testing on isolated runners.

Correct answer: B — Lakeflow Spark Declarative Pipelines (Delta Live Tables)

• A. Incorrect. Databricks Notebooks scheduled via cron are a basic automation method but do not inherently provide state management or declarative data quality enforcement. Implementing these features would require extensive manual coding for checkpointing and validation logic.
• B. Correct. Lakeflow Spark Declarative Pipelines (Delta Live Tables) are specifically designed to simplify the ETL lifecycle. They provide a declarative framework that automatically handles streaming state management, enforces data quality through 'expectations', and supports both batch and continuous processing modes.
• C. Incorrect. Databricks SQL Alerts are monitoring tools used to trigger notifications based on specific data conditions in SQL queries. They are not orchestration tools for building data pipelines or managing streaming state.
• D. Incorrect. While Lakeflow Jobs with Python wheels are useful for running modular and packageable code, they are imperative by nature. They do not provide the built-in, declarative framework for state management and data quality enforcement that is native to Delta Live Tables.

Correct answer: D — @dlt.expect_or_drop('valid_id', 'customer_id IS NOT NULL')

• A. @dlt.expect records the result of the expectation in the pipeline's event log and metrics but does not drop the record. The pipeline continues processing, and invalid records are still included in the target table.
• B. @dlt.expect_or_fail causes the entire pipeline execution to halt and fail if a single record violates the constraint. This is used for critical data quality issues and does not meet the requirement of continuing processing.
• C. @dlt.filter is not a valid decorator for defining expectations in Delta Live Tables (Lakeflow Declarative Pipelines). Expectations use the specific syntax of expect, expect_or_drop, or expect_or_fail.
• D. @dlt.expect_or_drop is the correct decorator to discard records that do not satisfy the condition (e.g., where customer_id is NULL) while allowing the pipeline to continue processing valid records.

Correct answer: B — If/Else condition

• A. Incorrect. 'Run If' is a task execution condition property (e.g., All succeeded, At least one failed) rather than a standalone task type. It controls execution based on the status of predecessor tasks, not the evaluation of specific values or logic passed between tasks.
• B. Correct. The 'If/Else condition' task type in Databricks Workflows allows you to branch logic based on a boolean expression. By retrieving values set by a previous task using `dbutils.jobs.task.setValues()`, the If/Else task can evaluate whether the condition is true or false to determine the subsequent path of the workflow.
• C. Incorrect. While 'Switch/Case' provides branching logic, it is designed for selecting one of several paths based on multiple potential values (strings or integers). The scenario described involves a binary true/false condition evaluation, which is the specific use case for the If/Else condition task.

Correct answer: A — Configure the Git provider in the Job settings and reference the branch in the task

• A. Correct. Configuring the job to use a Git provider source and pointing the task at the specific branch 'release/v1.2' allows Databricks to pull the notebook content from the repository at runtime. This avoids the need for manual workspace imports and ensures the job uses the version specified in the remote Git repository.
• B. Incorrect. Cloning the repository to Databricks Git Folders (formerly Workspace Repos) requires manual intervention or sync to bring the code into the workspace. This method references a workspace path rather than executing directly from the remote Git branch at runtime as requested.
• C. Incorrect. Using the Databricks CLI to copy files to DBFS is not a native Git integration feature. It adds operational overhead and involves moving code out of the repository into Databricks-managed storage, failing the requirement to run directly from Git.
• D. Incorrect. File arrival triggers are designed to start jobs when new data files land in a cloud storage location (like ADLS Gen2 or S3). They cannot be configured to monitor Git repository URLs or trigger notebook execution based on Git activity.

Correct answer: A — Configure the task as a Pipeline task; DLT handles its own retries automatically

• A. Correct. Configuring the task as a Pipeline task is the native and recommended way to run a DLT pipeline within a Databricks Job. DLT includes built-in retry and recovery behavior for transient infrastructure issues, allowing the service to manage pipeline execution semantics and recovery internally without requiring manual job-level retry logic.
• B. Incorrect. While setting Max Retries on the job task can help with task-level failures, it is not the recommended mechanism for DLT-specific recovery. DLT is designed to manage its own internal execution and infrastructure recovery, making high job-level retry settings redundant for transient cluster issues.
• C. Incorrect. Triggering a DLT pipeline via a Notebook task using the REST API adds unnecessary complexity and custom orchestration logic. This method bypasses the native resiliency benefits and simplified management provided by the integrated Pipeline task type.
• D. Incorrect. A Continuous trigger defines the execution mode (streaming/always-on) rather than the recovery mechanism for transient cluster failures. While continuous pipelines do attempt to stay active, the primary way to ensure the Job handles the DLT lifecycle and recovery correctly is by using the Pipeline task type.

Correct answers: A, B, C — Notebook; Python Wheel; SQL Query

• A. Notebook tasks are a standard and highly common task type in Databricks Lakeflow Jobs (Workflows). They allow for the execution of code (Python, SQL, Scala, or R) contained within a Databricks notebook as part of an orchestrated pipeline.
• B. Python Wheel tasks are supported in Databricks Jobs. They allow you to run packaged Python code distributed as a wheel (.whl) file, which is a best practice for productionizing reusable and modular job logic.
• C. SQL Query tasks (along with SQL Alerts and SQL Dashboards) are valid task types that execute logic against a Databricks SQL warehouse. This is essential for analytics, transformations, and reporting logic within the lakehouse.
• D. Power BI Dashboards are external visualization components. While Databricks provides data to Power BI, managing or executing the dashboard itself is not a native task type within a Databricks Lakeflow Job.
• E. Excel Macros are automation features specific to Microsoft Excel and are not supported as executable tasks within the Databricks orchestration environment.

Correct answer: B — Data skew

• A. Incorrect. While data spilling to disk often occurs as a result of a massive task exceeding memory limits, it is a symptom rather than the root cause of the imbalance. Spilling typically affects multiple tasks more uniformly if memory is insufficient across the cluster, and it does not explain why one task has 250 times more data than others.
• B. Correct. This scenario is a textbook example of data skew, where data is unevenly distributed across partitions (often due to a join or group-by key with high cardinality issues). This creates 'straggler' tasks that process significantly more data than others, delaying the completion of the entire stage.
• C. Incorrect. Insufficient cluster memory generally causes widespread performance degradation, frequent garbage collection, or OutOfMemory (OOM) errors across many tasks. It would not cause a single task to process a vastly different volume of data compared to its peers.
• D. Incorrect. High network latency impacts the time it takes to move data during shuffle operations, but it would typically affect all tasks involved in the shuffle. It does not explain the extreme discrepancy in the amount of data processed by a single task.

Correct answers: A, B — Enable Adaptive Query Execution (AQE) skew join optimization.; Add a random salt to the join key.

• A. Adaptive Query Execution (AQE) is a built-in Spark optimization that detects skewed partitions at runtime and splits them into smaller tasks. This dynamically balances the workload across tasks to prevent a few 'straggler' tasks from delaying the entire job.
• B. Adding a random salt to the join key involves appending a random number to the key in one table and duplicating the other table's records for each possible salt value. This redistributes the skewed keys across multiple partitions, preventing any single executor from being overwhelmed by a single heavy key.
• C. Decreasing cluster memory does not address the underlying data distribution issue. In fact, it would likely worsen performance or cause Out-of-Memory (OOM) errors because skewed tasks already require high memory to process large partitions.
• D. A cross join produces a Cartesian product, which dramatically increases the volume of data processed. This is not a skew mitigation strategy and would significantly degrade performance for large datasets.
• E. The VACUUM command is a Delta Lake maintenance operation used to remove files that are no longer in the latest state of the transaction log and are older than the retention threshold. It manages storage space and has no effect on join execution or data skew.