Select Two (Multi-Select) Questions

Microsoft Purview

Why wrong: Microsoft Purview is primarily used for data governance, cataloging, and security auditing across data estates. While it tracks lineage and sensitivity labels, it does not provide the performance metrics or compute utilization data necessary to monitor capacity health and throttling events.

Service Health Dashboard

Why wrong: The Service Health Dashboard is designed to show global status information regarding Microsoft service outages and planned maintenance. It does not provide insights into your specific tenant's resource consumption, user-level workload activity, or the granular throttling metrics required for performance optimization.

Power BI Desktop Performance Analyzer

Why wrong: The Performance Analyzer in Power BI Desktop is local to the report developer and identifies performance bottlenecks within a specific PBIX file. It cannot provide capacity-wide metrics or monitor compute throttling occurring on the Fabric backend during scheduled cloud refreshes or pipelines.

Export the logs to an Azure Log Analytics workspace.

Why wrong: While exporting logs is possible for long-term retention and complex querying, it is not a direct action within the Monitoring Hub to 'identify' jobs quickly. The Hub itself provides the real-time interface needed for this task without the overhead of setting up and querying external logging services.

Schedule a daily refresh for the Monitoring Hub dashboard.

Why wrong: The Monitoring Hub is a live system view that updates automatically as jobs progress; it is not a Power BI report that requires a scheduled refresh. Attempting to schedule a refresh is unnecessary and does not help in identifying current failures across the various workspaces in the environment.

Configure an alert in the Capacity Metrics app.

Why wrong: The Capacity Metrics app is focused on compute consumption and throttling rather than individual job success or failure. While you can alert on capacity limits, it will not provide a list of failed Spark jobs or Pipelines, making it the wrong tool for job-level status monitoring.

Manually export item .bim files and upload them to a GitHub repository.

Why wrong: Manual exports are prone to human error and do not provide the automated synchronization or change tracking offered by native Git integration. This approach bypasses the built-in Fabric source control features and makes it difficult to maintain a consistent state between the workspace and the repository. It is an inefficient method that lacks the governance required for modern analytics.

Assign the Workspace Admin role to the Service Principal used for Git.

Why wrong: While permissions are necessary, Git integration in Fabric typically uses the identity of the logged-in user rather than a standalone Service Principal for standard workspace sync. Assigning excessive admin roles to a Service Principal does not facilitate the version control process itself. Focus should remain on user permissions and repository access rights to ensure secure and effective synchronization.

Convert all Lakehouses to Warehouses to enable Git compatibility.

Why wrong: Both Lakehouses and Warehouses are supported in various capacities by Fabric's Git integration features, so converting types is unnecessary and counterproductive. Each artifact type has its specific use case, and Git integration is designed to handle different item types by serializing their unique metadata formats. Forcing a conversion would disrupt the data architecture without providing any version control benefits.

Grant the service principal the 'Global Administrator' role in Entra ID.

Why wrong: Granting Global Administrator rights is a violation of the principle of least privilege and is not required for Fabric API access. Service principals only need the specific workspace-level roles or tenant-level API permissions necessary for the tasks they are designed to perform within the environment.

Assign a Power BI Pro license directly to the service principal.

Why wrong: Service principals do not require individual user licenses like Power BI Pro. Their access is governed by tenant settings and workspace roles. As long as the content is on a supported capacity, the service principal can perform actions without the overhead of per-user licensing costs.

Data Pipeline

Why wrong: While Data Factory Pipelines are a core part of Fabric, they are not supported by the native Git integration at this time. Developers often have to manually move pipeline definitions or use alternative methods like APIs for versioning, although support for pipelines is a major item on the product roadmap.

KQL Queryset

Why wrong: KQL Querysets, used for interacting with Real-Time Analytics data, are currently not supported by the Fabric Git integration. Changes to these items must be managed within the Fabric UI or through other manual export/import processes, as they do not yet have a native serialization for Git.

Convert all tables to heap structures.

Why wrong: Heap structures lack inherent ordering, forcing the SQL engine to perform full table scans for most analytical queries. This results in poor performance for large datasets, as the engine cannot leverage metadata for data skipping or efficient retrieval, making heaps unsuitable for primary fact tables in a data warehouse.

Increase the number of rows per file to 1 billion.

Why wrong: Extremely large files hinder parallel processing capabilities in Fabric. The engine benefits from a balance where file sizes are large enough to be efficient but small enough to allow for effective parallel tasks. A billion rows per file would likely lead to massive memory pressure and failed query executions.

Disable statistics collection for all columns.

Why wrong: Statistics are vital for the query optimizer to create efficient execution plans. Without accurate statistics, the optimizer might choose suboptimal join orders or scan methods, leading to severe performance degradation. Managing statistics is a core maintenance task for ensuring the engine generates the most performant execution plans.

Verified

Why wrong: While 'Verified' sounds like a logical term for data quality, it is not a standard endorsement level in Microsoft Fabric. Fabric specifically uses 'Promoted' and 'Certified' to categorize the maturity and reliability of its items within the OneLake data hub and workspaces.

Approved

