Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

The option Use an SQS FIFO queue with customer-specific message-group IDs addresses a separate condition: messages for each customer must be processed in order while customers process concurrently. FIFO groups preserve per-group ordering while allowing parallel groups. The actual requirement is a message repeatedly fails due to invalid business schema. Recommended corrective action: Redrive failed messages to a configured DLQ after threshold. DLQ isolation prevents unbounded poison-message retry.

Use SQS standard queue with scalable consumers and idempotent handlers would help if a high throughput worker must consume many independent standard messages. Standard queues scale broadly with at-least-once unordered delivery. That is not the symptom described here: a message repeatedly fails due to invalid business schema. The matching response is Redrive failed messages to a configured DLQ after threshold, because dLQ isolation prevents unbounded poison-message retry.

For the alternative failure a consumer receives a message but crashes without deleting it, the control Let visibility timeout expire and process idempotently on redelivery is relevant: unacknowledged messages become available for retry. Here the evidence instead is a message repeatedly fails due to invalid business schema. The selected technical mechanism is Redrive failed messages to a configured DLQ after threshold: dLQ isolation prevents unbounded poison-message retry.

For the alternative failure cache nodes are restarted and session data is lost unexpectedly, the control Choose an appropriately durable session store or Redis configuration with persistence requirements is relevant: cache storage does not automatically guarantee durable state. Here the evidence instead is a web backend repeatedly calculates the same expensive reference data. The selected technical mechanism is Cache those results in ElastiCache with explicit TTL and invalidation: distributed caching avoids repeated expensive backend work.

Implement TTL or event-driven cache invalidation on writes solves a different operational problem where data updates occur but cached values remain stale for hours. Cache consistency depends on invalidation strategy. It does not directly address a web backend repeatedly calculates the same expensive reference data. The case calls for Cache those results in ElastiCache with explicit TTL and invalidation, since distributed caching avoids repeated expensive backend work.

The competing option Apply cache warming/request coalescing and bounded fallback rates would be useful when a sudden cache miss surge overloads RDS. Cache-stampede controls protect the backing database. The present issue is a web backend repeatedly calculates the same expensive reference data; it is more directly addressed by Cache those results in ElastiCache with explicit TTL and invalidation. Distributed caching avoids repeated expensive backend work.

For the alternative failure a web backend repeatedly calculates the same expensive reference data, the control Cache those results in ElastiCache with explicit TTL and invalidation is relevant: distributed caching avoids repeated expensive backend work. Here the evidence instead is cache nodes are restarted and session data is lost unexpectedly. The selected technical mechanism is Choose an appropriately durable session store or Redis configuration with persistence requirements: cache storage does not automatically guarantee durable state.

Implement TTL or event-driven cache invalidation on writes solves a different operational problem where data updates occur but cached values remain stale for hours. Cache consistency depends on invalidation strategy. It does not directly address cache nodes are restarted and session data is lost unexpectedly. The case calls for Choose an appropriately durable session store or Redis configuration with persistence requirements, since cache storage does not automatically guarantee durable state.

The option Store sessions in centralized ElastiCache or DynamoDB rather than instance memory addresses a separate condition: the application must share session state across ALB targets. Shared state enables stateless application placement. The actual requirement is cache nodes are restarted and session data is lost unexpectedly. Choose an appropriately durable session store or Redis configuration with persistence requirements instead: Cache storage does not automatically guarantee durable state.

Store sessions in centralized ElastiCache or DynamoDB rather than instance memory solves a different operational problem where the application must share session state across ALB targets. Shared state enables stateless application placement. It does not directly address data updates occur but cached values remain stale for hours. The case calls for Implement TTL or event-driven cache invalidation on writes, since cache consistency depends on invalidation strategy.

The competing option Choose an appropriately durable session store or Redis configuration with persistence requirements would be useful when cache nodes are restarted and session data is lost unexpectedly. Cache storage does not automatically guarantee durable state. The present issue is data updates occur but cached values remain stale for hours; it is more directly addressed by Implement TTL or event-driven cache invalidation on writes. Cache consistency depends on invalidation strategy.

The option Cache those results in ElastiCache with explicit TTL and invalidation addresses a separate condition: a web backend repeatedly calculates the same expensive reference data. Distributed caching avoids repeated expensive backend work. The actual requirement is data updates occur but cached values remain stale for hours. Recommended corrective action: Implement TTL or event-driven cache invalidation on writes. Cache consistency depends on invalidation strategy.

The competing option Choose an appropriately durable session store or Redis configuration with persistence requirements would be useful when cache nodes are restarted and session data is lost unexpectedly. Cache storage does not automatically guarantee durable state. The present issue is the application must share session state across ALB targets; it is more directly addressed by Store sessions in centralized ElastiCache or DynamoDB rather than instance memory. Shared state enables stateless application placement.

