SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
SAA-C03 · Domain 2

Design Resilient Architectures practice questions

Design Resilient Architectures is worth 26% of the SAA-C03 exam — the 2nd-heaviest of the 4 domains. Scalable, loosely coupled designs and highly available, fault-tolerant architectures measured against RTO and RPO. 6 fully worked examples are further down this page, answers included.

Exam weight
26%
the 2nd-heaviest of the 4 domains
Questions
140
across 2 topics
Free, no account
5/day
a free account allows 10 a day
Explanations
Every option
right and wrong

Build a practice session

5 free questions left today.

Domains

How many?

5 free questions left today.

Mode

Ready when you are

10 fresh questions drawn across 1 of 4 domains, in Learn mode.

Review what you missed

Every question you answer incorrectly, and every question you flag while practising, is saved here automatically. Finish a session and you can come back to re-drill just those.

6 sample Design Resilient Architectures questions, fully explained

Questions from the SAA-C03 bank mapped to domain 2, with the answer key and the reasoning behind every option. None of them repeat the examples on the main SAA-C03 practice page.

Question 1Design Resilient Architectures

A ticketing company's checkout API calls a seat-allocation service synchronously. During on-sale events for popular concerts the allocation service is overwhelmed, calls fail, and some paid checkouts never receive seats. Allocation may complete a few minutes after checkout, but no checkout can be dropped, and allocation capacity must grow with demand. Which combination of steps should a solutions architect take? (Select TWO.)

Choose TWO.

  • a
    Have the checkout API write each paid checkout to an Amazon SQS queue instead of calling the allocation service directly. Correct

    The queue accepts every checkout instantly and keeps it until an allocation worker processes and deletes it, so an overwhelmed service delays allocation rather than losing it.

  • b
    Have the checkout API publish each paid checkout to an Amazon SNS topic with the allocation service subscribed over HTTPS.

    SNS pushes to the overwhelmed endpoint on its own schedule; after the delivery retries are exhausted the checkout is dropped, so it is not a durable buffer.

  • c
    Run the allocation workers in an Auto Scaling group that scales on how much allocation work is waiting to be processed. Correct

    Scaling on the amount of pending allocation work (the queue backlog) adds workers while checkouts are waiting and removes them afterward, so capacity follows demand.

  • d
    Have the checkout API retry failed allocation calls with exponential backoff and jitter before returning an error.

    Backoff smooths retry storms, but a call that is still failing when the retries run out returns an error and the checkout is still lost.

  • e
    Put an internal Application Load Balancer in front of the allocation service and scale its targets on request count.

    This scales the service but keeps the synchronous call path, so checkouts that arrive while targets are saturated or still launching fail with nowhere to wait.

The concept

Two halves make a spike-proof hand-off: a durable queue between producer and consumer so nothing is dropped, and a consumer tier that scales on the queue's backlog so capacity follows demand.

Why that’s the answer

The stem tolerates a few minutes of delay but no loss, which is exactly what an asynchronous queue provides: SQS stores each checkout until a worker deletes it, and scaling the worker group on the queue's backlog adds allocation capacity during an on-sale event. The load balancer with request-count scaling is the near-twin: it scales, but checkouts still depend on the allocation service answering in time, so the ones caught while it is saturated fail. Retrying with backoff and jitter is good client hygiene but only postpones the failure. SNS over HTTPS is push delivery; it has no consumer-paced storage, so an endpoint that stays overwhelmed past the retry policy loses the message.

How to reason it out
  1. Read the constraint: delay is acceptable, loss is not, so the hand-off can be asynchronous.
  2. Choose a durable buffer: SQS keeps each checkout until a worker processes and deletes it.
  3. Pair it with consumer scaling on the queue backlog so capacity grows with demand.
  4. Reject options that keep the synchronous call (load balancer, retries) or push without storage (SNS over HTTPS).

Exam tip: No-loss plus elastic capacity = SQS between the tiers and workers scaling on queue backlog.

Scalable, Loosely Coupled Architectures: SQS, SNS, EventBridge, Step Functions — the lesson that teaches this.

Question 2Design Resilient Architectures

A banking platform queues payment instructions for asynchronous processing by a fleet of consumers. Instructions for any given account must be applied in the exact order they were submitted and must not be applied twice, while instructions for different accounts should be processed in parallel to keep up with volume. Which messaging design meets these requirements?

