Microsoft Fabric Data Engineer DP-700 Pipelines, PySpark, SQL, KQL And Batch Data Quality Practice Test

 

Topic 07 covers pipelines, pyspark, sql, kql and batch data quality for Microsoft DP-700 practice. Study each scenario and select the best answer. For broader exam preparation, review the Microsoft DP-700 Exam Dumps page.

Question 1

After a recent change in a logistics monitoring solution, the team determines that the workflow needs to move data and then run validations and downstream transformations. Which implementation should be selected?

1. Use Copy activity for governed source-to-target movement inside a larger pipeline
2. Use a parameterized pipeline for repeated table ingestion
3. Use a gateway-backed connection for a network-restricted source
4. Preserve hierarchy when file organization carries partition meaning
5. Use binary copy when files should be moved without schema parsing

Correct Answer: A

Correct Answer

Answer A is correct because Copy activity fits as one orchestrated pipeline step. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer B is incorrect because this action is appropriate when the same copy pattern must handle many tables whose names and paths vary at runtime. Specifically, parameters avoid cloning nearly identical pipelines, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the source cannot be reached directly from Fabric cloud endpoints. Specifically, a supported gateway bridges Fabric data movement to the restricted source network, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when downstream processing depends on the original folder structure such as year/month/day partitions. Specifically, preserving hierarchy retains the source path semantics in the copied data, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the requirement is high-throughput file transfer and transformation happens later. Specifically, schema-agnostic binary copy avoids unnecessary parsing during movement, which does not resolve the decisive condition in this scenario.

Question 2

A Fabric engineering team is reviewing a regional supply-chain platform. The same copy pattern must handle many tables whose names and paths vary at runtime Which action is most appropriate?

1. Preserve hierarchy when file organization carries partition meaning
2. Use binary copy when files should be moved without schema parsing
3. Use Copy activity for governed source-to-target movement inside a larger pipeline
4. Use a parameterized pipeline for repeated table ingestion
5. Use a gateway-backed connection for a network-restricted source

Correct Answer: D

Correct Answer

Answer D is correct because parameters avoid cloning nearly identical pipelines. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when downstream processing depends on the original folder structure such as year/month/day partitions. Specifically, preserving hierarchy retains the source path semantics in the copied data, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the requirement is high-throughput file transfer and transformation happens later. Specifically, schema-agnostic binary copy avoids unnecessary parsing during movement, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the workflow needs to move data and then run validations and downstream transformations. Specifically, Copy activity fits as one orchestrated pipeline step, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the source cannot be reached directly from Fabric cloud endpoints. Specifically, a supported gateway bridges Fabric data movement to the restricted source network, which does not resolve the decisive condition in this scenario.

Question 3

A data engineer must correct a design for a shared business intelligence platform. The decisive requirement is that the source cannot be reached directly from Fabric cloud endpoints. Which choice best addresses it?

1. Use a parameterized pipeline for repeated table ingestion
2. Use a gateway-backed connection for a network-restricted source
3. Preserve hierarchy when file organization carries partition meaning
4. Use binary copy when files should be moved without schema parsing
5. Use Copy activity for governed source-to-target movement inside a larger pipeline

Correct Answer: B

Correct Answer

Answer B is correct because a supported gateway bridges Fabric data movement to the restricted source network. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the same copy pattern must handle many tables whose names and paths vary at runtime. Specifically, parameters avoid cloning nearly identical pipelines, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when downstream processing depends on the original folder structure such as year/month/day partitions. Specifically, preserving hierarchy retains the source path semantics in the copied data, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the requirement is high-throughput file transfer and transformation happens later. Specifically, schema-agnostic binary copy avoids unnecessary parsing during movement, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the workflow needs to move data and then run validations and downstream transformations. Specifically, Copy activity fits as one orchestrated pipeline step, which does not resolve the decisive condition in this scenario.

Question 4

For an enterprise lakehouse program, the organization has fixed the following constraint: downstream processing depends on the original folder structure such as year/month/day partitions. Which action best satisfies the requirement?

1. Use binary copy when files should be moved without schema parsing
2. Use Copy activity for governed source-to-target movement inside a larger pipeline
3. Use a parameterized pipeline for repeated table ingestion
4. Use a gateway-backed connection for a network-restricted source
5. Preserve hierarchy when file organization carries partition meaning

Correct Answer: E

Correct Answer

Answer E is correct because preserving hierarchy retains the source path semantics in the copied data. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the requirement is high-throughput file transfer and transformation happens later. Specifically, schema-agnostic binary copy avoids unnecessary parsing during movement, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the workflow needs to move data and then run validations and downstream transformations. Specifically, Copy activity fits as one orchestrated pipeline step, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the same copy pattern must handle many tables whose names and paths vary at runtime. Specifically, parameters avoid cloning nearly identical pipelines, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the source cannot be reached directly from Fabric cloud endpoints. Specifically, a supported gateway bridges Fabric data movement to the restricted source network, which does not resolve the decisive condition in this scenario.

Question 5

During an operational design review for a regulated retail analytics platform, engineers confirm that the requirement is high-throughput file transfer and transformation happens later. What should they do?