The option Cache those results in ElastiCache with explicit TTL and invalidation addresses a separate condition: a web backend repeatedly calculates the same expensive reference data. Distributed caching avoids repeated expensive backend work. The actual requirement is the application must share session state across ALB targets. Recommended corrective action: Store sessions in centralized ElastiCache or DynamoDB rather than instance memory. Shared state enables stateless application placement.

For the alternative failure data updates occur but cached values remain stale for hours, the control Implement TTL or event-driven cache invalidation on writes is relevant: cache consistency depends on invalidation strategy. Here the evidence instead is the application must share session state across ALB targets. The selected technical mechanism is Store sessions in centralized ElastiCache or DynamoDB rather than instance memory: shared state enables stateless application placement.

The option Implement TTL or event-driven cache invalidation on writes addresses a separate condition: data updates occur but cached values remain stale for hours. Cache consistency depends on invalidation strategy. The actual requirement is a sudden cache miss surge overloads RDS. Recommended corrective action: Apply cache warming/request coalescing and bounded fallback rates. Cache-stampede controls protect the backing database.

For the alternative failure cache nodes are restarted and session data is lost unexpectedly, the control Choose an appropriately durable session store or Redis configuration with persistence requirements is relevant: cache storage does not automatically guarantee durable state. Here the evidence instead is a sudden cache miss surge overloads RDS. The selected technical mechanism is Apply cache warming/request coalescing and bounded fallback rates: cache-stampede controls protect the backing database.

Store sessions in centralized ElastiCache or DynamoDB rather than instance memory solves a different operational problem where the application must share session state across ALB targets. Shared state enables stateless application placement. It does not directly address a sudden cache miss surge overloads RDS. The case calls for Apply cache warming/request coalescing and bounded fallback rates, since cache-stampede controls protect the backing database.

Use SQS visibility timeout, bounded retries and DLQ would help if consumers need to retry transient downstream errors without resubmitting orders. Queue retries separate failed task recovery from request processing. That is not the symptom described here: an API waits for email dispatch before confirming a successful order. The matching response is Enqueue the email event and return the order result independently, because async notification removes email latency from checkout.

For the alternative failure a mobile client must poll for a long-running job result, the control Return a job ID and expose status through a supported query API is relevant: asynchronous job APIs avoid waiting through request timeouts. Here the evidence instead is an API waits for email dispatch before confirming a successful order. The selected technical mechanism is Enqueue the email event and return the order result independently: async notification removes email latency from checkout.

The competing option Enforce business idempotency keys at the destination database would be useful when a single consumer writes a processed event twice after a timeout. At-least-once messaging can redeliver even after a successful side effect. The present issue is an API waits for email dispatch before confirming a successful order; it is more directly addressed by Enqueue the email event and return the order result independently. Async notification removes email latency from checkout.

For the alternative failure an API waits for email dispatch before confirming a successful order, the control Enqueue the email event and return the order result independently is relevant: async notification removes email latency from checkout. Here the evidence instead is a mobile client must poll for a long-running job result. The selected technical mechanism is Return a job ID and expose status through a supported query API: asynchronous job APIs avoid waiting through request timeouts.

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

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 mobile client must poll for a long-running job result. Recommended corrective action: Return a job ID and expose status through a supported query API. Asynchronous job APIs avoid waiting through request timeouts.

Enqueue the email event and return the order result independently solves a different operational problem where an API waits for email dispatch before confirming a successful order. Async notification removes email latency from checkout. It does not directly address consumers need to retry transient downstream errors without resubmitting orders. The case calls for Use SQS visibility timeout, bounded retries and DLQ, since queue retries separate failed task recovery from request processing.

The competing option Return a job ID and expose status through a supported query API would be useful when a mobile client must poll for a long-running job result. Asynchronous job APIs avoid waiting through request timeouts. The present issue is consumers need to retry transient downstream errors without resubmitting orders; it is more directly addressed by Use SQS visibility timeout, bounded retries and DLQ. Queue retries separate failed task recovery from request processing.

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: consumers need to retry transient downstream errors without resubmitting orders. The matching response is Use SQS visibility timeout, bounded retries and DLQ, because queue retries separate failed task recovery from request processing.

The competing option Use SQS visibility timeout, bounded retries and DLQ would be useful when consumers need to retry transient downstream errors without resubmitting orders. Queue retries separate failed task recovery from request processing. The present issue is event delivery to several analytics consumers must not block billing processing; it is more directly addressed by Publish events to SNS/EventBridge with independent targets. Pub/sub decouples subscriber reliability from publisher throughput.

The option Enqueue the email event and return the order result independently addresses a separate condition: an API waits for email dispatch before confirming a successful order. Async notification removes email latency from checkout. The actual requirement is event delivery to several analytics consumers must not block billing processing. Recommended corrective action: Publish events to SNS/EventBridge with independent targets. Pub/sub decouples subscriber reliability from publisher throughput.

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

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.