SQS separates message producers from consumers. Choose standard or FIFO delivery, then configure processing visibility, retention, and failure recovery for the work the queue carries.
Standard and FIFO queues
SQS queues buffer work between producersAn application component that sends messages to a queue., which send messages, and consumersAn application component that receives and processes queue messages., which receive and process them. Standard queues suit work that tolerates duplicate delivery and occasional reordering. FIFOAn ordering rule that preserves the sequence of messages within a message group. (first-in, first-out) queues preserve order within each message group.
How it works
- Choose the queue type when creating the queue. Standard is the default. Changing the type later requires a new queue; a FIFO name must end in
.fifo. - For FIFO, assign
MessageGroupId, the identifier for one ordered sequence, to every message. Different groups can run concurrently. One group for every message creates one sequence. - FIFO suppresses repeated sends with the same deduplication IDA token SQS uses to recognize duplicate FIFO sends during its deduplication interval. within five minutes. This does not make the consumer’s business operation idempotentThe property that repeating a business operation does not produce extra effects., meaning safe to repeat without extra effects. A received message can become available again if it is not deleted before visibility timeoutThe period after receiving a message during which it is hidden from other consumers..
- A FIFO receive can return several messages from one group. Later receives cannot take more from that group until the received messages are deleted or visible again. Different groups can progress independently.
- For higher FIFO throughputThe amount of queue work handled per second, measured as requests or messages., set
DeduplicationScope=messageGroupandFifoThroughputLimit=perMessageGroupId. Use distinct groups for independent work so SQS can distribute it across partitionsAn SQS-managed allocation of storage holding FIFO queue messages., the storage allocations that hold queue messages. Regional quotas still apply.
| Property | Standard | FIFO |
|---|---|---|
| Ordering | Best effort | Within each message group |
| Duplicate handling | At-least-once deliveryDelivery in which a message can be received more than once. | Duplicate sends suppressed within five minutes |
| Throughput | Nearly unlimited API calls | Partition and regional quotas |
| Parallel work | Consumers process available work | Different message groups progress independently |
Exam cues
- If the question says order per customer with parallel customers, think FIFO with a group per customer, because ordering is per group.
- If the question says maximum queue throughput and duplicates are acceptable, think standard, because strict ordering is unnecessary for that requirement.
- If the question says FIFO throughput needs to grow, think independent groups and high-throughput mode, because a single ordered group limits parallel work.
Remember
- FIFO queue name:
.fifosuffix. Every FIFO send needsMessageGroupId. - Send deduplication interval: 5 minutes.
- Non-high-throughput FIFO: 300 transactions per second per action per partition, up to 3,000 messages per second with batching.
- High-throughput quotas vary by Region. Transactions per second count API requests; batching increases messages per request.
Trap: FIFO’s duplicate-send suppression does not make an external payment or database update occur only once. A consumer can fail after its side effect and receive the message again.
Consumer A processes received group A records in order.
Consumer B can process group B independently; there is no shared order across these groups.
From the AWS docs (14)
- Standard SQS queues decouple request producers from consumers performing background work.
- Standard queues are the default type and provide at-least-once delivery, best-effort ordering, and nearly unlimited API calls per second.
- FIFO ordering applies within a MessageGroupId; different groups can be processed concurrently without a shared ordering guarantee.
- Every FIFO message needs a MessageGroupId; using one group for all messages creates one ordered sequence.
- A FIFO queue name must end in .fifo.
- The queue type cannot be changed after creation; switching between standard and FIFO requires a new queue.
- FIFO suppresses duplicate sends using the same deduplication ID within a five-minute interval.
- A FIFO receive can contain multiple messages from one group; later receives cannot take more from that group until the received messages are deleted or visible again.
- An SQS message not processed and deleted before visibility timeout can become available for another attempt, so duplicate business effects must be prevented.
- Non-high-throughput FIFO partitions allow 300 transactions per second per API action; batching supports up to 3,000 messages per second per action.
- High-throughput FIFO requires DeduplicationScope=messageGroup and FifoThroughputLimit=perMessageGroupId.
- High-throughput FIFO request quotas vary by Region; increasing distinct message groups helps distribute work across partitions.
- The SQS Temporary Queue Client maps many application-managed temporary queues onto one SQS queue, which cuts API calls and cost for request-response patterns.
- SQS encrypts messages at rest with SQS-managed keys (SSE-SQS), the default for new queues, or with keys managed in AWS KMS (SSE-KMS).
Visibility, retention, and polling
SQS separates when a message becomes available, how long a consumerAn application component that receives and processes queue messages. can process it while hidden, and when it expires. Delay is the wait before the first receive. Visibility timeoutThe period after receiving a message during which it is hidden from other consumers. is the processing window after a receive. Retention is the message’s lifetime in the queue.
How it works
- A producerAn application component that sends messages to a queue. sends a message. Queue delay hides new messages before their first receive.
- The consumer calls
ReceiveMessage. Short pollingA receive operation that samples some queue servers and returns immediately. samples some servers and responds immediately. Long pollingA receive operation that queries all queue servers and waits for a message or its wait deadline. queries all servers and waits for an available message or its wait deadline, reducing empty results and false-empty results, where messages exist but the response contains none. - Receiving leaves the message in the queue but starts visibility timeout. Process and delete the message after success.
- If processing needs longer, call
ChangeMessageVisibility. Extensions do not reset the maximum allowance measured from initial receipt. Set visibility to 0 to release the message immediately. An undeleted message becomes available again when visibility expires. - SQS deletes messages after retention expires. A delay or a longer visibility timeout is not a replacement for choosing enough retention.
| Control | Starts when | Default | Range or maximum |
|---|---|---|---|
| Visibility timeout | Message is received | 30 seconds | 0 seconds through 12 hours |
| Retention | Message enters the queue | 4 days | 1 minute through 14 days |
| Queue delay | Message is sent | 0 seconds | Up to 15 minutes |
| Receive wait | Receive request waits | 0 seconds, short polling | Up to 20 seconds |
Exam cues
- If the question says two workers repeat work while one is still processing, think visibility timeout and safe duplicate handling, because the processing window may have expired.
- If the question says reduce empty receive calls, think long polling, because it waits and queries all servers.
- If the question says postpone a new message, think delay, because visibility only starts after receiving it.
Remember
- Maximum visibility is 12 hours from initial receipt, including extensions.
WaitTimeSeconds > 0enables long polling. The queue defaultReceiveMessageWaitTimeSecondsis 0.ReceiveMessagereturns up to 10 messages. Individual message maximum: 1 MiB (1,048,576 bytes).- Changing queue delay applies to already queued FIFOAn ordering rule that preserves the sequence of messages within a message group. messages, but not to already queued standard messages.
Trap: Receiving a message does not delete it. Visibility hides it temporarily, and an undeleted message becomes available again when visibility expires.
ReceiveMessage starts the processing visibility window.
After processing succeeds, delete with the latest receipt handle.
Without deletion, expiration of visibility makes the message available again.
An available message can be received for another attempt.
From the AWS docs (14)
- Receiving an SQS message leaves it in the queue but hides it for the visibility timeout.
- The SQS queue visibility timeout defaults to 30 seconds and accepts 0 through 43,200 seconds, or 12 hours.
- If a received SQS message is not deleted before visibility timeout expires, it becomes available for another receive.
- ChangeMessageVisibility changes the timeout for a received message; setting it to zero makes the message available immediately.
- Extending SQS visibility does not reset the 12-hour maximum measured from the initial receipt.
- SQS retains messages for four days by default, configurable from one minute through fourteen days.
- SQS deletes messages that remain in a queue beyond the configured retention period.
- A queue delay hides newly sent messages before their first receive, defaults to zero, and can be up to fifteen minutes.
- Changing queue delay affects messages already queued for FIFO but not for standard queues.
- Short polling is the default; it samples some servers and returns immediately even if no message is found.
- Long polling queries all servers and waits for an available message or expiration of its wait time, reducing empty and false-empty responses.
- ReceiveMessage WaitTimeSeconds greater than zero enables long polling, up to twenty seconds; queue ReceiveMessageWaitTimeSeconds defaults to zero.
- ReceiveMessage retrieves up to ten messages per request.
- The maximum SQS message size is 1,048,576 bytes, or 1 MiB.
Dead-letter queues and redrive
A dead-letter queueA queue that isolates source-queue messages that repeatedly fail processing. (DLQ) isolates messages that repeatedly fail processing. A redrive policyThe source-queue policy that selects a DLQ and receive-count threshold. moves failing messages into the DLQ. A DLQ redriveThe operation that moves retained DLQ messages back to a processing queue. task moves retained messages back for another processing attempt after the cause is repaired.
How it works
- Create a DLQ of the same type as the source: standard to standard, FIFOAn ordering rule that preserves the sequence of messages within a message group. to FIFO. On the source queue, set
RedrivePolicywithdeadLetterTargetArn, the DLQ’s Amazon Resource NameThe AWS resource identifier used to identify queues in policies and redrive settings. (ARN), andmaxReceiveCount, the receive-count threshold. SQS moves messages whose receive count exceeds that threshold. - Inspect the failure and repair its cause. For standard queues, the original enqueue timeThe recorded time at which a message entered a queue. still controls expiration after DLQ arrival. For FIFO, moving into the DLQ resets that timestamp. Set DLQ retention longer than source retention.
- Start a message move task with
StartMessageMoveTaskor the console. Redrive returns messages to their source by default, or sends them to another queue of the same type. Start with a low custom velocity, the rate of messages moved per second, and increase while watching the source. - Redriven messages can interleave with newly sent messages.
| Policy or operation | Configured on | Purpose |
|---|---|---|
RedrivePolicy |
Source queue | Move repeatedly received messages to the DLQ |
| DLQ redrive task | Started against the DLQ | Move retained messages back for processing |
Exam cues
- If the question says repeatedly failing messages need isolation, think source
RedrivePolicy, because it defines when to move them. - If the question says a repaired consumerAn application component that receives and processes queue messages. must reprocess DLQ backlog, think a controlled redrive task, because it returns messages at a selected rate.
- If the question says standard DLQ messages expire unexpectedly early, think original enqueue time, because DLQ arrival does not restart that expiration clock.
Remember
- DLQ
ApproximateAgeOfOldestMessagemeasures age since DLQ arrival. Standard-message expiration still includes source-queue time.
Trap: Moving a failed FIFO message aside lets later business operations continue without it. Neither FIFO-to-FIFO DLQ routing nor later redrive preserves the original full business sequence.
The source policy isolates messages whose receive count exceeds maxReceiveCount.
Inspect retained messages and repair the cause of processing failure.
Start a controlled DLQ redrive task after repair.
The task returns messages to the source for another processing attempt.
From the AWS docs (13)
- A dead-letter queue isolates source-queue messages that could not be processed successfully for diagnosis and later processing.
- A source queue RedrivePolicy identifies deadLetterTargetArn and maxReceiveCount; SQS moves a message when its receive count exceeds maxReceiveCount.
- A standard source queue needs a standard DLQ; a FIFO source queue needs a FIFO DLQ.
- Moving failed messages out of a FIFO queue can break the exact business-operation order.
- The default allowAll permits source queues in the same account and Region; byQueue allows up to ten specified source ARNs.
- A standard message retains its original enqueue timestamp when moved to a DLQ, so time spent in the source counts toward expiration.
- A FIFO message enqueue timestamp resets when it moves to a DLQ.
- ApproximateAgeOfOldestMessage on a DLQ measures time since arrival in the DLQ rather than original send time.
- AWS recommends DLQ retention longer than source-queue retention.
- A DLQ redrive task moves messages back to their source queue by default, or to another queue of the same type.
- StartMessageMoveTask starts a DLQ redrive task, ListMessageMoveTasks lists tasks, and CancelMessageMoveTask cancels a running task.
- Custom max redrive velocity is at most 500 messages per second; AWS recommends starting slowly and increasing while monitoring the source.
- Redriven messages can interleave with new producer messages in the destination, including a FIFO destination.
Large payloads
SQS carries messages up to 1 MiB. For a larger payloadThe application data carried by a message or stored separately behind its reference., the Extended Client Library stores the data in S3 and queues a reference, an address the consumerAn application component that receives and processes queue messages. uses to retrieve the object. The queue carries the work notification while S3 holds the large content.
How it works
- Check the native message limit before choosing offloadingStoring a message payload in S3 and sending its object reference through SQS., meaning storing the payload outside the queue. In August 2025, SQS raised that maximum from 256 KiB to 1 MiB for both standard and FIFOAn ordering rule that preserves the sequence of messages within a message group. queues.
- Use the Extended Client Library for Java or Python to write a payload to S3 and send its reference through SQS. The S3 payload can be up to 2 GB. The libraries support standard and FIFO queues with synchronous clients, whose operations wait for a response.
- On receive, the extended client retrieves the referenced object. Give the producerAn application component that sends messages to a queue. and consumer the necessary S3 permissions:
s3:PutObjectto write,s3:GetObjectto read, ands3:DeleteObjectwhen deleting payloads. - Configure payload cleanup as well as message deletion. The Python example uses
delete_payload_from_s3=Truewhen removing the S3 payload with the queue message. - For ordinary SQS batchA group of messages included in one queue API request. sends, check both message count and aggregate size.
SendMessageBatchpermits up to ten messages with a total payload no larger than 1 MiB. Inspect per-message results even when the HTTP response is 200, because individual entries can fail.
Exam cues
- If the question says send data larger than the SQS native limit, think S3 plus the Extended Client Library, because the queue can carry a reference to larger data.
- If the question says the consumer reads SQS but cannot load the payload, think S3 object access, because queue permissions do not grant
s3:GetObject. - If the question says a batch of individually valid messages exceeds the combined size limit, think smaller batches, because aggregate size also has a ceiling.
- If the question says a successful batch request lost some messages, think per-entry failures, because HTTP success does not mean every entry succeeded.
Remember
- Native message: 1 MiB, or 1,048,576 bytes. The previous 256 KiB service limit changed in August 2025.
- Offloaded payload: up to 2 GB in S3, with an SQS reference.
SendMessageBatch: at most 10 messages and 1 MiB total payload.- Extended clients support Java and Python, standard and FIFO queues, and synchronous clients.
Trap: The Extended Client Library does not raise the size of an SQS message. It moves the large content to S3 and sends a reference that fits through SQS.
The extended client stores the large payload in S3.
The producer sends an object reference through SQS.
The consumer receives the reference from the queue.
The extended client reads the referenced S3 object for processing.
From the AWS docs (11)
- SQS accepts an individual message up to 1,048,576 bytes, or 1 MiB.
- In August 2025, SQS increased its native maximum payload from 256 KiB to 1 MiB for standard and FIFO queues.
- The SQS Extended Client Libraries for Java and Python store a large payload in S3 and send an object reference through SQS.
- The Extended Client Library supports payloads up to 2 GB stored in S3.
- The Extended Client Libraries work with both standard and FIFO queues.
- The Extended Client Library supports synchronous clients only.
- The Extended Client Library retrieves the referenced S3 payload for a consumer and can delete the S3 payload.
- S3 object uploads, reads, and deletes require the corresponding s3:PutObject, s3:GetObject, and s3:DeleteObject permissions.
- The Python Extended Client example sets delete_payload_from_s3=True when deleting the corresponding S3 payload with the queue message.
- SendMessageBatch accepts up to ten messages; both individual message size and total batch payload are limited to 1 MiB.
- SendMessageBatch can report individual failures even when its HTTP status is 200.
Deduplication and message handling
SQS message handling depends on how producersAn application component that sends messages to a queue. identify and delay messages and how consumersAn application component that receives and processes queue messages. delete them. These choices also affect how to investigate a queue that stops returning work.
How it works
- For FIFOAn ordering rule that preserves the sequence of messages within a message group. deduplication, provide a
MessageDeduplicationIdor enable content-based deduplicationDuplicate-send detection based on a SHA-256 fingerprint of the message body.. Content-based deduplication uses a SHA-256 hash, a fingerprint, of the message body and excludes message attributes. See FIFO deduplication. - A queue delay hides new messages before their first receive. For standard queues, a per-message
DelaySecondstimer overrides that delay. FIFO queues do not support individual message timersA per-message delay before the message first becomes available to consumers.. - A received message remains in flight until it is deleted. To delete it, use the
ReceiptHandlefrom the most recent receive, not itsMessageId. An old handle can return success without deleting the message. See DeleteMessage. - If a standard queue reaches its in-flight limit, short pollingA receive operation that samples some queue servers and returns immediately. returns
OverLimit. Long pollingA receive operation that queries all queue servers and waits for a message or its wait deadline. returns no new messages until the in-flight count drops, without that error. See in-flight messages and quotas.
Exam cues
- If the question says FIFO messages have identical bodies but different attributes, think explicit deduplication IDsA token SQS uses to recognize duplicate FIFO sends during its deduplication interval., because the content-based hash excludes attributes.
- If the question says a FIFO message needs its own initial delay, think queue-level delay instead, because FIFO does not support individual message timers.
- If the question says a successful delete leaves a message in the queue, think the latest receipt handleAn identifier for a particular receive that is required to delete that received message., because an old handle can succeed without deleting it.
- If the question says long polling returns no work without
OverLimit, think in-flight count and deletion rate, because the queue may have reached its in-flight limit.
Remember
- Queue delay defaults to 0 seconds and can be up to 15 minutes.
- A standard queue allows approximately 120,000 in-flight messages, depending on traffic and backlog.
- Short polling returns
OverLimitat the in-flight limit; long polling returns no new messages until the count drops. - A DLQA queue that isolates source-queue messages that repeatedly fail processing.
RedriveAllowPolicyselects which source queues may use it:allowAll,byQueueordenyAll. - Redrive gives messages new IDs and enqueue times and cannot filter or rewrite them.
- Starting a redrive needs
sqs:StartMessageMoveTask, receive, delete and attribute permissions on the DLQ,sqs:SendMessageon the destination, and KMS permissions for encrypted queues.
Trap: Different message attributes do not make content-based FIFO deduplication treat identical bodies as different. Use explicit deduplication IDs when the messages need distinct identities.
From the AWS docs (14)
- Content-based FIFO deduplication uses a SHA-256 hash of the message body, excluding message attributes.
- A FIFO producer must provide a MessageDeduplicationId unless content-based deduplication is enabled.
- A standard-queue per-message DelaySeconds timer overrides queue delay; FIFO queues do not support timers on individual messages.
- A queue delay hides newly sent messages before their first receive, defaults to zero, and can be up to fifteen minutes.
- DeleteMessage requires the most recently received ReceiptHandle rather than MessageId; an old handle can succeed without deleting the message.
- An in-flight SQS message has been received but not yet deleted.
- Standard queues allow approximately 120,000 in-flight messages depending on traffic and backlog.
- At the in-flight limit, short polling returns OverLimit while long polling returns no new messages until in-flight count drops.
- A source queue RedrivePolicy identifies deadLetterTargetArn and maxReceiveCount; SQS moves a message when its receive count exceeds maxReceiveCount.
- A DLQ RedriveAllowPolicy selects allowed source queues using allowAll, byQueue, or denyAll.
- DLQ redrive cannot filter or modify message contents during movement.
- DLQ redrive assigns a new message ID and enqueue time, resetting retention.
- Starting redrive needs sqs:StartMessageMoveTask, sqs:ReceiveMessage, sqs:DeleteMessage, and sqs:GetQueueAttributes on the DLQ, plus sqs:SendMessage on the destination.
- Redrive of KMS-encrypted messages needs kms:Decrypt on the keys used to encrypt them; an encrypted destination also needs kms:GenerateDataKey and kms:Decrypt.
Flashcards
Nothing to review here right now. Pick other topics or another filter.
·
All 29 cards as a list
How do SQS standard and FIFO queues differ in delivery, ordering, and baseline throughput?
Standard provides at-least-once delivery, best-effort order, and nearly unlimited API calls. FIFO orders within each MessageGroupId and deduplicates sends for five minutes. Non-high-throughput FIFO partitions allow 300 transactions per second per action, or up to 3,000 messages per second with batching.
Does SQS FIFO send deduplication make consumer side effects safe from repetition?
No. Deduplication suppresses duplicate sends within five minutes. A received message can be processed again if it is not deleted before visibility timeout, so consumers still need idempotent business operations.
An SQS workload needs order per customer but parallel processing across customers. How should it use FIFO message groups?
Use a MessageGroupId per customer. FIFO preserves order inside each group while different groups can be processed concurrently.
A standard SQS queue must provide strict ordering for related messages. Can the team enable FIFO on the existing queue?
No. Create a FIFO queue, whose name ends in .fifo, and send related messages with the same MessageGroupId. Queue type cannot be changed after creation.
Which SQS FIFO attributes enable high-throughput mode?
Set DeduplicationScope to messageGroup and FifoThroughputLimit to perMessageGroupId. Distribute independent work across distinct message groups.
Thousands of short-lived clients each need a reply queue in a request-response pattern, and creating real SQS queues per client is slow and costly. What fits?
SQS temporary queues through the Temporary Queue Client, which maps them onto one SQS queue.
Pro users jobs must be processed before lite users jobs. How can SQS standard queues provide that priority?
Use two queues, one per class, and have the workers poll the pro queue first. A standard queue has only best-effort ordering, so one queue cannot rank messages.
A queue must use encryption keys whose use the security team can audit and restrict. SSE-SQS or SSE-KMS?
SSE-KMS, which uses keys in AWS KMS that the team controls through key policies. SSE-SQS keys are managed by SQS itself.
What SQS timer, polling, and message limits should a consumer design account for?
Visibility defaults to 30 seconds, with a 0-to-12-hour range. Retention defaults to four days, with a one-minute-to-fourteen-day range. Initial delay is at most fifteen minutes; long polling waits at most twenty seconds. Messages are at most 1 MiB and a receive returns up to ten.
An SQS worker is still processing when its message becomes visible and another worker receives it. Which setting should it adjust?
Increase visibility timeout or extend it using ChangeMessageVisibility while processing. Delete the message after success. Changing initial delay does not protect work already received.
An SQS application makes many receive calls with empty results even while some messages exist. What should it enable?
Enable long polling with a positive WaitTimeSeconds, up to twenty seconds. It queries all servers and reduces empty and false-empty responses.
A worker repeatedly extends SQS message visibility. Does each extension begin a new twelve-hour allowance?
No. The twelve-hour maximum is measured from initial receipt; extending visibility does not reset it.
Repeatedly failing SQS messages consume retries. How should the team isolate them, and what is the FIFO ordering risk?
Set the source queue RedrivePolicy with its deadLetterTargetArn and maxReceiveCount. Standard must target standard, and FIFO must target FIFO. Removing a failed FIFO message can break the exact business-operation order.
A standard SQS message spends time in its source queue before reaching a DLQ. Does its expiration clock restart on DLQ arrival?
No. The original enqueue timestamp remains, so source-queue time counts toward expiration. Use a DLQ retention period longer than the source retention. FIFO messages reset their enqueue timestamp on DLQ arrival.
A team has repaired the consumer that caused SQS messages to accumulate in its DLQ. How can it reprocess the backlog safely?
Start a DLQ redrive with StartMessageMoveTask or the console, targeting the source or another same-type queue. Begin with a low custom velocity and monitor the source as the rate increases.
A DLQ age metric looks young, but standard SQS messages expire sooner than expected. Why?
ApproximateAgeOfOldestMessage measures time since DLQ arrival, while standard-message expiration still uses the original enqueue timestamp.
A team must send an SQS payload larger than the native message limit. What should it use?
Use the SQS Extended Client Library for Java or Python. It stores payloads up to 2 GB in S3 and sends an object reference through SQS. Consumers need S3 read permissions.
An SQS consumer receives an object reference rather than the original large payload. What must its processing path do?
Use the Extended Client Library or equivalent reference-aware processing to retrieve the S3 object. Authorize s3:GetObject for the payload. The full data is stored in S3.
A team sends several individually valid SQS messages with SendMessageBatch, but their combined payload exceeds 1 MiB. Is that request within the limit?
No. SendMessageBatch has a 1 MiB total payload limit as well as the individual message limit, and accepts at most ten messages.
An SQS SendMessageBatch request returns HTTP 200. Can the producer assume every message was sent successfully?
No. Inspect the per-message results for individual failures even when the request returns HTTP 200.
An SQS Python Extended Client consumer must remove its S3 payload when deleting the queue message. What documented setting applies?
Set delete_payload_from_s3=True for payload deletion and authorize s3:DeleteObject. Queue access alone does not grant S3 object access.
Does SQS FIFO support the Extended Client Library payload-offloading pattern?
Yes. The Java and Python Extended Client Libraries support standard and FIFO queues, with synchronous clients.
An SQS producer retries messages with identical bodies but different attributes under content-based FIFO deduplication. Are the attributes part of the deduplication hash?
No. The SHA-256 hash uses the message body only. Use an explicit MessageDeduplicationId when the intended identity must distinguish those messages.
An SQS FIFO producer needs a different initial delay for each message. Can it use per-message DelaySeconds timers?
No. FIFO does not support individual message timers. It can use a queue-level delay of up to fifteen minutes.
An SQS delete request succeeds, yet the message remains after several receives. Which identifier should the consumer check?
Use the ReceiptHandle from the latest receive, not MessageId or an older receipt handle. An old handle can succeed without deleting the message.
An SQS standard queue has many received messages and long polling returns no new work without OverLimit. What should the team investigate?
Check the in-flight message limit and deletion rate. At that limit, long polling stops returning new messages without returning the short-poll OverLimit error.
How do SQS RedrivePolicy and RedriveAllowPolicy differ?
RedrivePolicy on the source sets failure routing and maxReceiveCount. RedriveAllowPolicy on the DLQ controls which source queues may use it.
A team wants SQS DLQ redrive to rewrite malformed payloads before sending them back. Can the managed redrive task do that?
No. DLQ redrive cannot filter or modify messages. It moves them and assigns new message IDs and enqueue times.
An SQS DLQ redrive is denied for an encrypted queue pair. Which permissions should the team check?
Check DLQ move/read/delete/attribute permissions and destination sqs:SendMessage. Also check kms:Decrypt for message keys and kms:GenerateDataKey plus kms:Decrypt for the encrypted destination.