1. Use a gateway-backed connection for a network-restricted source
2. Preserve hierarchy when file organization carries partition meaning
3. Use binary copy when files should be moved without schema parsing
4. Use Copy activity for governed source-to-target movement inside a larger pipeline
5. Use a parameterized pipeline for repeated table ingestion

Correct Answer: C

Correct Answer

Answer C is correct because schema-agnostic binary copy avoids unnecessary parsing during movement. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the source cannot be reached directly from Fabric cloud endpoints. Specifically, a supported gateway bridges Fabric data movement to the restricted source network, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when downstream processing depends on the original folder structure such as year/month/day partitions. Specifically, preserving hierarchy retains the source path semantics in the copied data, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the workflow needs to move data and then run validations and downstream transformations. Specifically, Copy activity fits as one orchestrated pipeline step, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the same copy pattern must handle many tables whose names and paths vary at runtime. Specifically, parameters avoid cloning nearly identical pipelines, which does not resolve the decisive condition in this scenario.

Question 6

After a recent change in an IoT operations solution, the team determines that the transformation joins large Delta datasets and needs Spark parallelism. Which implementation should be selected?

1. Use PySpark DataFrame operations for distributed large-scale joins
2. Use Spark SQL within the notebook for SQL-expressive Delta transformations
3. Repartition before a wide operation when the current partitioning causes severe skew
4. Broadcast the genuinely small dimension in a large-small join
5. Persist an expensive reused intermediate DataFrame when memory and reuse justify it

Correct Answer: A

Correct Answer

Answer A is correct because PySpark DataFrames provide distributed transformations across Spark executors. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer B is incorrect because this action is appropriate when engineers prefer SQL syntax but need the transformation to run in the Spark session over Lakehouse tables. Specifically, Spark SQL provides SQL semantics on Spark-managed data, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when one partition receives most rows and a shuffle stage has a long straggler. Specifically, repartitioning on a better key can distribute the work more evenly, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when a large fact table joins a dimension small enough to fit safely on executors. Specifically, broadcasting the small side can avoid a large shuffle, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the same costly transformation feeds several downstream actions in one notebook run. Specifically, caching/persisting can avoid recomputing the shared intermediate repeatedly, which does not resolve the decisive condition in this scenario.

Question 7

A Fabric engineering team is reviewing a product usage analytics pipeline. Engineers prefer SQL syntax but need the transformation to run in the Spark session over Lakehouse tables Which action is most appropriate?

1. Broadcast the genuinely small dimension in a large-small join
2. Persist an expensive reused intermediate DataFrame when memory and reuse justify it
3. Use PySpark DataFrame operations for distributed large-scale joins
4. Use Spark SQL within the notebook for SQL-expressive Delta transformations
5. Repartition before a wide operation when the current partitioning causes severe skew

Correct Answer: D

Correct Answer

Answer D is correct because Spark SQL provides SQL semantics on Spark-managed data. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when a large fact table joins a dimension small enough to fit safely on executors. Specifically, broadcasting the small side can avoid a large shuffle, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the same costly transformation feeds several downstream actions in one notebook run. Specifically, caching/persisting can avoid recomputing the shared intermediate repeatedly, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the transformation joins large Delta datasets and needs Spark parallelism. Specifically, PySpark DataFrames provide distributed transformations across Spark executors, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when one partition receives most rows and a shuffle stage has a long straggler. Specifically, repartitioning on a better key can distribute the work more evenly, which does not resolve the decisive condition in this scenario.

Question 8

A data engineer must correct a design for a customer-analytics environment. The decisive requirement is that one partition receives most rows and a shuffle stage has a long straggler. Which choice best addresses it?

1. Use Spark SQL within the notebook for SQL-expressive Delta transformations
2. Repartition before a wide operation when the current partitioning causes severe skew
3. Broadcast the genuinely small dimension in a large-small join
4. Persist an expensive reused intermediate DataFrame when memory and reuse justify it
5. Use PySpark DataFrame operations for distributed large-scale joins

Correct Answer: B

Correct Answer

Answer B is correct because repartitioning on a better key can distribute the work more evenly. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when engineers prefer SQL syntax but need the transformation to run in the Spark session over Lakehouse tables. Specifically, Spark SQL provides SQL semantics on Spark-managed data, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when a large fact table joins a dimension small enough to fit safely on executors. Specifically, broadcasting the small side can avoid a large shuffle, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the same costly transformation feeds several downstream actions in one notebook run. Specifically, caching/persisting can avoid recomputing the shared intermediate repeatedly, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the transformation joins large Delta datasets and needs Spark parallelism. Specifically, PySpark DataFrames provide distributed transformations across Spark executors, which does not resolve the decisive condition in this scenario.

Question 9

For an internal finance data estate, the organization has fixed the following constraint: a large fact table joins a dimension small enough to fit safely on executors. Which action best satisfies the requirement?

1. Persist an expensive reused intermediate DataFrame when memory and reuse justify it
2. Use PySpark DataFrame operations for distributed large-scale joins
3. Use Spark SQL within the notebook for SQL-expressive Delta transformations
4. Repartition before a wide operation when the current partitioning causes severe skew
5. Broadcast the genuinely small dimension in a large-small join

