Certified Data Engineer Associate Practice Test 37
Question 360
At an airport services provider, a transient REST call fails intermittently and the entire overnight job stops without retry or delay. The dataset `experiment_samples` is in scope, and operators cannot perform manual daily launches. Before release, which acceptance test would actually demonstrate that the root problem is controlled?
- Run only a normal, unchanged `experiment_samples` sample and review run attempt count.
- Review a platform-level availability report for `experiment_samples` without testing whether a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.
- Inject a transient first-attempt failure and confirm limited retries succeed; inject a persistent failure to ensure final alert
- Check that the intended configuration exists for `experiment_samples` and that a healthy run succeeded, without inducing the earlier failure.
Explanation
Correct Answer
C:Inject a transient first-attempt failure and confirm limited retries succeed; inject a persistent failure to ensure final alert. This reproduces the scenario-dependent condition, verifies run attempt count, retry intervals, transient error codes, and downstream completion, and directly tests whether a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately is resolved. Observed results, not intent, determine approval.
Incorrect Answers
A:Run only a normal, unchanged `experiment_samples` sample and review run attempt count. A normal sample does not challenge a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.
B:Review a platform-level availability report for `experiment_samples` without testing whether a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately. Aggregate availability does not establish the behavior of affected `experiment_samples` records. It cannot replace the direct exercise: inject a transient first-attempt failure and confirm limited retries succeed; inject a persistent failure to ensure final alert.
D:Check that the intended configuration exists for `experiment_samples` 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 recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.
Question 361
At a digital publishing service, one job must process a variable list of partner feeds and route failures to a review task while successful feeds publish. The dataset `supplier_orders` is in scope, and a failed task must remain visible in run history. What evidence should the engineer collect to establish the cause rather than a coincidental symptom?
- Compare the current configuration and the signed change approval, without source-row evidence
- Correlate per-feed task state, For each iteration results across affected and unaffected `R034-CASE-073` runs.
- Inspect normal-period success metrics for the stated dataset without reproducing the source error
- Review aggregate cluster availability and job completion for `supplier_orders` without correlating the observed error path.
Explanation
Correct Answer
B:Correlate per-feed task state, For each iteration results across affected and unaffected `R034-CASE-073` runs.. By joining per-feed task state, For each iteration results, branch condition, and final published record count across the affected and unaffected conditions, the investigation directly tests the recorded mechanism: a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches. It also sets a measurable baseline for submit a list containing one invalid feed and verify good feeds finish while the failed feed enters review.
Incorrect Answers
A:Compare the current configuration and the signed change approval, without source-row evidence. A desired configuration and approval ticket are not runtime proof. In this case they omit per-feed task state, For each iteration results, branch condition, and final published record count, the direct means of distinguishing a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches.
C: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 a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches. The failing-path per-feed task state, For each iteration results, branch condition, and final published record count has to be correlated before attributing cause.
D:Review aggregate cluster availability and job completion for `supplier_orders` without correlating the observed error path. A successful aggregate platform state can coexist with a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches. This check never observes the affected `supplier_orders` records or their causal path.
Question 362
At a digital publishing service, one job must process a variable list of partner feeds and route failures to a review task while successful feeds publish. The dataset `supplier_orders` is in scope, and a failed task must remain visible in run history. Which platform configuration or data-engineering change is most defensible?
- Use For each task control flow for feed items with conditional downstream handling based on task outcomes
- Run all partner processing manually from the workspace UI; use that approach for `supplier_orders`.
- Copy the job definition for every possible partner name; use that approach for `supplier_orders`.
- Use a single success-only dependency to run both success and failure handlers; use that approach for `supplier_orders`.
Explanation
Correct Answer
A:Use For each task control flow for feed items with conditional downstream handling based on task outcomes. This directly addresses a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches. The design should be accepted only after submit a list containing one invalid feed and verify good feeds finish while the failed feed enters review; the related operational boundary is to allow independent feed outcomes but preserve explicit failure handling and auditability.
Incorrect Answers
B:Run all partner processing manually from the workspace UI; use that approach for `supplier_orders`. Manual orchestration loses repeatable run status and fault isolation. For `supplier_orders`, this cannot remove the causal limitation: a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches.
C:Copy the job definition for every possible partner name; use that approach for `supplier_orders`. Static clones are hard to maintain and do not match the dynamic feed list. For `supplier_orders`, this cannot remove the causal limitation: a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches.
D:Use a single success-only dependency to run both success and failure handlers; use that approach for `supplier_orders`. A success-only edge will skip the failure branch when remediation is needed. For `supplier_orders`, this cannot remove the causal limitation: a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches.
Question 363
At a digital publishing service, one job must process a variable list of partner feeds and route failures to a review task while successful feeds publish. The dataset `supplier_orders` is in scope, and a failed task must remain visible in run history. A teammate proposes: "Use a single success-only dependency to run both success and failure handlers." Which technical limitation is the decisive reason not to approve that specific proposal?
- A success-only edge will skip the failure branch when remediation is needed. The proposal does not repair `supplier_orders`.
- Static clones are hard to maintain and do not match the dynamic feed list. This would apply to another option for `supplier_orders`.
- Manual orchestration loses repeatable run status and fault isolation. This would apply to an alternative change for `supplier_orders`.
- The upstream notebook succeeded, so the task graph and dependent job configuration cannot explain the outcome.
Explanation
Correct Answer
A:A success-only edge will skip the failure branch when remediation is needed. The proposal does not repair `supplier_orders`. This identifies the known limitation of the exact proposed action. A success-only edge will skip the failure branch when remediation is needed. The underlying problem remains a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches; Use For each task control flow for feed items with conditional downstream handling based on task outcomes instead targets that failure.
Incorrect Answers
B:Static clones are hard to maintain and do not match the dynamic feed list. This would apply to another option for `supplier_orders`. This limitation belongs to the different alternative "Copy the job definition for every possible partner name". The stem calls for the specific failure of "Use a single success-only dependency to run both success and failure handlers".
C:Manual orchestration loses repeatable run status and fault isolation. This would apply to an alternative change for `supplier_orders`. This failure applies to the separate proposal "Run all partner processing manually from the workspace UI".
D:The upstream notebook succeeded, so the task graph and dependent job configuration cannot explain the outcome. The case provides a concrete failing data or control path; a mere alternate theory does not address a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches.
Question 364
At a digital publishing service, one job must process a variable list of partner feeds and route failures to a review task while successful feeds publish. The dataset `supplier_orders` is in scope, and a failed task must remain visible in run history. What risk-and-cost compromise should the owner accept instead of the proposed shortcuts?
- Allow independent feed outcomes but preserve explicit failure handling and auditability
- Copy the job definition for every possible partner name
- Run all partner processing manually from the workspace UI
- Use a single success-only dependency to run both success and failure handlers; monitor results only after launch of `supplier_orders`.
Explanation
Correct Answer
A:Allow independent feed outcomes but preserve explicit failure handling and auditability. This explicitly bounds the compromise while still addressing a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches. Acceptance relies on submit a list containing one invalid feed and verify good feeds finish while the failed feed enters review rather than simply declaring the change complete.
Incorrect Answers
B:Copy the job definition for every possible partner name. Static clones are hard to maintain and do not match the dynamic feed list. Monitoring after deployment does not make this approach a safe bounded tradeoff for `supplier_orders`.
C:Run all partner processing manually from the workspace UI. Manual orchestration loses repeatable run status and fault isolation. Monitoring after deployment does not make this approach a safe bounded tradeoff for `supplier_orders`.
D:Use a single success-only dependency to run both success and failure handlers; monitor results only after launch of `supplier_orders`. A success-only edge will skip the failure branch when remediation is needed. Monitoring after deployment does not make this approach a safe bounded tradeoff for `supplier_orders`.
Question 365
At a digital publishing service, one job must process a variable list of partner feeds and route failures to a review task while successful feeds publish. The dataset `supplier_orders` is in scope, and a failed task must remain visible in run history. Which direct test could falsify the proposed fix instead of only confirming deployment?
- Check that the intended configuration exists for `supplier_orders` and that a healthy run succeeded, without inducing the earlier failure.
- Submit a list containing one invalid feed and verify good feeds finish while the failed feed enters review
- Review a platform-level availability report for `supplier_orders` without testing whether a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches.
- Run only a normal, unchanged `supplier_orders` sample and review per-feed task state.
Explanation
Correct Answer
B:Submit a list containing one invalid feed and verify good feeds finish while the failed feed enters review. This reproduces the scenario-dependent condition, verifies per-feed task state, For each iteration results, branch condition, and final published record count, and directly tests whether a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches 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 a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches.
C:Review a platform-level availability report for `supplier_orders` without testing whether a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches. Aggregate availability does not establish the behavior of affected `supplier_orders` records. It cannot replace the direct exercise: submit a list containing one invalid feed and verify good feeds finish while the failed feed enters review.
D:Run only a normal, unchanged `supplier_orders` sample and review per-feed task state. A normal sample does not challenge a fixed single notebook invocation cannot cleanly model a variable number of independent feed tasks and branches.
Question 366
At a medical device company, a transient REST call fails intermittently and the entire overnight job stops without retry or delay. The dataset `research_events` is in scope, and operators cannot perform manual daily launches. Which correlated observation is the strongest basis for the change decision?
- Correlate run attempt count, retry intervals across affected and unaffected `R034-CASE-074` runs.
- Inspect normal-period success metrics for the stated dataset without reproducing the source error
- Compare the current configuration and the signed change approval, without source-row evidence
- Review completed run status and aggregate cluster health without record-level correlation
Explanation
Correct Answer
A:Correlate run attempt count, retry intervals across affected and unaffected `R034-CASE-074` runs.. By joining run attempt count, retry intervals, transient error codes, and downstream completion across the affected and unaffected conditions, the investigation directly tests the recorded mechanism: a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately. It also sets a measurable baseline for inject a transient first-attempt failure and confirm limited retries succeed; inject a persistent failure to ensure final alert.
Incorrect Answers
B: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 a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately. The failing-path run attempt count, retry intervals, transient error codes, and downstream completion has to be correlated before attributing cause.
C:Compare the current configuration and the signed change approval, without source-row evidence. A desired configuration and approval ticket are not runtime proof. In this case they omit run attempt count, retry intervals, transient error codes, and downstream completion, the direct means of distinguishing a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.
D:Review completed run status and aggregate cluster health without record-level correlation. A successful aggregate platform state can coexist with a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately. This check never observes the affected `research_events` records or their causal path.
Question 367
At a medical device company, a transient REST call fails intermittently and the entire overnight job stops without retry or delay. The dataset `research_events` is in scope, and operators cannot perform manual daily launches. What implementation should the engineer select for the failing workflow?
- Configure bounded retries with sensible retry intervals on the failing Lakeflow Jobs task and retain failure visibility
- Retry every unrelated downstream task without isolating the failing call; use that approach for `research_events`.
- Add unbounded recursive retries inside the notebook code; use that approach for `research_events`.
- Mark the task successful after any HTTP error; use that approach for `research_events`.
Explanation
Correct Answer
A:Configure bounded retries with sensible retry intervals on the failing Lakeflow Jobs task and retain failure visibility. This directly addresses a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately. The design should be accepted only after inject a transient first-attempt failure and confirm limited retries succeed; inject a persistent failure to ensure final alert; the related operational boundary is to tolerate a finite number of transient failures while limiting delay and exposing persistent outages.
Incorrect Answers
B:Retry every unrelated downstream task without isolating the failing call; use that approach for `research_events`. Broad reruns waste work and obscure the original transient failure. For `research_events`, this cannot remove the causal limitation: a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.
C:Add unbounded recursive retries inside the notebook code; use that approach for `research_events`. Unbounded retries can hide persistent outages and consume compute indefinitely. For `research_events`, this cannot remove the causal limitation: a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.
D:Mark the task successful after any HTTP error; use that approach for `research_events`. Treating failure as success allows dependent tasks to use incomplete data. For `research_events`, this cannot remove the causal limitation: a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.
Question 368
At a medical device company, a transient REST call fails intermittently and the entire overnight job stops without retry or delay. The dataset `research_events` is in scope, and operators cannot perform manual daily launches. A teammate proposes: "Add unbounded recursive retries inside the notebook code." Which technical limitation is the decisive reason not to approve that specific proposal?
- The upstream notebook succeeded, so the task graph and dependent job configuration cannot explain the outcome.
- Broad reruns waste work and obscure the original transient failure. This would apply to another option for `research_events`.
- Treating failure as success allows dependent tasks to use incomplete data. This would apply to an alternative change for `research_events`.
- Unbounded retries can hide persistent outages and consume compute indefinitely. The proposal does not repair `research_events`.
Explanation
Correct Answer
D:Unbounded retries can hide persistent outages and consume compute indefinitely. The proposal does not repair `research_events`. This identifies the known limitation of the exact proposed action. Unbounded retries can hide persistent outages and consume compute indefinitely. The underlying problem remains a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately; Configure bounded retries with sensible retry intervals on the failing Lakeflow Jobs task and retain failure visibility instead targets that failure.
Incorrect Answers
A:The upstream notebook succeeded, so the task graph and dependent job configuration cannot explain the outcome. The case provides a concrete failing data or control path; a mere alternate theory does not address a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.
B:Broad reruns waste work and obscure the original transient failure. This would apply to another option for `research_events`. This limitation belongs to the different alternative "Retry every unrelated downstream task without isolating the failing call". The stem calls for the specific failure of "Add unbounded recursive retries inside the notebook code".
C:Treating failure as success allows dependent tasks to use incomplete data. This would apply to an alternative change for `research_events`. This failure applies to the separate proposal "Mark the task successful after any HTTP error".
Question 369
At a medical device company, a transient REST call fails intermittently and the entire overnight job stops without retry or delay. The dataset `research_events` is in scope, and operators cannot perform manual daily launches. Which decision preserves the stated data contract while keeping the change scope proportionate?
- Tolerate a finite number of transient failures while limiting delay and exposing persistent outages
- Add unbounded recursive retries inside the notebook code
- Retry every unrelated downstream task without isolating the failing call
- Mark the task successful after any HTTP error
Explanation
Correct Answer
A:Tolerate a finite number of transient failures while limiting delay and exposing persistent outages. This explicitly bounds the compromise while still addressing a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately. Acceptance relies on inject a transient first-attempt failure and confirm limited retries succeed; inject a persistent failure to ensure final alert rather than simply declaring the change complete.
Incorrect Answers
B:Add unbounded recursive retries inside the notebook code. Unbounded retries can hide persistent outages and consume compute indefinitely. Monitoring after deployment does not make this approach a safe bounded tradeoff for `research_events`.
C:Retry every unrelated downstream task without isolating the failing call. Broad reruns waste work and obscure the original transient failure. Monitoring after deployment does not make this approach a safe bounded tradeoff for `research_events`.
D:Mark the task successful after any HTTP error. Treating failure as success allows dependent tasks to use incomplete data. Monitoring after deployment does not make this approach a safe bounded tradeoff for `research_events`.
Question 370
At a medical device company, a transient REST call fails intermittently and the entire overnight job stops without retry or delay. The dataset `research_events` is in scope, and operators cannot perform manual daily launches. What verification provides evidence of correct behavior under the original adverse condition?
- Run only a normal, unchanged `research_events` sample and review run attempt count.
- Review a platform-level availability report for `research_events` without testing whether a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.
- Check that the intended configuration exists for `research_events` and that a healthy run succeeded, without inducing the earlier failure.
- Inject a transient first-attempt failure and confirm limited retries succeed; inject a persistent failure to ensure final alert
Explanation
Correct Answer
D:Inject a transient first-attempt failure and confirm limited retries succeed; inject a persistent failure to ensure final alert. This reproduces the scenario-dependent condition, verifies run attempt count, retry intervals, transient error codes, and downstream completion, and directly tests whether a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately is resolved. Observed results, not intent, determine approval.
Incorrect Answers
A:Run only a normal, unchanged `research_events` sample and review run attempt count. A normal sample does not challenge a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.
B:Review a platform-level availability report for `research_events` without testing whether a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately. Aggregate availability does not establish the behavior of affected `research_events` records. It cannot replace the direct exercise: inject a transient first-attempt failure and confirm limited retries succeed; inject a persistent failure to ensure final alert.
C:Check that the intended configuration exists for `research_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 a recoverable transient error should be retried within a controlled budget instead of aborting the whole DAG immediately.