Certified Data Engineer Associate Practice Test 56
Question 550
At a regional banking group, a job alternates between running and timing out, but alerts consider only final task success and miss the growing tail latency. The dataset `patient_visits` is in scope, and fault analysis must preserve actual stage-level evidence. What verification provides evidence of correct behavior under the original adverse condition?
- Run only a normal, unchanged `patient_visits` sample and review run-time distribution.
- Review a platform-level availability report for `patient_visits` without testing whether a final green status does not reveal repeated near-timeout or intermittent task failures.
- Check that the intended configuration exists for `patient_visits` and that a healthy run succeeded, without inducing the earlier failure.
- Inject intermittent delayed tasks and verify history exposes both failures and increasing runtimes
Explanation
Correct Answer
D:Inject intermittent delayed tasks and verify history exposes both failures and increasing runtimes. This reproduces the scenario-dependent condition, verifies run-time distribution, failed-attempt fraction, per-task duration, and retry counts, and directly tests whether a final green status does not reveal repeated near-timeout or intermittent task failures is resolved. Observed results, not intent, determine approval.
Incorrect Answers
A:Run only a normal, unchanged `patient_visits` sample and review run-time distribution. A normal sample does not challenge a final green status does not reveal repeated near-timeout or intermittent task failures.
B:Review a platform-level availability report for `patient_visits` without testing whether a final green status does not reveal repeated near-timeout or intermittent task failures. Aggregate availability does not establish the behavior of affected `patient_visits` records. It cannot replace the direct exercise: inject intermittent delayed tasks and verify history exposes both failures and increasing runtimes.
C:Check that the intended configuration exists for `patient_visits` and that a healthy run succeeded, without inducing the earlier failure. Installed configuration and a healthy run are insufficient to prove the failure mode is gone. The original issue was a final green status does not reveal repeated near-timeout or intermittent task failures.
Question 551
At a census statistics agency, a scheduled gold job is marked skipped because its silver predecessor failed, but the on-call team inspects only the gold notebook. The dataset `courier_events` is in scope, and the cost increase must be justified by better completion times. Which investigation best tests the stated constraint with direct data?
- Correlate run graph statuses, first failed task across affected and unaffected `R034-CASE-111` runs.
- Compare the saved configuration with the signed change ticket for `courier_events` while omitting source and output records.
- Examine only a normal successful run of `courier_events` and trend run graph statuses without recreating the fault.
- Review aggregate cluster availability and job completion for `courier_events` without correlating the observed error path.
Explanation
Correct Answer
A:Correlate run graph statuses, first failed task across affected and unaffected `R034-CASE-111` runs.. By joining run graph statuses, first failed task, upstream exception, and downstream skip reason across the affected and unaffected conditions, the investigation directly tests the recorded mechanism: the gold node never ran; its skipped status is a downstream consequence of an upstream task failure. It also sets a measurable baseline for inject an upstream task exception and confirm the DAG identifies the failure and only dependent nodes skip.
Incorrect Answers
B:Compare the saved configuration with the signed change ticket for `courier_events` while omitting source and output records. A desired configuration and approval ticket are not runtime proof. In this case they omit run graph statuses, first failed task, upstream exception, and downstream skip reason, the direct means of distinguishing the gold node never ran; its skipped status is a downstream consequence of an upstream task failure.
C:Examine only a normal successful run of `courier_events` and trend run graph statuses without recreating the fault. A healthy-run trend can be useful, but it does not expose the gold node never ran; its skipped status is a downstream consequence of an upstream task failure. The failing-path run graph statuses, first failed task, upstream exception, and downstream skip reason has to be correlated before attributing cause.
D:Review aggregate cluster availability and job completion for `courier_events` without correlating the observed error path. A successful aggregate platform state can coexist with the gold node never ran; its skipped status is a downstream consequence of an upstream task failure. This check never observes the affected `courier_events` records or their causal path.
Question 552
At a census statistics agency, a scheduled gold job is marked skipped because its silver predecessor failed, but the on-call team inspects only the gold notebook. The dataset `courier_events` is in scope, and the cost increase must be justified by better completion times. Which option targets the actual technical dependency rather than an incidental symptom?
- Search the gold notebook stack trace despite there being no gold execution; use that approach for `courier_events`.
- Retry only the skipped gold task without repairing upstream silver; use that approach for `courier_events`.
- Use the Lakeflow Jobs DAG view and upstream task error details to trace the first failed dependency
- Change the gold dashboard refresh schedule to an earlier time; use that approach for `courier_events`.
Explanation
Correct Answer
C:Use the Lakeflow Jobs DAG view and upstream task error details to trace the first failed dependency. This directly addresses the gold node never ran; its skipped status is a downstream consequence of an upstream task failure. The design should be accepted only after inject an upstream task exception and confirm the DAG identifies the failure and only dependent nodes skip; the related operational boundary is to repair the causal upstream node before rerunning failed and skipped work.
Incorrect Answers
A:Search the gold notebook stack trace despite there being no gold execution; use that approach for `courier_events`. A skipped task has no failed execution trace to explain the upstream error. For `courier_events`, this cannot remove the causal limitation: the gold node never ran; its skipped status is a downstream consequence of an upstream task failure.
B:Retry only the skipped gold task without repairing upstream silver; use that approach for `courier_events`. The dependency has not produced valid input and will block or invalidate the result. For `courier_events`, this cannot remove the causal limitation: the gold node never ran; its skipped status is a downstream consequence of an upstream task failure.
D:Change the gold dashboard refresh schedule to an earlier time; use that approach for `courier_events`. A schedule change does not repair the failed predecessor in the DAG. For `courier_events`, this cannot remove the causal limitation: the gold node never ran; its skipped status is a downstream consequence of an upstream task failure.
Question 553
At a census statistics agency, a scheduled gold job is marked skipped because its silver predecessor failed, but the on-call team inspects only the gold notebook. The dataset `courier_events` is in scope, and the cost increase must be justified by better completion times. A teammate proposes: "Change the gold dashboard refresh schedule to an earlier time." Which technical limitation is the decisive reason not to approve that specific proposal?
- The task is waiting for its next schedule; Spark stage metrics and task failure records are irrelevant.
- A skipped task has no failed execution trace to explain the upstream error. This would apply to another option for `courier_events`.
- The dependency has not produced valid input and will block or invalidate the result. This would apply to an alternative change for `courier_events`.
- A schedule change does not repair the failed predecessor in the DAG. The proposal does not repair `courier_events`.
Explanation
Correct Answer
D:A schedule change does not repair the failed predecessor in the DAG. The proposal does not repair `courier_events`. This identifies the known limitation of the exact proposed action. A schedule change does not repair the failed predecessor in the DAG. The underlying problem remains the gold node never ran; its skipped status is a downstream consequence of an upstream task failure; Use the Lakeflow Jobs DAG view and upstream task error details to trace the first failed dependency instead targets that failure.
Incorrect Answers
A:The task is waiting for its next schedule; Spark stage metrics and task failure records are irrelevant. The case provides a concrete failing data or control path; a mere alternate theory does not address the gold node never ran; its skipped status is a downstream consequence of an upstream task failure.
B:A skipped task has no failed execution trace to explain the upstream error. This would apply to another option for `courier_events`. This limitation belongs to the different alternative "Search the gold notebook stack trace despite there being no gold execution". The stem calls for the specific failure of "Change the gold dashboard refresh schedule to an earlier time".
C:The dependency has not produced valid input and will block or invalidate the result. This would apply to an alternative change for `courier_events`. This failure applies to the separate proposal "Retry only the skipped gold task without repairing upstream silver".
Question 554
At a census statistics agency, a scheduled gold job is marked skipped because its silver predecessor failed, but the on-call team inspects only the gold notebook. The dataset `courier_events` is in scope, and the cost increase must be justified by better completion times. What operational boundary should be documented for approval?
- Retry only the skipped gold task without repairing upstream silver; monitor results only after launch of `courier_events`.
- Change the gold dashboard refresh schedule to an earlier time; monitor results only after launch of `courier_events`.
- Search the gold notebook stack trace despite there being no gold execution; monitor results only after launch of `courier_events`.
- Repair the causal upstream node before rerunning failed and skipped work
Explanation
Correct Answer
D:Repair the causal upstream node before rerunning failed and skipped work. This explicitly bounds the compromise while still addressing the gold node never ran; its skipped status is a downstream consequence of an upstream task failure. Acceptance relies on inject an upstream task exception and confirm the DAG identifies the failure and only dependent nodes skip rather than simply declaring the change complete.
Incorrect Answers
A:Retry only the skipped gold task without repairing upstream silver; monitor results only after launch of `courier_events`. The dependency has not produced valid input and will block or invalidate the result. Monitoring after deployment does not make this approach a safe bounded tradeoff for `courier_events`.
B:Change the gold dashboard refresh schedule to an earlier time; monitor results only after launch of `courier_events`. A schedule change does not repair the failed predecessor in the DAG. Monitoring after deployment does not make this approach a safe bounded tradeoff for `courier_events`.
C:Search the gold notebook stack trace despite there being no gold execution; monitor results only after launch of `courier_events`. A skipped task has no failed execution trace to explain the upstream error. Monitoring after deployment does not make this approach a safe bounded tradeoff for `courier_events`.
Question 555
At a census statistics agency, a scheduled gold job is marked skipped because its silver predecessor failed, but the on-call team inspects only the gold notebook. The dataset `courier_events` is in scope, and the cost increase must be justified by better completion times. Which validation should be required in the release record?
- Check that the intended configuration exists for `courier_events` and that a healthy run succeeded, without inducing the earlier failure.
- Inject an upstream task exception and confirm the DAG identifies the failure and only dependent nodes skip
- Run only a normal, unchanged `courier_events` sample and review run graph statuses.
- Review a platform-level availability report for `courier_events` without testing whether the gold node never ran; its skipped status is a downstream consequence of an upstream task failure.
Explanation
Correct Answer
B:Inject an upstream task exception and confirm the DAG identifies the failure and only dependent nodes skip. This reproduces the scenario-dependent condition, verifies run graph statuses, first failed task, upstream exception, and downstream skip reason, and directly tests whether the gold node never ran; its skipped status is a downstream consequence of an upstream task failure is resolved. Observed results, not intent, determine approval.
Incorrect Answers
A:Check that the intended configuration exists for `courier_events` and that a healthy run succeeded, without inducing the earlier failure. Installed configuration and a healthy run are insufficient to prove the failure mode is gone. The original issue was the gold node never ran; its skipped status is a downstream consequence of an upstream task failure.
C:Run only a normal, unchanged `courier_events` sample and review run graph statuses. A normal sample does not challenge the gold node never ran; its skipped status is a downstream consequence of an upstream task failure.
D:Review a platform-level availability report for `courier_events` without testing whether the gold node never ran; its skipped status is a downstream consequence of an upstream task failure. Aggregate availability does not establish the behavior of affected `courier_events` records. It cannot replace the direct exercise: inject an upstream task exception and confirm the DAG identifies the failure and only dependent nodes skip.
Question 556
At a tax accounting service, one shuffle stage has a single task reading gigabytes more data than its peers and dominates total execution time. The dataset `supplier_orders` is in scope, and the proposed fix needs before-and-after measurements. Before choosing a remedy, which investigation actually distinguishes the failure mechanism from a green dashboard?
- Inspect normal-period success metrics for the stated dataset without reproducing the source error
- Review completed run status and aggregate cluster health without record-level correlation
- Compare the saved configuration with the signed change ticket for `supplier_orders` while omitting source and output records.
- Correlate max versus median shuffle read, stage task times across affected and unaffected `R034-CASE-112` runs.
Explanation
Correct Answer
D:Correlate max versus median shuffle read, stage task times across affected and unaffected `R034-CASE-112` runs.. By joining max versus median shuffle read, stage task times, spill bytes, and heavy key counts across the affected and unaffected conditions, the investigation directly tests the recorded mechanism: one heavily skewed key concentrates work in a straggling shuffle partition. It also sets a measurable baseline for apply the selected partitioning change and compare longest task time, spill and aggregate correctness.
Incorrect Answers
A:Inspect normal-period success metrics for the stated dataset without reproducing the source error. A healthy-run trend can be useful, but it does not expose one heavily skewed key concentrates work in a straggling shuffle partition. The failing-path max versus median shuffle read, stage task times, spill bytes, and heavy key counts has to be correlated before attributing cause.
B:Review completed run status and aggregate cluster health without record-level correlation. A successful aggregate platform state can coexist with one heavily skewed key concentrates work in a straggling shuffle partition. This check never observes the affected `supplier_orders` records or their causal path.
C:Compare the saved configuration with the signed change ticket for `supplier_orders` while omitting source and output records. A desired configuration and approval ticket are not runtime proof. In this case they omit max versus median shuffle read, stage task times, spill bytes, and heavy key counts, the direct means of distinguishing one heavily skewed key concentrates work in a straggling shuffle partition.
Question 557
At a tax accounting service, one shuffle stage has a single task reading gigabytes more data than its peers and dominates total execution time. The dataset `supplier_orders` is in scope, and the proposed fix needs before-and-after measurements. Which implementation best resolves the stated defect without breaking the business constraint?
- Ignore task-level metrics and double all executors permanently; use that approach for `supplier_orders`.
- Increase only driver memory and leave the skewed execution plan unchanged; use that approach for `supplier_orders`.
- Diagnose key skew in Spark UI and apply a bounded skew-aware partitioning or salting strategy for the affected operation
- Reduce the shuffle partition count sharply across the whole application; use that approach for `supplier_orders`.
Explanation
Correct Answer
C:Diagnose key skew in Spark UI and apply a bounded skew-aware partitioning or salting strategy for the affected operation. This directly addresses one heavily skewed key concentrates work in a straggling shuffle partition. The design should be accepted only after apply the selected partitioning change and compare longest task time, spill and aggregate correctness; the related operational boundary is to target the skewed operation instead of scaling the whole application without evidence.
Incorrect Answers
A:Ignore task-level metrics and double all executors permanently; use that approach for `supplier_orders`. Additional idle executors do not split one skewed key and inflate cost. For `supplier_orders`, this cannot remove the causal limitation: one heavily skewed key concentrates work in a straggling shuffle partition.
B:Increase only driver memory and leave the skewed execution plan unchanged; use that approach for `supplier_orders`. Driver memory does not redistribute an oversized executor-side shuffle partition. For `supplier_orders`, this cannot remove the causal limitation: one heavily skewed key concentrates work in a straggling shuffle partition.
D:Reduce the shuffle partition count sharply across the whole application; use that approach for `supplier_orders`. Larger shuffle partitions can worsen stragglers and disk spill. For `supplier_orders`, this cannot remove the causal limitation: one heavily skewed key concentrates work in a straggling shuffle partition.
Question 558
At a tax accounting service, one shuffle stage has a single task reading gigabytes more data than its peers and dominates total execution time. The dataset `supplier_orders` is in scope, and the proposed fix needs before-and-after measurements. A teammate proposes: "Reduce the shuffle partition count sharply across the whole application." Which technical limitation is the decisive reason not to approve that specific proposal?
- Driver memory does not redistribute an oversized executor-side shuffle partition. This would apply to another option for `supplier_orders`.
- Additional idle executors do not split one skewed key and inflate cost. This would apply to an alternative change for `supplier_orders`.
- Larger shuffle partitions can worsen stragglers and disk spill. The proposal does not repair `supplier_orders`.
- The task is waiting for its next schedule; Spark stage metrics and task failure records are irrelevant.
Explanation
Correct Answer
C:Larger shuffle partitions can worsen stragglers and disk spill. The proposal does not repair `supplier_orders`. This identifies the known limitation of the exact proposed action. Larger shuffle partitions can worsen stragglers and disk spill. The underlying problem remains one heavily skewed key concentrates work in a straggling shuffle partition; Diagnose key skew in Spark UI and apply a bounded skew-aware partitioning or salting strategy for the affected operation instead targets that failure.
Incorrect Answers
A:Driver memory does not redistribute an oversized executor-side shuffle partition. This would apply to another option for `supplier_orders`. This limitation belongs to the different alternative "Increase only driver memory and leave the skewed execution plan unchanged". The stem calls for the specific failure of "Reduce the shuffle partition count sharply across the whole application".
B:Additional idle executors do not split one skewed key and inflate cost. This would apply to an alternative change for `supplier_orders`. This failure applies to the separate proposal "Ignore task-level metrics and double all executors permanently".
D:The task is waiting for its next schedule; Spark stage metrics and task failure records are irrelevant. The case provides a concrete failing data or control path; a mere alternate theory does not address one heavily skewed key concentrates work in a straggling shuffle partition.
Question 559
At a tax accounting service, one shuffle stage has a single task reading gigabytes more data than its peers and dominates total execution time. The dataset `supplier_orders` is in scope, and the proposed fix needs before-and-after measurements. Which bounded tradeoff would preserve the core outcome and control operational risk?
- Target the skewed operation instead of scaling the whole application without evidence
- Increase only driver memory and leave the skewed execution plan unchanged
- Ignore task-level metrics and double all executors permanently
- Reduce the shuffle partition count sharply across the whole application; monitor results only after launch of `supplier_orders`.
Explanation
Correct Answer
A:Target the skewed operation instead of scaling the whole application without evidence. This explicitly bounds the compromise while still addressing one heavily skewed key concentrates work in a straggling shuffle partition. Acceptance relies on apply the selected partitioning change and compare longest task time, spill and aggregate correctness rather than simply declaring the change complete.
Incorrect Answers
B:Increase only driver memory and leave the skewed execution plan unchanged. Driver memory does not redistribute an oversized executor-side shuffle partition. Monitoring after deployment does not make this approach a safe bounded tradeoff for `supplier_orders`.
C:Ignore task-level metrics and double all executors permanently. Additional idle executors do not split one skewed key and inflate cost. Monitoring after deployment does not make this approach a safe bounded tradeoff for `supplier_orders`.
D:Reduce the shuffle partition count sharply across the whole application; monitor results only after launch of `supplier_orders`. Larger shuffle partitions can worsen stragglers and disk spill. Monitoring after deployment does not make this approach a safe bounded tradeoff for `supplier_orders`.
Question 560
At a tax accounting service, one shuffle stage has a single task reading gigabytes more data than its peers and dominates total execution time. The dataset `supplier_orders` is in scope, and the proposed fix needs before-and-after measurements. Before release, which acceptance test would actually demonstrate that the root problem is controlled?
- Check that the intended configuration exists for `supplier_orders` and that a healthy run succeeded, without inducing the earlier failure.
- Apply the selected partitioning change and compare longest task time, spill and aggregate correctness
- Review a platform-level availability report for `supplier_orders` without testing whether one heavily skewed key concentrates work in a straggling shuffle partition.
- Run only a normal, unchanged `supplier_orders` sample and review max versus median shuffle read.
Explanation
Correct Answer
B:Apply the selected partitioning change and compare longest task time, spill and aggregate correctness. This reproduces the scenario-dependent condition, verifies max versus median shuffle read, stage task times, spill bytes, and heavy key counts, and directly tests whether one heavily skewed key concentrates work in a straggling shuffle partition is resolved. Observed results, not intent, determine approval.
Incorrect Answers
A:Check that the intended configuration exists for `supplier_orders` and that a healthy run succeeded, without inducing the earlier failure. Installed configuration and a healthy run are insufficient to prove the failure mode is gone. The original issue was one heavily skewed key concentrates work in a straggling shuffle partition.
C:Review a platform-level availability report for `supplier_orders` without testing whether one heavily skewed key concentrates work in a straggling shuffle partition. Aggregate availability does not establish the behavior of affected `supplier_orders` records. It cannot replace the direct exercise: apply the selected partitioning change and compare longest task time, spill and aggregate correctness.
D:Run only a normal, unchanged `supplier_orders` sample and review max versus median shuffle read. A normal sample does not challenge one heavily skewed key concentrates work in a straggling shuffle partition.