Choose one.

  • a
    An SQS standard queue, with consumers that record each processed instruction ID per account.

    Idempotency tracking stops duplicates from being applied twice, but a standard queue delivers in best-effort order, so one account's instructions can still be applied out of sequence.

  • b
    An SQS FIFO queue, with one fixed message group ID for the whole platform.

    This keeps strict order and deduplication, but a single message group is processed one message at a time, so accounts can no longer be handled in parallel.

  • c
    An SQS standard queue, with long polling and the account ID as a message attribute.

    Long polling reduces empty receives and a message attribute is only metadata; neither gives ordering or deduplication.

  • d
    An SQS FIFO queue, with each instruction's account ID used as the message group ID. Correct

    FIFO orders messages within each message group and deduplicates them, and separate groups (one per account) can be consumed in parallel by different consumers.

The concept

In an SQS FIFO queue, ordering is guaranteed within a message group, and different message groups are processed in parallel. Choosing the group ID is the design decision: it should be the entity whose order matters.

Why that’s the answer

Account ID as the message group ID meets all three requirements: FIFO keeps each account's instructions in submission order, deduplication prevents an instruction from being enqueued twice, and messages from different groups are delivered to different consumers at the same time. The tempting near-twin is a single shared group ID: it is still a FIFO queue, so order and deduplication hold, but one group means one in-flight message at a time and no parallelism across accounts. A standard queue with idempotent consumers handles duplicates but not order. A standard queue with long polling and an attribute provides neither.

How to reason it out
  1. Note the two per-account guarantees: strict order and no double processing, which point to FIFO.
  2. Note the scaling requirement: different accounts in parallel.
  3. Recall that FIFO orders within a message group and parallelises across groups.
  4. Set the group ID to the account ID so order is per account and accounts run in parallel.

Exam tip: FIFO message group ID = the unit whose order matters; one shared group serialises everything.

Scalable, Loosely Coupled Architectures: SQS, SNS, EventBridge, Step Functions — the lesson that teaches this.

Question 3Design Resilient Architectures

An IoT platform ingests several hundred thousand telemetry messages per minute from millions of sensors into a queue for a fleet of consumers. Each message is independent, arrival order does not matter, and the consumers already discard duplicates. Which queue design meets the requirements at the lowest cost with the least configuration?

Choose one.

  • a
    A single SQS FIFO queue in high-throughput mode, with a random message group ID on each message.

    High-throughput FIFO can carry this volume, but every send now needs a message group ID plus a deduplication ID or content-based deduplication, and FIFO requests cost more, for ordering the workload does not need.

  • b
    Several SQS FIFO queues, with a Lambda function that shards messages across them by sensor ID.

    Sharding across FIFO queues adds a routing function and several queues to operate in order to buy throughput that a standard queue provides with no extra components.

  • c
    An Amazon MQ for RabbitMQ broker in an active/standby deployment, with a queue per sensor type.

    Amazon MQ suits applications that already speak AMQP or other broker protocols; here it adds brokers to size and patch with no benefit over SQS.

  • d
    A single SQS standard queue, with the sensors' messages sent in batches to cut request costs. Correct

    Standard queues have nearly unlimited throughput and the lowest request price (batching up to 10 messages per request lowers it further); at-least-once delivery and best-effort order are harmless because the consumers are idempotent and order does not matter.

The concept

SQS standard is the default: nearly unlimited throughput, at-least-once delivery, best-effort ordering. FIFO is chosen only when order or exactly-once processing is a stated requirement, because it costs more per request and needs group and deduplication IDs.

Why that’s the answer

With no ordering requirement and idempotent consumers, the FIFO guarantees buy nothing. A single standard queue absorbs the volume at the lowest request price with no extra IDs to set. High-throughput FIFO is the tempting option because it can now reach this scale, but it still requires a message group ID and deduplication on every send and charges the higher FIFO rate. Sharding across FIFO queues is the over-engineered version of the same mistake. Amazon MQ is for protocol compatibility during a migration, not for new cloud-native telemetry.

How to reason it out
  1. Check the stated needs: order does not matter and duplicates are already handled.
  2. Recall that FIFO's only benefits are ordering and deduplication, at a higher price and with more producer configuration.
  3. Recall that standard queues scale with no configuration and cost less per request.
  4. Pick the single standard queue; reject the FIFO variants and the broker as unneeded complexity.

Exam tip: No ordering or exactly-once requirement means SQS standard; choosing FIFO anyway only adds cost and configuration.

Scalable, Loosely Coupled Architectures: SQS, SNS, EventBridge, Step Functions — the lesson that teaches this.

Question 4Design Resilient Architectures