Correct Answer: E

Correct Answer

Answer E is correct because broadcasting the small side can avoid a large shuffle. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the same costly transformation feeds several downstream actions in one notebook run. Specifically, caching/persisting can avoid recomputing the shared intermediate repeatedly, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the transformation joins large Delta datasets and needs Spark parallelism. Specifically, PySpark DataFrames provide distributed transformations across Spark executors, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when engineers prefer SQL syntax but need the transformation to run in the Spark session over Lakehouse tables. Specifically, Spark SQL provides SQL semantics on Spark-managed data, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when one partition receives most rows and a shuffle stage has a long straggler. Specifically, repartitioning on a better key can distribute the work more evenly, which does not resolve the decisive condition in this scenario.

Question 10

During an operational design review for a multi-team Fabric deployment, engineers confirm that the same costly transformation feeds several downstream actions in one notebook run. What should they do?

1. Repartition before a wide operation when the current partitioning causes severe skew
2. Broadcast the genuinely small dimension in a large-small join
3. Persist an expensive reused intermediate DataFrame when memory and reuse justify it
4. Use PySpark DataFrame operations for distributed large-scale joins
5. Use Spark SQL within the notebook for SQL-expressive Delta transformations

Correct Answer: C

Correct Answer

Answer C is correct because caching/persisting can avoid recomputing the shared intermediate repeatedly. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when one partition receives most rows and a shuffle stage has a long straggler. Specifically, repartitioning on a better key can distribute the work more evenly, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when a large fact table joins a dimension small enough to fit safely on executors. Specifically, broadcasting the small side can avoid a large shuffle, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the transformation joins large Delta datasets and needs Spark parallelism. Specifically, PySpark DataFrames provide distributed transformations across Spark executors, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when engineers prefer SQL syntax but need the transformation to run in the Spark session over Lakehouse tables. Specifically, Spark SQL provides SQL semantics on Spark-managed data, which does not resolve the decisive condition in this scenario.

Question 11

After a recent change in a real-time telemetry service, the team determines that a warehouse target must apply inserts and updates from a staged relational dataset. Which implementation should be selected?

1. Use a set-based T-SQL MERGE or equivalent controlled upsert pattern
2. Use a view for reusable relational transformation logic
3. Use GROUP BY for relational aggregation at the target grain
4. Use window functions when row detail must be preserved alongside partition-level calculations
5. Stage complex transformations before publishing to the curated table

Correct Answer: A

Correct Answer

Answer A is correct because set-based SQL is appropriate for relational upsert processing when concurrency and semantics are validated.

Incorrect Answers

Answer B is incorrect because this action is appropriate when multiple consumers need the same governed projection without physically duplicating the data. Specifically, a view centralizes the relational expression while leaving base storage unchanged, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the source contains detail rows but the target requires one row per business key and day. Specifically, GROUP BY computes the declared aggregate grain in SQL, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the output needs each event plus rank or running metrics within an entity partition. Specifically, window functions calculate partition context without collapsing rows, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the logic requires multiple steps and the final curated object should only receive validated results. Specifically, staging separates intermediate processing from the governed published table, which does not resolve the decisive condition in this scenario.

Question 12

A Fabric engineering team is reviewing a global manufacturing data product. Multiple consumers need the same governed projection without physically duplicating the data Which action is most appropriate?

1. Use window functions when row detail must be preserved alongside partition-level calculations
2. Stage complex transformations before publishing to the curated table
3. Use a set-based T-SQL MERGE or equivalent controlled upsert pattern
4. Use a view for reusable relational transformation logic
5. Use GROUP BY for relational aggregation at the target grain

Correct Answer: D

Correct Answer

Answer D is correct because a view centralizes the relational expression while leaving base storage unchanged. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the output needs each event plus rank or running metrics within an entity partition. Specifically, window functions calculate partition context without collapsing rows, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the logic requires multiple steps and the final curated object should only receive validated results. Specifically, staging separates intermediate processing from the governed published table, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when a warehouse target must apply inserts and updates from a staged relational dataset. Specifically, set-based SQL is appropriate for relational upsert processing when concurrency and semantics are validated, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the source contains detail rows but the target requires one row per business key and day. Specifically, GROUP BY computes the declared aggregate grain in SQL, which does not resolve the decisive condition in this scenario.

Question 13

A data engineer must correct a design for a governed self-service analytics domain. The decisive requirement is that the source contains detail rows but the target requires one row per business key and day. Which choice best addresses it?

1. Use a view for reusable relational transformation logic
2. Use GROUP BY for relational aggregation at the target grain
3. Use window functions when row detail must be preserved alongside partition-level calculations
4. Stage complex transformations before publishing to the curated table
5. Use a set-based T-SQL MERGE or equivalent controlled upsert pattern

Correct Answer: B

Correct Answer

