Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

The option Buffer fulfillment messages in SQS with consumers that scale on backlog addresses a separate condition: a burst generates more checkout events than fulfillment can immediately process. Durable queues smooth producer-to-consumer rate mismatch. The actual requirement is a partner requires exactly-once business processing despite at-least-once delivery. Recommended corrective action: Make the fulfillment transaction idempotent using a unique order operation key. Message delivery semantics do not replace business-level deduplication.

Publish the domain event to EventBridge with consumer-specific rules would help if multiple services need a consistent customer-changed event. Event-bus routing reduces direct subscriber coupling. That is not the symptom described here: a partner requires exactly-once business processing despite at-least-once delivery. The matching response is Make the fulfillment transaction idempotent using a unique order operation key, because message delivery semantics do not replace business-level deduplication.

Keep payment result in synchronous transaction and queue fulfillment downstream solves a different operational problem where payment authorization must be strongly synchronous but fulfillment can be delayed. Business-critical confirmation can be separated from optional asynchronous steps. It does not directly address a partner requires exactly-once business processing despite at-least-once delivery. The case calls for Make the fulfillment transaction idempotent using a unique order operation key, since message delivery semantics do not replace business-level deduplication.

Use provisioned concurrency for latency-sensitive functions where justified would help if the API has unpredictable traffic that causes Lambda cold-start latency. Provisioned concurrency prepares execution environments ahead of requests. That is not the symptom described here: the application's idle periods are long and web requests are sporadic. The matching response is Implement Lambda behind API Gateway for request-driven compute when runtime fits, because lambda bills per invocation rather than continuously running servers.

Use EventBridge Scheduler to invoke the target workflow solves a different operational problem where the app must send scheduled notifications every night without an always-on host. Managed schedules trigger tasks without cron servers. It does not directly address the application's idle periods are long and web requests are sporadic. The case calls for Implement Lambda behind API Gateway for request-driven compute when runtime fits, since lambda bills per invocation rather than continuously running servers.

The competing option Accept the job asynchronously and process with Step Functions or AWS Batch would be useful when the request initiates a multi-hour report that cannot finish within API timeout. Asynchronous workflows avoid synchronous request timeouts. The present issue is the application's idle periods are long and web requests are sporadic; it is more directly addressed by Implement Lambda behind API Gateway for request-driven compute when runtime fits. Lambda bills per invocation rather than continuously running servers.

For the alternative failure a public endpoint fails when the only regional backend service is unhealthy, the control Build multi-AZ backend capacity and regional failover as required is relevant: serverless alone does not establish end-to-end resilience. Here the evidence instead is the API has unpredictable traffic that causes Lambda cold-start latency. The selected technical mechanism is Use provisioned concurrency for latency-sensitive functions where justified: provisioned concurrency prepares execution environments ahead of requests.

The competing option Use EventBridge Scheduler to invoke the target workflow would be useful when the app must send scheduled notifications every night without an always-on host. Managed schedules trigger tasks without cron servers. The present issue is the API has unpredictable traffic that causes Lambda cold-start latency; it is more directly addressed by Use provisioned concurrency for latency-sensitive functions where justified. Provisioned concurrency prepares execution environments ahead of requests.

The option Accept the job asynchronously and process with Step Functions or AWS Batch addresses a separate condition: the request initiates a multi-hour report that cannot finish within API timeout. Asynchronous workflows avoid synchronous request timeouts. The actual requirement is the API has unpredictable traffic that causes Lambda cold-start latency. Recommended corrective action: Use provisioned concurrency for latency-sensitive functions where justified. Provisioned concurrency prepares execution environments ahead of requests.

Build multi-AZ backend capacity and regional failover as required solves a different operational problem where a public endpoint fails when the only regional backend service is unhealthy. Serverless alone does not establish end-to-end resilience. It does not directly address the request initiates a multi-hour report that cannot finish within API timeout. The case calls for Accept the job asynchronously and process with Step Functions or AWS Batch, since asynchronous workflows avoid synchronous request timeouts.

The competing option Implement Lambda behind API Gateway for request-driven compute when runtime fits would be useful when the application's idle periods are long and web requests are sporadic. Lambda bills per invocation rather than continuously running servers. The present issue is the request initiates a multi-hour report that cannot finish within API timeout; it is more directly addressed by Accept the job asynchronously and process with Step Functions or AWS Batch. Asynchronous workflows avoid synchronous request timeouts.

