Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

The option Use SQS visibility timeout, bounded retries and DLQ addresses a separate condition: consumers need to retry transient downstream errors without resubmitting orders. Queue retries separate failed task recovery from request processing. The actual requirement is a single consumer writes a processed event twice after a timeout. Recommended corrective action: Enforce business idempotency keys at the destination database. At-least-once messaging can redeliver even after a successful side effect.

Publish events to SNS/EventBridge with independent targets would help if event delivery to several analytics consumers must not block billing processing. Pub/sub decouples subscriber reliability from publisher throughput. That is not the symptom described here: a single consumer writes a processed event twice after a timeout. The matching response is Enforce business idempotency keys at the destination database, because at-least-once messaging can redeliver even after a successful side effect.

Return a job ID and expose status through a supported query API solves a different operational problem where a mobile client must poll for a long-running job result. Asynchronous job APIs avoid waiting through request timeouts. It does not directly address a single consumer writes a processed event twice after a timeout. The case calls for Enforce business idempotency keys at the destination database, since at-least-once messaging can redeliver even after a successful side effect.

Add CloudWatch metrics/traces for orchestration tasks would help if an ETL worker has no centralized observation of per-step duration. Task telemetry identifies slow or failing stages. That is not the symptom described here: a daily ETL pipeline has a human-maintained execution order across five dependent tasks. The matching response is Use Step Functions or managed workflow orchestration to encode dependencies, because state machines define deterministic task sequencing.

For the alternative failure an ETL compute step occasionally exceeds available EC2 host capacity, the control Run elastic batch tasks with AWS Batch compute management is relevant: batch adds capacity according to queued tasks. Here the evidence instead is a daily ETL pipeline has a human-maintained execution order across five dependent tasks. The selected technical mechanism is Use Step Functions or managed workflow orchestration to encode dependencies: state machines define deterministic task sequencing.

Emit a versioned data-ready event through EventBridge solves a different operational problem where producers need to notify multiple analytic models of a published dataset. Events notify downstream systems without direct coupling. It does not directly address a daily ETL pipeline has a human-maintained execution order across five dependent tasks. The case calls for Use Step Functions or managed workflow orchestration to encode dependencies, since state machines define deterministic task sequencing.

For the alternative failure a failed processing step must resume without rerunning all completed stages, the control Implement checkpoint-aware state transitions and idempotent task behavior is relevant: durable workflow state enables bounded resumption. Here the evidence instead is an ETL compute step occasionally exceeds available EC2 host capacity. The selected technical mechanism is Run elastic batch tasks with AWS Batch compute management: batch adds capacity according to queued tasks.

The competing option Emit a versioned data-ready event through EventBridge would be useful when producers need to notify multiple analytic models of a published dataset. Events notify downstream systems without direct coupling. The present issue is an ETL compute step occasionally exceeds available EC2 host capacity; it is more directly addressed by Run elastic batch tasks with AWS Batch compute management. Batch adds capacity according to queued tasks.

The option Add CloudWatch metrics/traces for orchestration tasks addresses a separate condition: an ETL worker has no centralized observation of per-step duration. Task telemetry identifies slow or failing stages. The actual requirement is an ETL compute step occasionally exceeds available EC2 host capacity. Recommended corrective action: Run elastic batch tasks with AWS Batch compute management. Batch adds capacity according to queued tasks.

Add CloudWatch metrics/traces for orchestration tasks solves a different operational problem where an ETL worker has no centralized observation of per-step duration. Task telemetry identifies slow or failing stages. It does not directly address producers need to notify multiple analytic models of a published dataset. The case calls for Emit a versioned data-ready event through EventBridge, since events notify downstream systems without direct coupling.

The competing option Implement checkpoint-aware state transitions and idempotent task behavior would be useful when a failed processing step must resume without rerunning all completed stages. Durable workflow state enables bounded resumption. The present issue is producers need to notify multiple analytic models of a published dataset; it is more directly addressed by Emit a versioned data-ready event through EventBridge. Events notify downstream systems without direct coupling.