Answer B is correct because GROUP BY computes the declared aggregate grain in SQL. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when multiple consumers need the same governed projection without physically duplicating the data. Specifically, a view centralizes the relational expression while leaving base storage unchanged, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the output needs each event plus rank or running metrics within an entity partition. Specifically, window functions calculate partition context without collapsing rows, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the logic requires multiple steps and the final curated object should only receive validated results. Specifically, staging separates intermediate processing from the governed published table, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when a warehouse target must apply inserts and updates from a staged relational dataset. Specifically, set-based SQL is appropriate for relational upsert processing when concurrency and semantics are validated, which does not resolve the decisive condition in this scenario.

Question 14

For a financial reporting workspace, the organization has fixed the following constraint: the output needs each event plus rank or running metrics within an entity partition. Which action best satisfies the requirement?

1. Stage complex transformations before publishing to the curated table
2. Use a set-based T-SQL MERGE or equivalent controlled upsert pattern
3. Use a view for reusable relational transformation logic
4. Use GROUP BY for relational aggregation at the target grain
5. Use window functions when row detail must be preserved alongside partition-level calculations

Correct Answer: E

Correct Answer

Answer E is correct because window functions calculate partition context without collapsing rows. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the logic requires multiple steps and the final curated object should only receive validated results. Specifically, staging separates intermediate processing from the governed published table, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when a warehouse target must apply inserts and updates from a staged relational dataset. Specifically, set-based SQL is appropriate for relational upsert processing when concurrency and semantics are validated, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when multiple consumers need the same governed projection without physically duplicating the data. Specifically, a view centralizes the relational expression while leaving base storage unchanged, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the source contains detail rows but the target requires one row per business key and day. Specifically, GROUP BY computes the declared aggregate grain in SQL, which does not resolve the decisive condition in this scenario.

Question 15

During an operational design review for a healthcare operations workspace, engineers confirm that the logic requires multiple steps and the final curated object should only receive validated results. What should they do?

1. Use GROUP BY for relational aggregation at the target grain
2. Use window functions when row detail must be preserved alongside partition-level calculations
3. Stage complex transformations before publishing to the curated table
4. Use a set-based T-SQL MERGE or equivalent controlled upsert pattern
5. Use a view for reusable relational transformation logic

Correct Answer: C

Correct Answer

Answer C is correct because staging separates intermediate processing from the governed published table. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the source contains detail rows but the target requires one row per business key and day. Specifically, GROUP BY computes the declared aggregate grain in SQL, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the output needs each event plus rank or running metrics within an entity partition. Specifically, window functions calculate partition context without collapsing rows, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when a warehouse target must apply inserts and updates from a staged relational dataset. Specifically, set-based SQL is appropriate for relational upsert processing when concurrency and semantics are validated, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when multiple consumers need the same governed projection without physically duplicating the data. Specifically, a view centralizes the relational expression while leaving base storage unchanged, which does not resolve the decisive condition in this scenario.

Question 16

After a recent change in a logistics monitoring solution, the team determines that the Eventhouse query needs counts and measures by device and time bucket. Which implementation should be selected?

1. Use summarize for grouped event aggregation
2. Use extend for a derived column that preserves the input rows
3. Use project to keep only the required output columns
4. Use join for event enrichment from a compatible lookup dataset
5. Use where early to remove irrelevant events before expensive operations

Correct Answer: A

Correct Answer

Answer A is correct because summarize is the KQL grouping/aggregation operator. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer B is incorrect because this action is appropriate when the query needs a calculated classification while retaining each event row. Specifically, extend adds calculated columns without grouping away row detail, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the downstream query should reduce width and expose a curated column set. Specifically, project selects and orders the columns returned by the KQL query, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when telemetry rows need descriptive attributes from a second KQL-accessible dataset. Specifically, join combines matching records from the two inputs, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when only a small time range and device subset is needed from a much larger event table. Specifically, early filtering reduces the data processed by later KQL operators, which does not resolve the decisive condition in this scenario.

Question 17

A Fabric engineering team is reviewing a regional supply-chain platform. The query needs a calculated classification while retaining each event row Which action is most appropriate?

1. Use join for event enrichment from a compatible lookup dataset
2. Use where early to remove irrelevant events before expensive operations
3. Use summarize for grouped event aggregation
4. Use extend for a derived column that preserves the input rows
5. Use project to keep only the required output columns

Correct Answer: D

Correct Answer

Answer D is correct because extend adds calculated columns without grouping away row detail. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when telemetry rows need descriptive attributes from a second KQL-accessible dataset. Specifically, join combines matching records from the two inputs, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when only a small time range and device subset is needed from a much larger event table. Specifically, early filtering reduces the data processed by later KQL operators, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the Eventhouse query needs counts and measures by device and time bucket. Specifically, summarize is the KQL grouping/aggregation operator, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the downstream query should reduce width and expose a curated column set. Specifically, project selects and orders the columns returned by the KQL query, which does not resolve the decisive condition in this scenario.

Question 18

A data engineer must correct a design for a shared business intelligence platform. The decisive requirement is that the downstream query should reduce width and expose a curated column set. Which choice best addresses it?

1. Use extend for a derived column that preserves the input rows
2. Use project to keep only the required output columns
3. Use join for event enrichment from a compatible lookup dataset
4. Use where early to remove irrelevant events before expensive operations
5. Use summarize for grouped event aggregation

Correct Answer: B

Correct Answer