Use provisioned concurrency for latency-sensitive functions where justified would help if the API has unpredictable traffic that causes Lambda cold-start latency. Provisioned concurrency prepares execution environments ahead of requests. That is not the symptom described here: the request initiates a multi-hour report that cannot finish within API timeout. The matching response is Accept the job asynchronously and process with Step Functions or AWS Batch, because asynchronous workflows avoid synchronous request timeouts.

The option Accept the job asynchronously and process with Step Functions or AWS Batch addresses a separate condition: the request initiates a multi-hour report that cannot finish within API timeout. Asynchronous workflows avoid synchronous request timeouts. The actual requirement is the app must send scheduled notifications every night without an always-on host. Recommended corrective action: Use EventBridge Scheduler to invoke the target workflow. Managed schedules trigger tasks without cron servers.

Implement Lambda behind API Gateway for request-driven compute when runtime fits would help if the application's idle periods are long and web requests are sporadic. Lambda bills per invocation rather than continuously running servers. That is not the symptom described here: the app must send scheduled notifications every night without an always-on host. The matching response is Use EventBridge Scheduler to invoke the target workflow, because managed schedules trigger tasks without cron servers.

For the alternative failure a public endpoint fails when the only regional backend service is unhealthy, the control Build multi-AZ backend capacity and regional failover as required is relevant: serverless alone does not establish end-to-end resilience. Here the evidence instead is the app must send scheduled notifications every night without an always-on host. The selected technical mechanism is Use EventBridge Scheduler to invoke the target workflow: managed schedules trigger tasks without cron servers.

Accept the job asynchronously and process with Step Functions or AWS Batch would help if the request initiates a multi-hour report that cannot finish within API timeout. Asynchronous workflows avoid synchronous request timeouts. That is not the symptom described here: a public endpoint fails when the only regional backend service is unhealthy. The matching response is Build multi-AZ backend capacity and regional failover as required, because serverless alone does not establish end-to-end resilience.

For the alternative failure the app must send scheduled notifications every night without an always-on host, the control Use EventBridge Scheduler to invoke the target workflow is relevant: managed schedules trigger tasks without cron servers. Here the evidence instead is a public endpoint fails when the only regional backend service is unhealthy. The selected technical mechanism is Build multi-AZ backend capacity and regional failover as required: serverless alone does not establish end-to-end resilience.

Use provisioned concurrency for latency-sensitive functions where justified solves a different operational problem where the API has unpredictable traffic that causes Lambda cold-start latency. Provisioned concurrency prepares execution environments ahead of requests. It does not directly address a public endpoint fails when the only regional backend service is unhealthy. The case calls for Build multi-AZ backend capacity and regional failover as required, since serverless alone does not establish end-to-end resilience.

Use AWS Batch or ECS tasks for long-running containerized processing would help if a sustained batch transform needs custom binaries and long runtimes. Batch and ECS support runtimes unsuitable for Lambda. That is not the symptom described here: a short event-triggered transform requires no server administration. The matching response is Use Lambda for supported short-duration event processing, because lambda provides managed event-driven execution.

Deploy them on Amazon ECS with Fargate solves a different operational problem where small container services need simple scaling without Kubernetes cluster operations. ECS/Fargate offers managed task scheduling without Kubernetes. It does not directly address a short event-triggered transform requires no server administration. The case calls for Use Lambda for supported short-duration event processing, since lambda provides managed event-driven execution.

The competing option Use Amazon EKS where Kubernetes controllers are required would be useful when a portable Kubernetes operator controls complex workload custom resources. EKS provides Kubernetes APIs and custom resource extensibility. The present issue is a short event-triggered transform requires no server administration; it is more directly addressed by Use Lambda for supported short-duration event processing. Lambda provides managed event-driven execution.

Deploy them on Amazon ECS with Fargate solves a different operational problem where small container services need simple scaling without Kubernetes cluster operations. ECS/Fargate offers managed task scheduling without Kubernetes. It does not directly address a sustained batch transform needs custom binaries and long runtimes. The case calls for Use AWS Batch or ECS tasks for long-running containerized processing, since batch and ECS support runtimes unsuitable for Lambda.

