AWS Certified Developer - Associate (DVA-C02) practice questions

A developer is building an order service that publishes an OrderPlaced event. Three independent consumers must each receive every event: an email service polls a queue, an analytics service polls a separate queue, and an inventory service is an HTTP endpoint. The developer wants each consumer to process events at its own pace with retry and buffering. Which design implements this fan-out most directly?

• APublish each event to an SNS topic and subscribe the two queues plus the inventory HTTP endpoint to the topic so SNS delivers a copy to every subscriber.check_circle Correct
• BPublish each event to one SQS standard queue and let all three consumers poll that single shared queue so every service receives the same message body.
• CPublish each event to an SNS topic with the inventory HTTP endpoint subscribed directly and the two services reading from the topic by long polling it for messages.
• DPublish each event to an SQS FIFO queue and configure three message group IDs so each consumer reads only the group that matches its own service name reliably.

Why A is correct: SNS fan-out pushes a copy of each message to every subscriber, so both queues buffer for their pollers and the HTTP endpoint receives a direct delivery with retries.

Why B is wrong: A single SQS queue delivers each message to only one consumer that deletes it, so the three services would compete for messages rather than each receiving every event.

Why C is wrong: SNS is push-based and cannot be polled, so subscribing the services by polling the topic is not possible and would lose the buffering the queues provide.

Why D is wrong: Message group IDs order messages within a single FIFO queue but still deliver each message once, so they cannot duplicate every event to three separate consumers.

A payment service writes transactions to an SQS queue that a worker fleet polls. Each transaction must be processed once and in the exact order it was submitted per customer account. Duplicate processing would double-charge a customer. Which queue configuration meets the ordering and exactly-once processing requirement?

• AUse an SQS standard queue with a long visibility timeout and rely on the worker to sort messages by a submittedAt timestamp before charging each customer account.
• BUse an SQS FIFO queue with the customer account as the message group ID and content-based deduplication enabled so order and single processing hold per account.check_circle Correct
• CUse an SQS standard queue with deduplication scope set to message group so repeated transactions are dropped and the workers process each account in arrival order.
• DUse an SNS standard topic subscribed to one queue with delivery retries tuned so the topic enforces strict order and removes duplicate transactions before workers poll.

Why A is wrong: Standard queues offer best-effort ordering and at-least-once delivery, so a long timeout and client sorting cannot guarantee per-account order or prevent duplicate charges.

Why B is correct: A FIFO queue preserves order within each message group and deduplication suppresses repeats, so transactions for one account are processed in order and exactly once.

Why C is wrong: Standard queues do not support deduplication scope or message groups, so this configuration is invalid and would not stop duplicate or out-of-order processing.

Why D is wrong: SNS standard topics do not guarantee ordering or deduplication, and retries can themselves cause duplicates, so the double-charge risk and ordering gap remain.

A worker reads orders from an SQS standard queue and calls a downstream API. Some messages contain malformed data that always fails, so the worker never deletes them and they reappear after the visibility timeout, blocking the queue and wasting compute. The developer wants poison messages isolated automatically after a few failed attempts. What should the developer configure?

• ALower the queue's visibility timeout so failing messages reappear faster and the worker can retry them many more times within the same processing window.
• BIncrease the message retention period so failing messages stay longer, giving the worker additional chances to process them before they are finally deleted.
• CSet a redrive policy on the queue with a dead-letter queue and a maxReceiveCount so messages move to the dead-letter queue after the failed attempts.check_circle Correct
• DEnable long polling with a higher wait time so the worker batches messages and skips the malformed ones until they expire from the queue on their own.

Why A is wrong: A shorter visibility timeout only makes poison messages reappear sooner, increasing wasted retries rather than removing them from the main queue.

Why B is wrong: A longer retention period keeps poison messages in the queue even longer, which worsens the blocking and waste rather than isolating the bad messages.

Why C is correct: A redrive policy counts receives and moves a message to the dead-letter queue once maxReceiveCount is exceeded, isolating poison messages from the main queue automatically.

Why D is wrong: Long polling reduces empty receive calls but does not skip or remove failing messages, so poison messages keep returning until retention expires.