Answer B is correct because project selects and orders the columns returned by the KQL query. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the query needs a calculated classification while retaining each event row. Specifically, extend adds calculated columns without grouping away row detail, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when telemetry rows need descriptive attributes from a second KQL-accessible dataset. Specifically, join combines matching records from the two inputs, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when only a small time range and device subset is needed from a much larger event table. Specifically, early filtering reduces the data processed by later KQL operators, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the Eventhouse query needs counts and measures by device and time bucket. Specifically, summarize is the KQL grouping/aggregation operator, which does not resolve the decisive condition in this scenario.

Question 19

For an enterprise lakehouse program, the organization has fixed the following constraint: telemetry rows need descriptive attributes from a second KQL-accessible dataset. Which action best satisfies the requirement?

1. Use where early to remove irrelevant events before expensive operations
2. Use summarize for grouped event aggregation
3. Use extend for a derived column that preserves the input rows
4. Use project to keep only the required output columns
5. Use join for event enrichment from a compatible lookup dataset

Correct Answer: E

Correct Answer

Answer E is correct because join combines matching records from the two inputs. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when only a small time range and device subset is needed from a much larger event table. Specifically, early filtering reduces the data processed by later KQL operators, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the Eventhouse query needs counts and measures by device and time bucket. Specifically, summarize is the KQL grouping/aggregation operator, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the query needs a calculated classification while retaining each event row. Specifically, extend adds calculated columns without grouping away row detail, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the downstream query should reduce width and expose a curated column set. Specifically, project selects and orders the columns returned by the KQL query, which does not resolve the decisive condition in this scenario.

Question 20

During an operational design review for a regulated retail analytics platform, engineers confirm that only a small time range and device subset is needed from a much larger event table. What should they do?

1. Use project to keep only the required output columns
2. Use join for event enrichment from a compatible lookup dataset
3. Use where early to remove irrelevant events before expensive operations
4. Use summarize for grouped event aggregation
5. Use extend for a derived column that preserves the input rows

Correct Answer: C

Correct Answer

Answer C is correct because early filtering reduces the data processed by later KQL operators. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the downstream query should reduce width and expose a curated column set. Specifically, project selects and orders the columns returned by the KQL query, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when telemetry rows need descriptive attributes from a second KQL-accessible dataset. Specifically, join combines matching records from the two inputs, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the Eventhouse query needs counts and measures by device and time bucket. Specifically, summarize is the KQL grouping/aggregation operator, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the query needs a calculated classification while retaining each event row. Specifically, extend adds calculated columns without grouping away row detail, which does not resolve the decisive condition in this scenario.

Question 21

After a recent change in an IoT operations solution, the team determines that queries repeatedly join the same stable small dimension and low-latency serving is prioritized. Which implementation should be selected?

1. Flatten frequently joined descriptive attributes into the serving table when the read pattern benefits and update semantics are controlled
2. Keep volatile attributes normalized when duplication would create widespread update inconsistency
3. Create a curated flattened table rather than modifying the raw ingestion layer
4. Document the chosen grain before denormalizing one-to-many data
5. Reconcile row counts and measures after the denormalizing join

Correct Answer: A

Correct Answer

Answer A is correct because selective denormalization can reduce repeated join work when the duplication tradeoff is acceptable. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer B is incorrect because this action is appropriate when the attribute changes frequently and would be copied into many rows if denormalized. Specifically, normalization avoids repeated updates and inconsistent duplicated values, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when consumers need simplified analytics but the raw source representation must remain available for replay. Specifically, a curated layer can denormalize for use while preserving raw lineage, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when a one-to-many relationship could multiply rows and silently change measures. Specifically, grain definition prevents accidental row multiplication during flattening, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the flattening step might duplicate facts due to nonunique join keys. Specifically, reconciliation detects unintended amplification before publication, which does not resolve the decisive condition in this scenario.

Question 22

A Fabric engineering team is reviewing a product usage analytics pipeline. The attribute changes frequently and would be copied into many rows if denormalized Which action is most appropriate?

1. Document the chosen grain before denormalizing one-to-many data
2. Reconcile row counts and measures after the denormalizing join
3. Flatten frequently joined descriptive attributes into the serving table when the read pattern benefits and update semantics are controlled
4. Keep volatile attributes normalized when duplication would create widespread update inconsistency
5. Create a curated flattened table rather than modifying the raw ingestion layer

Correct Answer: D

Correct Answer

Answer D is correct because normalization avoids repeated updates and inconsistent duplicated values. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when a one-to-many relationship could multiply rows and silently change measures. Specifically, grain definition prevents accidental row multiplication during flattening, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the flattening step might duplicate facts due to nonunique join keys. Specifically, reconciliation detects unintended amplification before publication, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when queries repeatedly join the same stable small dimension and low-latency serving is prioritized. Specifically, selective denormalization can reduce repeated join work when the duplication tradeoff is acceptable, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when consumers need simplified analytics but the raw source representation must remain available for replay. Specifically, a curated layer can denormalize for use while preserving raw lineage, which does not resolve the decisive condition in this scenario.

Question 23

A data engineer must correct a design for a customer-analytics environment. The decisive requirement is that consumers need simplified analytics but the raw source representation must remain available for replay. Which choice best addresses it?