Workers pull jobs from an SQS standard queue that was created with default settings, and each job takes up to five minutes to process. Monitoring shows many messages are processed two or three times even though no worker has crashed and no producer sends duplicates. What should a solutions architect do to stop the duplicate processing?

Choose one.

  • a
    Convert the queue to a FIFO queue with content-based deduplication enabled for the job messages.

    FIFO deduplication rejects duplicate sends within its window; it does not stop a received message from becoming visible again while a worker is still processing it.

  • b
    Enable long polling on the queue by setting the receive message wait time to 20 seconds.

    Long polling reduces empty receive responses and cost; it has no effect on how long a received message stays hidden.

  • c
    Increase the queue's visibility timeout so that it exceeds the longest job processing time. Correct

    The default visibility timeout is 30 seconds, so each message reappears long before its five-minute job finishes and another worker picks it up; a longer timeout keeps it hidden until the first worker deletes it.

  • d
    Attach a dead-letter queue with a redrive policy that sets the maximum receive count to 1.

    This moves a message to the dead-letter queue as soon as it is received a second time, so healthy jobs end up there instead of being processed; the root cause is untouched.

The concept

A received SQS message is hidden for the visibility timeout and must be deleted by the consumer before the timeout expires. If processing outlasts the timeout, the message reappears and is delivered again.

Why that’s the answer

Duplicates with no crashes and no duplicate sends point to the visibility timeout: the default is 30 seconds, jobs take up to five minutes, so every slow job is redelivered to another worker while still in progress. Raising the timeout above the longest processing time (or extending it per message with ChangeMessageVisibility) fixes it. FIFO with deduplication is the tempting answer for 'duplicates', but deduplication applies to sends, and FIFO still redelivers a message whose visibility timeout expires. Long polling changes how receives wait, not how long messages stay hidden. A dead-letter queue with a receive count of 1 hides the symptom by shunting good jobs aside.

How to reason it out
  1. Rule out crashes and duplicate sends, as the stem does: the duplicates come from redelivery.
  2. Compare the default visibility timeout (30 seconds) with the processing time (up to five minutes).
  3. Recall that an undeleted message reappears when its visibility timeout expires.
  4. Raise the visibility timeout above the maximum processing time.

Exam tip: Duplicate processing without crashes means the visibility timeout is shorter than the job; raise it rather than switching to FIFO.

Scalable, Loosely Coupled Architectures: SQS, SNS, EventBridge, Step Functions — the lesson that teaches this.

Question 5Design Resilient Architectures

A consumer fleet processes messages from an SQS standard queue. A small number of malformed messages throw an exception on every attempt, return to the queue after the visibility timeout, and are redelivered over and over, wasting worker capacity and delaying valid messages. The team wants the bad messages set aside for later analysis with the LEAST operational overhead. What should the architect configure?

Choose one.

  • a
    A redrive policy that moves a message to a dead-letter queue after a set receive count, plus an alarm on that queue's depth. Correct

    SQS counts receives itself; once a message exceeds maxReceiveCount it is moved to the dead-letter queue intact, where the alarm flags it and the team can inspect or redrive it later.

  • b
    Exception handling in the consumers that deletes a message after a failed attempt and writes the error to CloudWatch Logs.

    Deleting on the first failure also discards messages that failed for a transient reason, and the log holds the error, not the message, so there is nothing to analyse or reprocess.

  • c
    A message retention period of one hour on the queue, so that repeatedly failing messages expire before they pile up.

    Retention applies to every message, so valid messages delayed by a backlog expire too, and expired messages are deleted rather than kept for analysis.

  • d
    A visibility timeout of 12 hours on the queue, so that failing messages reappear much less often for the workers.

    This slows the loop but never ends it, and it also delays the retry of valid messages whose consumer crashed by up to 12 hours.

The concept

A poison message fails every time and would cycle through receive, fail and reappear forever. A redrive policy on the source queue moves any message received more than maxReceiveCount times to a dead-letter queue.

Why that’s the answer

The dead-letter queue is the built-in, no-code answer: SQS tracks each message's receive count, moves it to the DLQ after the threshold, and the main queue goes back to valid work. An alarm on the DLQ's depth tells the team something needs attention, and the messages are kept intact for analysis or redrive. Deleting on failure in code loses the data and also throws away transient failures. A short retention period is indiscriminate and deletes rather than keeps. A very long visibility timeout only slows the cycle and harms recovery for valid messages.