Why wrong: The term 'Approved' is not part of the official Microsoft Fabric endorsement vocabulary. While organizations may have an approval workflow, the final state reflected in the Fabric UI and metadata is either 'Promoted' or 'Certified' to help users discover the most relevant data.

Validated

Why wrong: Similar to 'Verified' and 'Approved', 'Validated' is not a technical term used for item endorsement in Fabric. Using the correct terminology is important for both the exam and for configuring the environment according to Microsoft's governance framework and user interface options.

Lookup activity

Why wrong: The Lookup activity is used to retrieve data from a dataset or query result. While it can be used to feed values into conditional logic, it is an ingestion/retrieval activity, not a control-flow activity. It does not perform branching or logic evaluation on its own.

Stored Procedure activity

Why wrong: A Stored Procedure activity is used to invoke SQL code. While that code may contain conditional logic, the activity itself does not manage pipeline-level branching or orchestration. It is a discrete task execution unit and should not be used for control flow orchestration in the Fabric pipeline.

Wait activity

Why wrong: The Wait activity pauses the pipeline execution for a specified duration. It does not support logical branching, conditional evaluation, or any form of workflow control beyond timing. It is intended for synchronization or delaying downstream tasks, not for implementing logic-based decision-making in your ingestion architecture.

Smaller storage footprint than Parquet

Why wrong: Delta Lake files are physically stored as Parquet files. Therefore, there is no inherent reduction in storage footprint. In fact, the metadata overhead from the Delta log slightly increases storage usage, but this is a necessary trade-off for the advanced management features provided.

Faster cold-start execution for Spark clusters

Why wrong: Delta Lake format does not impact the cold-start time of a Spark cluster. Cluster startup speed is determined by the infrastructure provisioning process, not the file format used in the storage layer. These are entirely separate components in the Fabric architecture.

Manually delete old Parquet files from the file system

Why wrong: Manually deleting files from the storage account can corrupt the Delta table state. Delta Lake maintains a transaction log; bypassing this log will lead to inconsistencies or table errors. You must use the VACUUM command to safely remove expired files that are no longer referenced by the log.

Convert the table to CSV format

Why wrong: Converting to CSV is regressive. CSV files lack the metadata, schema enforcement, and transaction capabilities that Delta Lake provides. You would lose support for features like time travel, ACID transactions, and efficient partition pruning, leading to significantly worse performance and reliability for your high-volume sensor data processing.

Increase the number of partitions to equal total file count

Why wrong: Increasing partitions to match the file count causes an 'over-partitioning' problem. This leads to excessive small file creation and metadata overhead, which degrades performance rather than improving it. Partitioning should be based on logical query boundaries, not the raw number of files present in the storage.

Always set the number of partitions to 1

Why wrong: Setting partitions to 1 is a performance killer. It forces all data onto a single worker node, negating the benefits of parallel processing. This leads to severe bottlenecks and memory overflow errors, making it the wrong approach for scaling data processing in Spark-based cloud environments.

Convert all data to JSON

Why wrong: Converting to JSON is detrimental to performance. It increases serialization overhead and storage size compared to binary formats like Delta or Parquet. JSON is not an analytical format and will drastically increase the time spent on I/O and parsing during data processing jobs, making this an anti-pattern.

Increase the idle timeout

Why wrong: Increasing the idle timeout does not impact the execution time of a job. It only affects how long the compute resources remain active after the job finishes. While it might prevent startup delays for future jobs, it is not a technique to optimize the current job's processing logic.

Enable 'High Concurrency' mode for the Dataflow.

Why wrong: High Concurrency is a Spark session setting that allows multiple jobs to run on the same cluster. It does not affect the logical filtering of data for incremental loads and is not a configuration option within the Dataflow Gen2 user interface or its refresh settings.

Use the 'Remove Duplicates' transformation on the entire table.

Why wrong: While removing duplicates might be necessary for data quality, it is a transformation step that processes all rows in the current buffer. It does not facilitate incremental loading from the source; rather, it is a data cleaning step applied after the data has been ingested.

Configure a 'Tumbling Window' trigger in the Lakehouse.

Why wrong: Tumbling Window triggers are components of Data Factory pipelines, not Dataflows themselves. While a pipeline can trigger a Dataflow, the internal logic for incremental processing must be defined within the Dataflow's Power Query steps and parameters to be effective.

Increase the number of partitions to the maximum.

Why wrong: Blindly increasing partitions can actually degrade performance due to metadata overhead. If the skew is inherent to the data distribution, simply increasing partitions will not resolve the issue. You must focus on redistribution techniques like salting rather than just increasing the volume of tasks for the engine.

Change the file format to CSV.

Why wrong: Changing the file format to CSV will not impact how Spark handles joins or data skew. It will likely degrade performance further due to the lack of schema enforcement and the inability to use advanced features like partition pruning or data skipping, which are vital for query efficiency.

The physical IP address of the Spark executor nodes.

Why wrong: The Capacity Metrics app is a high-level management tool and does not provide low-level networking or infrastructure details like individual IP addresses of compute nodes. Such information is abstracted away by the Fabric platform and is generally not relevant for capacity-level performance tuning or cost management.