1. Keep volatile attributes normalized when duplication would create widespread update inconsistency
2. Create a curated flattened table rather than modifying the raw ingestion layer
3. Document the chosen grain before denormalizing one-to-many data
4. Reconcile row counts and measures after the denormalizing join
5. Flatten frequently joined descriptive attributes into the serving table when the read pattern benefits and update semantics are controlled

Correct Answer: B

Correct Answer

Answer B is correct because a curated layer can denormalize for use while preserving raw lineage. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the attribute changes frequently and would be copied into many rows if denormalized. Specifically, normalization avoids repeated updates and inconsistent duplicated values, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when a one-to-many relationship could multiply rows and silently change measures. Specifically, grain definition prevents accidental row multiplication during flattening, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the flattening step might duplicate facts due to nonunique join keys. Specifically, reconciliation detects unintended amplification before publication, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when queries repeatedly join the same stable small dimension and low-latency serving is prioritized. Specifically, selective denormalization can reduce repeated join work when the duplication tradeoff is acceptable, which does not resolve the decisive condition in this scenario.

Question 24

For an internal finance data estate, the organization has fixed the following constraint: a one-to-many relationship could multiply rows and silently change measures. Which action best satisfies the requirement?

1. Reconcile row counts and measures after the denormalizing join
2. Flatten frequently joined descriptive attributes into the serving table when the read pattern benefits and update semantics are controlled
3. Keep volatile attributes normalized when duplication would create widespread update inconsistency
4. Create a curated flattened table rather than modifying the raw ingestion layer
5. Document the chosen grain before denormalizing one-to-many data

Correct Answer: E

Correct Answer

Answer E is correct because grain definition prevents accidental row multiplication during flattening. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the flattening step might duplicate facts due to nonunique join keys. Specifically, reconciliation detects unintended amplification before publication, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when queries repeatedly join the same stable small dimension and low-latency serving is prioritized. Specifically, selective denormalization can reduce repeated join work when the duplication tradeoff is acceptable, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the attribute changes frequently and would be copied into many rows if denormalized. Specifically, normalization avoids repeated updates and inconsistent duplicated values, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when consumers need simplified analytics but the raw source representation must remain available for replay. Specifically, a curated layer can denormalize for use while preserving raw lineage, which does not resolve the decisive condition in this scenario.

Question 25

During an operational design review for a multi-team Fabric deployment, engineers confirm that the flattening step might duplicate facts due to nonunique join keys. What should they do?

1. Create a curated flattened table rather than modifying the raw ingestion layer
2. Document the chosen grain before denormalizing one-to-many data
3. Reconcile row counts and measures after the denormalizing join
4. Flatten frequently joined descriptive attributes into the serving table when the read pattern benefits and update semantics are controlled
5. Keep volatile attributes normalized when duplication would create widespread update inconsistency

Correct Answer: C

Correct Answer

Answer C is correct because reconciliation detects unintended amplification before publication. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when consumers need simplified analytics but the raw source representation must remain available for replay. Specifically, a curated layer can denormalize for use while preserving raw lineage, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when a one-to-many relationship could multiply rows and silently change measures. Specifically, grain definition prevents accidental row multiplication during flattening, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when queries repeatedly join the same stable small dimension and low-latency serving is prioritized. Specifically, selective denormalization can reduce repeated join work when the duplication tradeoff is acceptable, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the attribute changes frequently and would be copied into many rows if denormalized. Specifically, normalization avoids repeated updates and inconsistent duplicated values, which does not resolve the decisive condition in this scenario.

Question 26

After a recent change in a real-time telemetry service, the team determines that the summary target is one row per store per day while source events are transaction-level. Which implementation should be selected?

1. Aggregate to the exact reporting grain before writing the summary table
2. Use event-time windows for time-bucketed streaming measures
3. Keep additive and nonadditive measures separate in aggregate design
4. Pre-aggregate very high-volume detail only when drill-through detail remains available elsewhere
5. Validate group keys for null or malformed values before aggregation

Correct Answer: A

Correct Answer

Answer A is correct because aggregation should match the declared store-day grain. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer B is incorrect because this action is appropriate when the metric is defined by when events occurred rather than when the processor happened to receive them. Specifically, event-time windows align streaming aggregation to event timestamps, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when summing balances or percentages across unrelated groups would produce invalid business results. Specifically, aggregate logic must respect each measure’s mathematical behavior, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the dashboard needs fast summaries but investigators still need raw events. Specifically, summary tables can accelerate analytics while a lower-grain source preserves detail, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when invalid keys would collapse unrelated records into an ambiguous null group. Specifically, key validation prevents bad group membership from distorting aggregates, which does not resolve the decisive condition in this scenario.

Question 27

A Fabric engineering team is reviewing a global manufacturing data product. The metric is defined by when events occurred rather than when the processor happened to receive them Which action is most appropriate?

1. Pre-aggregate very high-volume detail only when drill-through detail remains available elsewhere
2. Validate group keys for null or malformed values before aggregation
3. Aggregate to the exact reporting grain before writing the summary table
4. Use event-time windows for time-bucketed streaming measures
5. Keep additive and nonadditive measures separate in aggregate design