The option Run elastic batch tasks with AWS Batch compute management addresses a separate condition: an ETL compute step occasionally exceeds available EC2 host capacity. Batch adds capacity according to queued tasks. The actual requirement is producers need to notify multiple analytic models of a published dataset. Recommended corrective action: Emit a versioned data-ready event through EventBridge. Events notify downstream systems without direct coupling.

The option Add CloudWatch metrics/traces for orchestration tasks addresses a separate condition: an ETL worker has no centralized observation of per-step duration. Task telemetry identifies slow or failing stages. The actual requirement is a failed processing step must resume without rerunning all completed stages. Recommended corrective action: Implement checkpoint-aware state transitions and idempotent task behavior. Durable workflow state enables bounded resumption.

Run elastic batch tasks with AWS Batch compute management would help if an ETL compute step occasionally exceeds available EC2 host capacity. Batch adds capacity according to queued tasks. That is not the symptom described here: a failed processing step must resume without rerunning all completed stages. The matching response is Implement checkpoint-aware state transitions and idempotent task behavior, because durable workflow state enables bounded resumption.

For the alternative failure a daily ETL pipeline has a human-maintained execution order across five dependent tasks, the control Use Step Functions or managed workflow orchestration to encode dependencies is relevant: state machines define deterministic task sequencing. Here the evidence instead is a failed processing step must resume without rerunning all completed stages. The selected technical mechanism is Implement checkpoint-aware state transitions and idempotent task behavior: durable workflow state enables bounded resumption.

Use Step Functions or managed workflow orchestration to encode dependencies would help if a daily ETL pipeline has a human-maintained execution order across five dependent tasks. State machines define deterministic task sequencing. That is not the symptom described here: an ETL worker has no centralized observation of per-step duration. The matching response is Add CloudWatch metrics/traces for orchestration tasks, because task telemetry identifies slow or failing stages.

For the alternative failure an ETL compute step occasionally exceeds available EC2 host capacity, the control Run elastic batch tasks with AWS Batch compute management is relevant: batch adds capacity according to queued tasks. Here the evidence instead is an ETL worker has no centralized observation of per-step duration. The selected technical mechanism is Add CloudWatch metrics/traces for orchestration tasks: task telemetry identifies slow or failing stages.

Emit a versioned data-ready event through EventBridge solves a different operational problem where producers need to notify multiple analytic models of a published dataset. Events notify downstream systems without direct coupling. It does not directly address an ETL worker has no centralized observation of per-step duration. The case calls for Add CloudWatch metrics/traces for orchestration tasks, since task telemetry identifies slow or failing stages.

Choose a compatible NLB/TCP health design or expose a valid HTTP health endpoint would help if a service only listens on TCP but ALB performs failing HTTP path checks. Health protocols must match application behavior. That is not the symptom described here: deployments replace instances while ALB is still sending in-flight requests. The matching response is Configure target deregistration delay and graceful shutdown, because connection draining allows in-flight requests to finish.

Use meaningful health checks and readiness validation solves a different operational problem where a newly launched target is marked healthy before dependencies are ready. Healthy routing should wait for service readiness. It does not directly address deployments replace instances while ALB is still sending in-flight requests. The case calls for Configure target deregistration delay and graceful shutdown, since connection draining allows in-flight requests to finish.

The competing option Use ALB host-based routing to separate target groups would be useful when two services require distinct hostnames on the same public listener. Host-header rules map hostnames to backends. The present issue is deployments replace instances while ALB is still sending in-flight requests; it is more directly addressed by Configure target deregistration delay and graceful shutdown. Connection draining allows in-flight requests to finish.

