A password-reset request can receive an API acceptance and still produce a bounce later, leaving the user without a working link. Transactional email bounce handling gives your team a concrete way to reconcile that failure without retrying a dead address or claiming the message was delivered.
A bounce means the recipient’s mail system rejected a message and the sending service reported the failure. Record it against the message and recipient, classify it as permanent or temporary, then suppress or correct permanent failures and retry temporary ones only under a bounded policy. Keep provider acceptance, a later bounce, and confirmed delivery as distinct outcomes.
For the transactional email your application sends, this distinction is operational: it determines whether a user can receive a receipt, verification link, or account alert, and what your application should tell them. The workflow below focuses on concrete actions after a failure, not general campaign-list cleanup.
What a transactional email bounce means
A bounce is a delivery rejection reported by the recipient’s mail system. Amazon SES describes the receiving system as sending the failure back to SES, which then notifies the sender through email or Amazon SNS, depending on the notification setup. An accepted send request therefore tells you that the sending service accepted the request; it does not establish that the recipient received the message.
That distinction matters when email is part of an application flow. If a receipt bounces, the purchase may still be complete even though the customer lacks the email record. If a verification message bounces, the account may remain unverified. If a password-reset link bounces, the reset request is still unresolved; the application must not mark the user as notified simply because the provider accepted the send.
Model these as separate facts. A message can have an initial accepted outcome and later a bounced outcome. A message marked delivered should require a delivery outcome from the sending system; an API response alone is not enough. Your application’s user-facing state can then reflect the actual workflow, such as “We could not send the link to this address,” rather than “Email sent.”
Volanea is built on Amazon SES, and every message it sends travels over SES. Volanea also provides send records and event logs, so teams can inspect sending outcomes alongside application state. Those records make the distinction between an attempted send and a later delivery event useful in practice, rather than a status distinction that exists only in code.
Hard bounces vs. soft bounces: choose the right response
The key decision is whether the reported failure is persistent or temporary. Amazon SES describes a hard bounce as a persistent delivery failure, such as a mailbox that does not exist. A soft bounce is temporary; examples include a full mailbox, too many connections, or a connection timeout.
| Bounce type | Example | Operational response |
|---|---|---|
| Hard / persistent | The recipient mailbox does not exist. | Stop automatic sends to that address. Preserve the failure record and allow a corrected address to follow your normal verification flow. |
| Soft / temporary | The mailbox is full or the receiving server times out. | Consider a bounded retry after a delay. Keep the message undelivered until a later outcome changes its state. |
| Temporary but message-related | The recipient system rejects a particular message. | Diagnose whether the message needs to change before retrying. Repeating an unchanged send may repeat the same failure. |
Do not make the response depend on the word “bounce” alone. Use the provider’s classification and available reason, then decide whether another attempt could plausibly succeed. A full mailbox may clear later; an address that does not exist will not become valid because a worker retries it.
The application action also depends on message purpose. For a receipt, preserve the completed purchase while showing that email delivery failed. For a verification link, keep verification incomplete and provide a route to correct the address. For an account alert, record the failed notification without changing the underlying account event. In all three cases, the bounce changes delivery state, not the truth of the business event.
Volanea automatically handles and suppresses bounces and complaints. That helps prevent repeat sends to addresses already known to be problematic, while your application should still retain the per-message outcome needed to explain a failed receipt or reset request. See how Volanea handles sending on Amazon SES for the product-level distinction between managed sending and raw SES infrastructure.
Transactional email bounce handling: build an event workflow
Treat a bounce notification as an event to reconcile, not as a free-standing command to change an account. The safe sequence is: receive the notification, associate it with the original send and recipient, record it, classify it, and apply an idempotent action. A notification system can deliver the same event more than once, and events can arrive after the original send job has finished.
Use an application-owned event record to make these steps explicit. This example is a normalized record for your own system—not a Volanea payload or a claim about a provider’s exact notification schema:
{
"event_key": "evt_84c21",
"message_key": "msg_reset_3107",
"provider_message_key": "provider-id-from-send-response",
"recipient": "user@example.com",
"message_type": "password_reset",
"outcome": "bounced",
"classification": "temporary",
"reason": "mailbox_full",
"received_at": "2026-11-14T12:00:00Z",
"processed_at": null
}
The exact event identifier and payload depend on the provider and the notification path you configure. Keep your internal record stable even if a provider adds fields or changes its external representation. For each accepted send, retain your own message key and the provider’s send identifier; then associate a bounce with both that send and the affected recipient.
A handler can follow this outline:
on_bounce(event):
parsed = validate_and_normalize(event)
if not parsed.has_message_and_recipient:
store_for_review(parsed)
return
begin_transaction()
if event_key_already_processed(parsed.event_key):
commit_and_return()
save_event(parsed)
update_message_outcome(parsed.message_key, "bounced")
if parsed.classification == "permanent":
suppress_recipient_for_sending(parsed.recipient)
else:
schedule_retry_if_policy_allows(parsed.message_key)
mark_event_processed(parsed.event_key)
commit()
Use a unique constraint on the event key, or another stable identifier from your integration, so concurrent workers cannot apply the same side effect twice. Keep the raw notification or a durable copy of its relevant fields for debugging, while storing normalized fields for queries. If an event cannot be matched to a send, retain it for investigation rather than suppressing an address or changing an unrelated message.
Volanea provides send records, event logs, and delivery, open, click, bounce, and unsubscribe statistics. Its product information describes those observability surfaces, but this guide does not assume particular event names, a retrieval endpoint, or a webhook payload schema. Use the records and logs Volanea provides; do not build an integration around guessed event names or pretend the illustrative JSON above is its format. The Volanea platform overview describes those sending records and statistics.
When to retry a soft bounce—and when to stop
An immediate retry rarely helps when the recipient server is still unavailable or throttling connections. Repeated attempts can add load without changing the outcome, and overlapping workers can create duplicate messages if an earlier attempt eventually succeeds. Apply one bounded policy to the original message rather than restarting the retry counter whenever a job runs again.
For example, a team might schedule retries after 1 minute, 5 minutes, 30 minutes, and 2 hours for a temporary failure. That is an illustrative schedule, not an Amazon SES or Volanea default. A password-reset link that expires after a short period should stop retrying when it is no longer useful; a receipt can remain relevant longer, but repeated failures still need a limit and a visible final state.
Persist the attempt number and next-attempt time. A worker restart should resume the existing schedule, not send the first retry again. Before scheduling, check whether the message has expired, the recipient has since been corrected, or a successful delivery outcome has already arrived. A later delivery or a user action can make a queued retry unnecessary.
Repeated soft failures should eventually pause for review. A single timeout and several consecutive mailbox-full failures are both temporary classifications, but they do not carry the same operational signal. Keep the reason and history so your team can distinguish an isolated delay from a recurring issue with a particular recipient or domain. If the cause is the message itself, change the content before another attempt instead of applying backoff to an unchanged payload.
Suppress hard-bounced addresses without breaking account workflows
For a permanent failure, prevent routine jobs from repeatedly sending to the same address. Keep an address-level sending status such as hard_bounced, together with the event and timestamp, and check it before queuing a new receipt, reset link, or alert. This is especially important when multiple services can send to the same contact: a suppression check in only one worker leaves another free to repeat the failure.
Do not conflate address suppression with account state. A bounced reset email does not mean the reset succeeded, and a bounced receipt does not undo the purchase. Keep the message marked undelivered and let the user correct the address through your normal account flow. Once the new address is saved and verified according to that flow, create a new send attempt; do not rewrite the original failed message as if it had reached the corrected address.
Volanea handles and suppresses bounces automatically, but the application still benefits from retaining its own link between the failed message and the user action that triggered it. That lets support explain why a user did not receive an alert and lets the application offer an appropriate next step without reporting a false success.
Test this branch without sending real email. Volanea’s sk_test_ keys render and log requests but never deliver them. They can help test template rendering and request logging, but they cannot produce a real recipient-server bounce. To exercise your bounce handler, feed it a synthetic, normalized event fixture such as the JSON above and verify that it records the event, suppresses only the intended address, and handles a duplicate event without applying the action twice.
Protect sender reputation and keep bounce rates visible
Repeated delivery failures can affect sender reputation, so monitor both the volume and the pattern of bounces. Amazon SES recommends staying proactive about delivery issues and monitoring sending status; its deliverability guidance distinguishes persistent hard bounces from temporary failures. Do not turn a single failure into a broad conclusion, but do investigate a sustained rise before it becomes normal operating behavior.
Track hard-bounce rate separately from soft failures, and break results down by message type and recipient domain. For example, if password-reset messages fail while receipts remain stable, inspect the address capture and reset flow first. If multiple message types begin failing at the same recipient domain, investigate the shared delivery pattern rather than changing one template without evidence. Small batches can make a few failures look large as a percentage, so retain counts alongside rates.
Keep product notifications distinct from campaign-list hygiene. A campaign’s aggregate result does not tell you whether a password reset failed for one user, and a campaign cleanup process should not decide whether an account alert is retried. Use different dashboards or filters for transactional events and campaign outcomes so a high-volume campaign cannot obscure a smaller but important application flow.
Volanea’s reputation guard slows sending when a list may harm the sending domain. Volanea also sends over shared Amazon SES infrastructure and does not offer dedicated IPs. That means teams should monitor their own patterns and list quality rather than assuming a dedicated sending IP isolates reputation risk; the guard is a safeguard, not a substitute for investigating repeated failures.
Plans differ by monthly email volume and domain count, and there is no overage billing: sending pauses when the monthly limit is reached. Include that behavior in operational planning. If a pause coincides with an incident, your application should distinguish a volume-limit pause from a recipient bounce rather than grouping both as “email failed.”
Common bounce-handling mistakes
The less obvious failures are often about state consistency, not classification. A handler can correctly identify a hard bounce and still produce confusing behavior if it updates the wrong row, processes the same event twice, or loses the relation between a notification and the user action.
- Retrying a permanent failure. Stop automated attempts to an address reported as persistently undeliverable. Wait for an address correction and handle that as a new send.
- Suppressing every temporary failure. A full mailbox or timeout is not evidence that the address is permanently invalid. Keep it eligible for a bounded retry unless later evidence changes the classification.
- Retrying repeated soft failures indefinitely. Keep the attempt count and reason across worker restarts, then stop or pause when the policy limit or message expiry is reached.
- Marking acceptance as delivery. Record the provider’s acceptance separately from later delivery outcomes. A bounce must be able to update the message without contradicting an earlier “delivered” status that was set merely on API success.
- Applying an event twice. Enforce idempotency at the database or job boundary, not only with an in-memory check. A duplicate notification should not enqueue two retries or repeat a suppression side effect.
- Letting address correction erase history. Keep the original failed attempt and create a new attempt for the corrected address. That preserves a useful timeline for support and for future debugging.
For each message type, write down the state transitions and the action allowed at each state. A password-reset message might move from accepted to bounced and then retry_scheduled or undeliverable; a receipt may instead remain a completed purchase with an unresolved email status. That small state model is more useful than a single email_sent boolean.
FAQ
What does it mean when an email bounces?
The recipient’s mail system reported that it could not deliver the message, and the sending service relayed that outcome. The original request may have been accepted by the service before the bounce arrived. For example, a password-reset request can exist in your application while its email is marked undeliverable, so acceptance should not be displayed as confirmed delivery.
When should I switch from retrying to asking the user to act?
Stop when the message expires, your retry policy is exhausted, or repeated temporary failures need investigation. For a reset link, an expired link should not keep generating attempts; offer a fresh request after the user confirms or corrects the address. For a receipt, preserve the purchase and offer another way to access the record if delivery remains unresolved.
What happens if a bounce arrives after I have queued a retry?
Before the retry worker sends, re-read the message state and check for a later delivery or bounce event. If the message is already resolved, cancel the queued attempt. If the new event is a permanent failure, stop the retry and apply suppression. This state check prevents stale queue jobs from sending after the application has learned that another action is needed.
How is a transactional message different from a marketing email for bounce handling?
A transactional message follows an application event, such as a purchase or password-reset request, so its failure should update that event’s delivery state. A marketing campaign is sent to a broader audience and is managed through campaign-level list and engagement processes. Keep their metrics and remediation paths separate so campaign results do not hide failures in critical account messages.
Start free with 1,000 emails a month