How to reason it out
  1. Recognise the symptom: the same messages fail on every attempt, which makes them poison messages.
  2. Recall that SQS can count receives and move messages after maxReceiveCount via a redrive policy.
  3. Add an alarm on the dead-letter queue so isolated messages are noticed.
  4. Reject options that delete data (code delete, short retention) or merely slow the loop (long visibility timeout).

Exam tip: Messages that fail every time belong in a dead-letter queue via a redrive policy, not deleted or left to cycle.

Scalable, Loosely Coupled Architectures: SQS, SNS, EventBridge, Step Functions — the lesson that teaches this.

Question 6Design Resilient Architectures

When a customer places an order, three systems owned by different teams must each receive and process every order event independently: inventory, billing, and an analytics pipeline. Each system has maintenance windows of up to an hour and must work through its own backlog afterward, and the company wants to add future consumers without changing the ordering application. Which architecture meets these requirements?

Choose one.

  • a
    Send each order event to one SQS standard queue, and have the inventory, billing, and analytics systems poll that queue.

    Consumers of one queue compete: each message goes to whichever system receives it first, so every system sees only part of the orders.

  • b
    Have the ordering application send each order event to three SQS queues, one per consuming system.

    Each system gets every event and a durable backlog, but adding a fourth consumer means changing the ordering application, which the company wants to avoid.

  • c
    Publish each order event to an SNS topic, and subscribe a separate SQS queue to the topic for each consuming system. Correct

    SNS copies every event to each subscribed queue, each queue holds its system's backlog through maintenance, and a new consumer is just a new subscription.

  • d
    Publish each order event to an SNS topic, and subscribe each consuming system's HTTPS endpoint directly to the topic.

    Every system gets a copy, but SNS push delivery to an endpoint that is down for an hour has no backlog for the system to work through later; once retries run out, events are lost.

The concept

Fan-out delivers one event to many independent consumers. SNS-to-SQS fan-out combines the topic's copy-to-every-subscriber delivery with a durable queue per consumer.

Why that’s the answer

Publishing once to an SNS topic with a queue per consumer meets all three needs: every system receives every event, each queue buffers through that system's maintenance window, and new consumers subscribe without the publisher changing. Direct HTTPS subscriptions are the near-twin: the fan-out is right, but nothing holds the backlog while a system is down. Writing to three queues from the application works today but couples the publisher to the list of consumers. A single shared queue fails outright because its consumers compete for messages.

How to reason it out
  1. Identify the pattern: one event, several independent consumers, which is fan-out.
  2. Add the durability requirement: each consumer needs its own backlog through downtime, so each gets its own queue.
  3. Add the extensibility requirement: the publisher must not know the consumers, so it publishes to a topic.
  4. Combine them: SNS topic with an SQS queue subscribed per consumer.

Exam tip: Many consumers that each need every event and their own backlog = SNS topic fanning out to one SQS queue per consumer.

Scalable, Loosely Coupled Architectures: SQS, SNS, EventBridge, Step Functions — the lesson that teaches this.

What SAA-C03 domain 2 tests, topic by topic

The official exam guide breaks Design Resilient Architectures into 2 topics. The question bank follows the same split, so a weak topic shows up as a cluster of misses you can go back and read.

Published SAA-C03 practice questions per topic in Design Resilient Architectures
TopicWhat it coversQuestions
Design scalable and loosely coupled architecturesExam guide task 2.1. Event-driven, microservice, and multi-tier designs; decoupling with SQS and pub/sub messaging, API Gateway, and Step Functions orchestration; when to choose serverless (Lambda, Fargate) vs containers (ECS, EKS) and migrating apps into containers; horizontal vs vertical scaling, load balancing (ALB), caching, edge accelerators (CDN), read replicas, and storage types (object, file, block).70
Design highly available and/or fault-tolerant architecturesExam guide task 2.2. Multi-AZ and multi-Region design with Regions, AZs, and Route 53; disaster-recovery strategies (backup and restore, pilot light, warm standby, active-active failover) against RTO/RPO; mitigating single points of failure; failover and distributed design patterns, immutable infrastructure, RDS Proxy; data durability strategies, service quotas and throttling, workload visibility with X-Ray, and improving the reliability of legacy applications.70
Total140

Revise Design Resilient Architectures before you drill it

Other SAA-C03 domains

Design Resilient Architectures: your questions

Design Resilient Architectures is domain 2 of the SAA-C03 exam guide and carries 26% of the scored content — the 2nd-heaviest of the 4 domains. On a 65-question paper that works out to roughly 17 questions, though AWS does not publish an exact per-domain count and individual exam forms vary.

Source

The domain weight and topic list on this page come from the official SAA-C03 exam guide.