Choose a compatible NLB/TCP health design or expose a valid HTTP health endpoint solves a different operational problem where a service only listens on TCP but ALB performs failing HTTP path checks. Health protocols must match application behavior. It does not directly address a newly launched target is marked healthy before dependencies are ready. The case calls for Use meaningful health checks and readiness validation, since healthy routing should wait for service readiness.

The competing option Use ALB host-based routing to separate target groups would be useful when two services require distinct hostnames on the same public listener. Host-header rules map hostnames to backends. The present issue is a newly launched target is marked healthy before dependencies are ready; it is more directly addressed by Use meaningful health checks and readiness validation. Healthy routing should wait for service readiness.

The option Externalize state and reduce dependence on target stickiness addresses a separate condition: sticky session routing hides failure by keeping users on one bad instance. Stateless design improves replacement resilience. The actual requirement is a newly launched target is marked healthy before dependencies are ready. Recommended corrective action: Use meaningful health checks and readiness validation. Healthy routing should wait for service readiness.

Use meaningful health checks and readiness validation solves a different operational problem where a newly launched target is marked healthy before dependencies are ready. Healthy routing should wait for service readiness. It does not directly address a service only listens on TCP but ALB performs failing HTTP path checks. The case calls for Choose a compatible NLB/TCP health design or expose a valid HTTP health endpoint, since health protocols must match application behavior.

The option Externalize state and reduce dependence on target stickiness addresses a separate condition: sticky session routing hides failure by keeping users on one bad instance. Stateless design improves replacement resilience. The actual requirement is a service only listens on TCP but ALB performs failing HTTP path checks. Choose a compatible NLB/TCP health design or expose a valid HTTP health endpoint instead: Health protocols must match application behavior.

Configure target deregistration delay and graceful shutdown would help if deployments replace instances while ALB is still sending in-flight requests. Connection draining allows in-flight requests to finish. That is not the symptom described here: a service only listens on TCP but ALB performs failing HTTP path checks. The matching response is Choose a compatible NLB/TCP health design or expose a valid HTTP health endpoint, because health protocols must match application behavior.

The competing option Configure target deregistration delay and graceful shutdown would be useful when deployments replace instances while ALB is still sending in-flight requests. Connection draining allows in-flight requests to finish. The present issue is two services require distinct hostnames on the same public listener; it is more directly addressed by Use ALB host-based routing to separate target groups. Host-header rules map hostnames to backends.

The option Externalize state and reduce dependence on target stickiness addresses a separate condition: sticky session routing hides failure by keeping users on one bad instance. Stateless design improves replacement resilience. The actual requirement is two services require distinct hostnames on the same public listener. Recommended corrective action: Use ALB host-based routing to separate target groups. Host-header rules map hostnames to backends.

Use meaningful health checks and readiness validation would help if a newly launched target is marked healthy before dependencies are ready. Healthy routing should wait for service readiness. That is not the symptom described here: two services require distinct hostnames on the same public listener. The matching response is Use ALB host-based routing to separate target groups, because host-header rules map hostnames to backends.

Use ALB host-based routing to separate target groups would help if two services require distinct hostnames on the same public listener. Host-header rules map hostnames to backends. That is not the symptom described here: sticky session routing hides failure by keeping users on one bad instance. The matching response is Externalize state and reduce dependence on target stickiness, because stateless design improves replacement resilience.

For the alternative failure a newly launched target is marked healthy before dependencies are ready, the control Use meaningful health checks and readiness validation is relevant: healthy routing should wait for service readiness. Here the evidence instead is sticky session routing hides failure by keeping users on one bad instance. The selected technical mechanism is Externalize state and reduce dependence on target stickiness: stateless design improves replacement resilience.

Configure target deregistration delay and graceful shutdown solves a different operational problem where deployments replace instances while ALB is still sending in-flight requests. Connection draining allows in-flight requests to finish. It does not directly address sticky session routing hides failure by keeping users on one bad instance. The case calls for Externalize state and reduce dependence on target stickiness, since stateless design improves replacement resilience.