The competing option Use Amazon EKS where Kubernetes controllers are required would be useful when a portable Kubernetes operator controls complex workload custom resources. EKS provides Kubernetes APIs and custom resource extensibility. The present issue is a sustained batch transform needs custom binaries and long runtimes; it is more directly addressed by Use AWS Batch or ECS tasks for long-running containerized processing. Batch and ECS support runtimes unsuitable for Lambda.

The option Use Lambda for supported short-duration event processing addresses a separate condition: a short event-triggered transform requires no server administration. Lambda provides managed event-driven execution. The actual requirement is a sustained batch transform needs custom binaries and long runtimes. Recommended corrective action: Use AWS Batch or ECS tasks for long-running containerized processing. Batch and ECS support runtimes unsuitable for Lambda.

The competing option Use Amazon EKS where Kubernetes controllers are required would be useful when a portable Kubernetes operator controls complex workload custom resources. EKS provides Kubernetes APIs and custom resource extensibility. The present issue is a vendor requires full OS access and specialized kernel modules; it is more directly addressed by Run the application on EC2 with approved instance configuration. EC2 exposes guest OS control unavailable in serverless containers.

The option Deploy them on Amazon ECS with Fargate addresses a separate condition: small container services need simple scaling without Kubernetes cluster operations. ECS/Fargate offers managed task scheduling without Kubernetes. The actual requirement is a vendor requires full OS access and specialized kernel modules. Recommended corrective action: Run the application on EC2 with approved instance configuration. EC2 exposes guest OS control unavailable in serverless containers.

Use Lambda for supported short-duration event processing would help if a short event-triggered transform requires no server administration. Lambda provides managed event-driven execution. That is not the symptom described here: a vendor requires full OS access and specialized kernel modules. The matching response is Run the application on EC2 with approved instance configuration, because eC2 exposes guest OS control unavailable in serverless containers.

The competing option Deploy them on Amazon ECS with Fargate would be useful when small container services need simple scaling without Kubernetes cluster operations. ECS/Fargate offers managed task scheduling without Kubernetes. The present issue is a portable Kubernetes operator controls complex workload custom resources; it is more directly addressed by Use Amazon EKS where Kubernetes controllers are required. EKS provides Kubernetes APIs and custom resource extensibility.

Run the application on EC2 with approved instance configuration would help if a vendor requires full OS access and specialized kernel modules. EC2 exposes guest OS control unavailable in serverless containers. That is not the symptom described here: a portable Kubernetes operator controls complex workload custom resources. The matching response is Use Amazon EKS where Kubernetes controllers are required, because eKS provides Kubernetes APIs and custom resource extensibility.

For the alternative failure a sustained batch transform needs custom binaries and long runtimes, the control Use AWS Batch or ECS tasks for long-running containerized processing is relevant: batch and ECS support runtimes unsuitable for Lambda. Here the evidence instead is a portable Kubernetes operator controls complex workload custom resources. The selected technical mechanism is Use Amazon EKS where Kubernetes controllers are required: eKS provides Kubernetes APIs and custom resource extensibility.

The option Use Amazon EKS where Kubernetes controllers are required addresses a separate condition: a portable Kubernetes operator controls complex workload custom resources. EKS provides Kubernetes APIs and custom resource extensibility. The actual requirement is small container services need simple scaling without Kubernetes cluster operations. Recommended corrective action: Deploy them on Amazon ECS with Fargate. ECS/Fargate offers managed task scheduling without Kubernetes.

Run the application on EC2 with approved instance configuration would help if a vendor requires full OS access and specialized kernel modules. EC2 exposes guest OS control unavailable in serverless containers. That is not the symptom described here: small container services need simple scaling without Kubernetes cluster operations. The matching response is Deploy them on Amazon ECS with Fargate, because eCS/Fargate offers managed task scheduling without Kubernetes.

For the alternative failure a sustained batch transform needs custom binaries and long runtimes, the control Use AWS Batch or ECS tasks for long-running containerized processing is relevant: batch and ECS support runtimes unsuitable for Lambda. Here the evidence instead is small container services need simple scaling without Kubernetes cluster operations. The selected technical mechanism is Deploy them on Amazon ECS with Fargate: eCS/Fargate offers managed task scheduling without Kubernetes.