The SQL execution plan for every query in the timepoint.

Why wrong: The Capacity Metrics app shows that a SQL query ran and how many CUs it used, but it does not store or display the full execution plans. To see execution plans, you must use the SQL Analytics Endpoint's own management views or the Query Insights feature within the workspace.

Increase the number of rows per transaction.

Why wrong: Increasing the number of rows per transaction is generally associated with write-heavy workloads and transactional processing. In a data warehouse environment, this does not help read performance and can actually lead to lock contention, slowing down read queries during concurrent operations.

Use row-based storage exclusively.

Why wrong: Row-based storage is optimized for transactional systems (OLTP) where individual records are frequently updated or retrieved. It is inefficient for analytical workloads because it requires reading entire rows even when only a few columns are needed, resulting in excessive I/O for analytical queries.

Disable data compression.

Why wrong: Disabling compression increases the amount of data read from disk, which severely degrades performance in an analytical environment. Compression is essential for reducing I/O, and since read-heavy workloads rely on efficient scanning, keeping data compressed is vital for keeping queries running quickly.

Lakehouse name rules

Why wrong: Fabric deployment pipelines do not currently support rules for renaming the Lakehouse item itself during deployment. The item name remains consistent across stages to maintain the lineage and internal GUID mapping. Changes to the item's display name must be done manually if absolutely necessary, though it's discouraged.

User permission rules

Why wrong: Deployment pipelines do not manage the synchronization or modification of user permissions or workspace roles. Security and access control must be managed separately in the destination workspace. Pipelines focus on the items and their internal configurations rather than the access control lists associated with the workspace itself.

Sensitivity labels in Fabric only affect the UI color and do not provide protection.

Why wrong: Labels provide much more than visual cues; they can enforce actual protection policies, including encryption and access restrictions. When properly configured in Purview, these labels ensure that only authorized users can open files, even if they are downloaded or shared outside the organization. They are a core part of the security architecture, not just a cosmetic feature.

Labels are only available for Power BI items and cannot be applied to Lakehouses.

Why wrong: Microsoft Fabric has extended sensitivity label support to many item types, including Lakehouses, Warehouses, and Notebooks. This allows for a holistic approach to data classification across the entire data engineering and data science lifecycle. Limiting labels to only Power BI would leave a significant gap in the organization's overall data security and compliance posture.

Sensitivity labels automatically delete any data that is older than three years.

Why wrong: Sensitivity labels are used for classification and protection, not for data retention or lifecycle deletion policies. While Purview does offer retention labels, they are a distinct feature from the sensitivity labels used to secure and classify items in Fabric. Confusing the two can lead to incorrect data management strategies and accidental loss of important historical information.

Increase the 'isSequential' property to True.

Why wrong: The isSequential property is a setting used in Data Factory pipeline ForEach activities to control whether iterations run one after another or in parallel. It has no relevance to the internal transformation performance of a Spark Notebook or how Spark handles data processing on its cluster.

Convert all files to the Avro format for faster reads.

Why wrong: Avro is a row-based format that is excellent for write-intensive workloads but is generally slower for analytical queries compared to columnar formats like Parquet or Delta. Fabric is optimized for Delta Lake, and moving away from Delta would actually degrade performance across the platform's engines.

Disable the Spark 'High Concurrency' mode.

Why wrong: High Concurrency mode in Fabric Spark allows multiple users or jobs to share the same Spark session, which reduces startup latency and improves resource utilization. Disabling this mode would not improve transformation performance and would likely increase the time spent waiting for session initialization.

Create a shortcut to the data in an Azure Data Lake Storage Gen2 account.

Why wrong: Shortcuts allow you to reference data without moving it, but they do not inherently apply optimizations like V-Order or re-partition the existing data. To apply these optimizations, the data must be rewritten into the Lakehouse. Shortcuts are a connectivity feature rather than a performance optimization technique for data ingestion.

Convert the files to CSV format before ingestion to reduce overhead.

Why wrong: CSV files are significantly less efficient than Parquet or Delta formats because they are row-based and do not support advanced optimizations like V-Order. Converting data to CSV would actually degrade performance for downstream analytical queries and is contrary to the best practices for building a performant Fabric Lakehouse.

Apply a Z-Order index on the primary key column during the write operation.

Why wrong: While Z-Order is a valid Delta Lake optimization for multidimensional clustering, it is typically applied via an OPTIMIZE command after the data is written, rather than during the initial write operation. Additionally, V-Order is the preferred Microsoft Fabric optimization that provides similar or better benefits for the Fabric engine.

A Shortcut to the Azure SQL Database.

Why wrong: Shortcuts are currently used for file-based or Fabric-native storage and do not apply to Azure SQL Database for incremental pipeline logic. Even if they did, a shortcut provides access to the whole table and does not inherently manage the logic required to track and filter incremental changes over time.

Mirroring for Azure SQL Database.

Why wrong: Mirroring is an alternative to pipelines that provides automated, continuous replication. If you are using Mirroring, you would not need to manually build a watermark-based pipeline. Since the question specifically asks for the components of a watermark-based pipeline, Mirroring is not a component of that manual process.