Correct Answer: D

Correct Answer

Answer D is correct because event-time windows align streaming aggregation to event timestamps. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the dashboard needs fast summaries but investigators still need raw events. Specifically, summary tables can accelerate analytics while a lower-grain source preserves detail, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when invalid keys would collapse unrelated records into an ambiguous null group. Specifically, key validation prevents bad group membership from distorting aggregates, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the summary target is one row per store per day while source events are transaction-level. Specifically, aggregation should match the declared store-day grain, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when summing balances or percentages across unrelated groups would produce invalid business results. Specifically, aggregate logic must respect each measure’s mathematical behavior, which does not resolve the decisive condition in this scenario.

Question 28

A data engineer must correct a design for a governed self-service analytics domain. The decisive requirement is that summing balances or percentages across unrelated groups would produce invalid business results. Which choice best addresses it?

1. Use event-time windows for time-bucketed streaming measures
2. Keep additive and nonadditive measures separate in aggregate design
3. Pre-aggregate very high-volume detail only when drill-through detail remains available elsewhere
4. Validate group keys for null or malformed values before aggregation
5. Aggregate to the exact reporting grain before writing the summary table

Correct Answer: B

Correct Answer

Answer B is correct because aggregate logic must respect each measure’s mathematical behavior. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when the metric is defined by when events occurred rather than when the processor happened to receive them. Specifically, event-time windows align streaming aggregation to event timestamps, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the dashboard needs fast summaries but investigators still need raw events. Specifically, summary tables can accelerate analytics while a lower-grain source preserves detail, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when invalid keys would collapse unrelated records into an ambiguous null group. Specifically, key validation prevents bad group membership from distorting aggregates, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the summary target is one row per store per day while source events are transaction-level. Specifically, aggregation should match the declared store-day grain, which does not resolve the decisive condition in this scenario.

Question 29

For a financial reporting workspace, the organization has fixed the following constraint: the dashboard needs fast summaries but investigators still need raw events. Which action best satisfies the requirement?

1. Validate group keys for null or malformed values before aggregation
2. Aggregate to the exact reporting grain before writing the summary table
3. Use event-time windows for time-bucketed streaming measures
4. Keep additive and nonadditive measures separate in aggregate design
5. Pre-aggregate very high-volume detail only when drill-through detail remains available elsewhere

Correct Answer: E

Correct Answer

Answer E is correct because summary tables can accelerate analytics while a lower-grain source preserves detail. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when invalid keys would collapse unrelated records into an ambiguous null group. Specifically, key validation prevents bad group membership from distorting aggregates, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the summary target is one row per store per day while source events are transaction-level. Specifically, aggregation should match the declared store-day grain, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the metric is defined by when events occurred rather than when the processor happened to receive them. Specifically, event-time windows align streaming aggregation to event timestamps, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when summing balances or percentages across unrelated groups would produce invalid business results. Specifically, aggregate logic must respect each measure’s mathematical behavior, which does not resolve the decisive condition in this scenario.

Question 30

During an operational design review for a healthcare operations workspace, engineers confirm that invalid keys would collapse unrelated records into an ambiguous null group. What should they do?

1. Keep additive and nonadditive measures separate in aggregate design
2. Pre-aggregate very high-volume detail only when drill-through detail remains available elsewhere
3. Validate group keys for null or malformed values before aggregation
4. Aggregate to the exact reporting grain before writing the summary table
5. Use event-time windows for time-bucketed streaming measures

Correct Answer: C

Correct Answer

Answer C is correct because key validation prevents bad group membership from distorting aggregates. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when summing balances or percentages across unrelated groups would produce invalid business results. Specifically, aggregate logic must respect each measure’s mathematical behavior, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the dashboard needs fast summaries but investigators still need raw events. Specifically, summary tables can accelerate analytics while a lower-grain source preserves detail, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the summary target is one row per store per day while source events are transaction-level. Specifically, aggregation should match the declared store-day grain, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the metric is defined by when events occurred rather than when the processor happened to receive them. Specifically, event-time windows align streaming aggregation to event timestamps, which does not resolve the decisive condition in this scenario.

Question 31

After a recent change in a logistics monitoring solution, the team determines that the source can resend the same logical record and duplicates must not inflate facts. Which implementation should be selected?

1. Deduplicate on a stable business or event key before curated insert
2. Quarantine records missing mandatory keys
3. Allow late events within a defined watermark window
4. Route records beyond the allowed lateness threshold to a reconciliation path
5. Use deterministic survivorship rules when duplicate source records conflict

Correct Answer: A

Correct Answer

Answer A is correct because stable-key deduplication prevents repeated delivery from producing repeated business events. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer B is incorrect because this action is appropriate when rows without required identifiers cannot be safely matched to the target grain. Specifically, quarantine preserves evidence while preventing invalid curated records, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when streaming events can arrive out of order and should still update the correct time window within a tolerated delay. Specifically, watermark/late-event handling balances correctness with bounded state retention, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when very late events should not silently mutate closed reporting periods. Specifically, a separate reconciliation path makes the exceptional correction controlled and auditable, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when two records share the same business key but carry different update timestamps and values. Specifically, a documented precedence rule selects the authoritative version consistently, which does not resolve the decisive condition in this scenario.

Question 32

A Fabric engineering team is reviewing a regional supply-chain platform. Rows without required identifiers cannot be safely matched to the target grain Which action is most appropriate?

1. Route records beyond the allowed lateness threshold to a reconciliation path
2. Use deterministic survivorship rules when duplicate source records conflict
3. Deduplicate on a stable business or event key before curated insert
4. Quarantine records missing mandatory keys
5. Allow late events within a defined watermark window

Correct Answer: D

Correct Answer

Answer D is correct because quarantine preserves evidence while preventing invalid curated records. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when very late events should not silently mutate closed reporting periods. Specifically, a separate reconciliation path makes the exceptional correction controlled and auditable, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when two records share the same business key but carry different update timestamps and values. Specifically, a documented precedence rule selects the authoritative version consistently, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when the source can resend the same logical record and duplicates must not inflate facts. Specifically, stable-key deduplication prevents repeated delivery from producing repeated business events, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when streaming events can arrive out of order and should still update the correct time window within a tolerated delay. Specifically, watermark/late-event handling balances correctness with bounded state retention, which does not resolve the decisive condition in this scenario.

Question 33

A data engineer must correct a design for a shared business intelligence platform. The decisive requirement is that streaming events can arrive out of order and should still update the correct time window within a tolerated delay. Which choice best addresses it?

1. Quarantine records missing mandatory keys
2. Allow late events within a defined watermark window
3. Route records beyond the allowed lateness threshold to a reconciliation path
4. Use deterministic survivorship rules when duplicate source records conflict
5. Deduplicate on a stable business or event key before curated insert

Correct Answer: B

Correct Answer

Answer B is correct because watermark/late-event handling balances correctness with bounded state retention. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when rows without required identifiers cannot be safely matched to the target grain. Specifically, quarantine preserves evidence while preventing invalid curated records, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when very late events should not silently mutate closed reporting periods. Specifically, a separate reconciliation path makes the exceptional correction controlled and auditable, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when two records share the same business key but carry different update timestamps and values. Specifically, a documented precedence rule selects the authoritative version consistently, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when the source can resend the same logical record and duplicates must not inflate facts. Specifically, stable-key deduplication prevents repeated delivery from producing repeated business events, which does not resolve the decisive condition in this scenario.

Question 34

For an enterprise lakehouse program, the organization has fixed the following constraint: very late events should not silently mutate closed reporting periods. Which action best satisfies the requirement?

1. Use deterministic survivorship rules when duplicate source records conflict
2. Deduplicate on a stable business or event key before curated insert
3. Quarantine records missing mandatory keys
4. Allow late events within a defined watermark window
5. Route records beyond the allowed lateness threshold to a reconciliation path

Correct Answer: E

Correct Answer

Answer E is correct because a separate reconciliation path makes the exceptional correction controlled and auditable. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when two records share the same business key but carry different update timestamps and values. Specifically, a documented precedence rule selects the authoritative version consistently, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when the source can resend the same logical record and duplicates must not inflate facts. Specifically, stable-key deduplication prevents repeated delivery from producing repeated business events, which does not resolve the decisive condition in this scenario.

Answer C is incorrect because this action is appropriate when rows without required identifiers cannot be safely matched to the target grain. Specifically, quarantine preserves evidence while preventing invalid curated records, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when streaming events can arrive out of order and should still update the correct time window within a tolerated delay. Specifically, watermark/late-event handling balances correctness with bounded state retention, which does not resolve the decisive condition in this scenario.

Question 35

During an operational design review for a regulated retail analytics platform, engineers confirm that two records share the same business key but carry different update timestamps and values. What should they do?

1. Allow late events within a defined watermark window
2. Route records beyond the allowed lateness threshold to a reconciliation path
3. Use deterministic survivorship rules when duplicate source records conflict
4. Deduplicate on a stable business or event key before curated insert
5. Quarantine records missing mandatory keys

Correct Answer: C

Correct Answer

Answer C is correct because a documented precedence rule selects the authoritative version consistently. This directly addresses the relevant Fabric behavior while preserving the other stated constraints.

Incorrect Answers

Answer A is incorrect because this action is appropriate when streaming events can arrive out of order and should still update the correct time window within a tolerated delay. Specifically, watermark/late-event handling balances correctness with bounded state retention, which does not resolve the decisive condition in this scenario.

Answer B is incorrect because this action is appropriate when very late events should not silently mutate closed reporting periods. Specifically, a separate reconciliation path makes the exceptional correction controlled and auditable, which does not resolve the decisive condition in this scenario.

Answer D is incorrect because this action is appropriate when the source can resend the same logical record and duplicates must not inflate facts. Specifically, stable-key deduplication prevents repeated delivery from producing repeated business events, which does not resolve the decisive condition in this scenario.

Answer E is incorrect because this action is appropriate when rows without required identifiers cannot be safely matched to the target grain. Specifically, quarantine preserves evidence while preventing invalid curated records, which does not resolve the decisive condition in this scenario.