HomeResourcesGuides
Practical guide

Checklist to avoid problems with your application's transactional emails

A confirmation that never arrives, an invoice that lands in spam, or an email sent twice can quickly become a customer incident. This guide covers the basic checks to complete before sending transactional emails in production.

When "sent" does not mean the customer received it

Your application runs the send correctly, but the customer says they did not receive the email.

  • Did the message leave the application?
  • Did the provider accept it?
  • Was it delivered to the recipient server?
  • Did it bounce?
  • Was the address incorrect?
  • Was it attempted more than once?
  • Is there any record that proves what happened?

Without the right configuration and traceability, answering these questions can mean digging through logs, manually resending messages, and spending hours on an incident that should take minutes to resolve.

This guide is designed to help avoid those situations before moving to production.

Operational impact

What problems this checklist helps avoid

Incidents that are hard to investigate

When a customer says they did not receive a message, you need to know what happened without relying on assumptions.

Loss of trust

An invoice, purchase confirmation, or access email that does not arrive directly affects how the service is perceived.

Unnecessary support hours

Without clear states, logs, and events, a simple question can involve support, development, and the email provider.

Duplicate or unexpected sends

Retries, queues, and integration errors can generate repeated messages or unplanned sending volume.

Costs and reputation

Repeatedly sending to invalid addresses, ignoring bounces, or generating emails by mistake can increase costs and hurt future deliverability.

Pre-production checklist

Checklist before going to production

Each point explains what to review, why it matters, and which operational problem it helps avoid.

A

Domain identity and configuration

1

Verify the sending domain

Check that the domain is correctly registered and validated in the sending platform.

Problem it avoids: provider rejections, configuration errors, and messages sent from identities that are not ready to operate.

2

Check SPF and DKIM

Review that the provider is authorized to send from the domain and that messages are signed correctly.

Problem it avoids: messages flagged as suspicious, authentication issues, and lower trust from receiving servers.

3

Configure and review DMARC

DMARC helps check that the visible sender identity is aligned with authentication. Start with a monitoring policy when needed and review results before applying stricter policies.

Problem it avoids: spoofing, unnoticed configuration mistakes, and DNS changes that affect delivery.

4

Use a consistent sender

The sender name, visible address, and domain should be recognizable to the recipient. Also review whether replies should go to a different address via Reply-To.

Problem it avoids: distrust, lost replies, and confusion about who sent the message.

B

Recipients and content

5

Validate the address before sending

At minimum, check that the address has a valid format and is not part of a list of recipients that already produced permanent errors.

Problem it avoids: predictable bounces, unnecessary spend, and incorrect data accumulating in the application.

6

Review templates with real data

Check subject, sender, links, required variables, empty or overly long values, special characters, HTML and text versions, and mobile rendering.

Problem it avoids: incomplete emails, broken links, wrong names, and unprofessional messages sent to real customers.

7

Control links and sensitive actions

Access, verification, or recovery links should have a limited lifetime and should not include sensitive information directly in the URL.

Problem it avoids: unauthorized access, reused links, and unnecessary exposure of information.

8

Separate transactional email from marketing

Confirmations, invoices, access emails, and operational notices should not depend on the same flow or rules as a commercial campaign.

Problem it avoids: blocks affecting critical messages, confusing analytics, and preference-management problems.

C

States and traceability

9

Do not mark email as delivered when calling the API

A successful API response usually means the provider accepted the request. Separate pending, accepted, delivered, delayed, rejected, bounced, suppressed, and failed states.

Problem it avoids: incorrectly reporting that an email arrived and being unable to explain what really happened.

10

Store the provider identifier

Connect each internal send with the identifier generated by the email platform.

Problem it avoids: manual searches, difficulty cross-checking information, and lost traceability between the application and provider.

11

Process delivery events

Final states often arrive asynchronously through webhooks or event systems. The application must be able to receive, validate, and use them to update message status.

Problem it avoids: outdated states and the false impression that all accepted messages were delivered.

12

Keep useful logs, but limit sensitive data

Log email type, recipient, date, status, internal and provider identifiers, and error code or category. Avoid storing passwords, access tokens, or unnecessary personal content.

Problem it avoids: long investigations, lack of evidence during an incident, and exposure of sensitive data in logs.

D

Bounces, errors, and retries

13

Separate temporary and permanent errors

A temporarily full mailbox should not be treated the same as a non-existent address. Temporary errors may allow retries; permanent errors should block further automatic attempts.

Problem it avoids: useless retries, additional costs, and continued sending to invalid addresses.

14

Handle bounces, complaints, and suppressions

When an address produces a permanent bounce or a complaint, it should be added to a suppression list or blocked from future sends.

Problem it avoids: reputation damage, repeated errors, and problems with provider limits.

15

Limit and control retries

Define which errors allow retries, how long to wait, how many attempts to make, and what to do after the limit is reached.

Problem it avoids: loops, unexpected costs, and queues full of messages that will never be delivered.

16

Avoid duplicate sends

A timeout or network error does not always mean the provider rejected the message. The integration should prevent the same operation from generating multiple emails.

Problem it avoids: invoices, access links, or confirmations sent several times to the same customer.

E

Operation and control

17

Prioritize critical messages

A password recovery email or access code may need priority over less urgent notifications.

Problem it avoids: delays in important operations when message volume is high.

18

Configure operational alerts

The team should be notified when authentication errors, bounces, rejections, template failures, delays, or sending volume increase.

Problem it avoids: discovering an incident through a customer complaint instead of automatic detection.

19

Test the full process before production

Do not test only the API call. Also check template rendering, event reception, bounces, retries, suppressions, duplicates, alerts, and volume limits.

Problem it avoids: finding out in production that only the happy path was tested.

Real situations

Situations this checklist helps avoid

The application says it was sent, but the customer did not receive it

This often happens when provider acceptance is treated as delivery. Recording real events and states makes it possible to know whether the message was delivered, delayed, rejected, or bounced.

The user received the same email several times

This can happen after retrying a request following a timeout or processing a queued message twice. Idempotency helps avoid duplicates.

An error generated thousands of sends

A scheduled process, queue, or misconfigured event can multiply volume in minutes. Limits and alerts reduce the impact before costs rise.

We keep sending to an address that always bounces

If permanent bounces do not update recipient data, the application repeats the same error. Suppression lists prevent new attempts.

We cannot explain what happened to the customer

Without related identifiers, states, and logs, the team can only check fragments of information across different systems.

Actionable summary

Quick check before publishing

Before enabling real sends, confirm that the critical points are covered and can be checked from your application or provider.

If any of these points cannot be verified, there is still an operational risk worth resolving before going to production.

  • The domain is authenticated.
  • The sender is recognizable.
  • Templates have been tested with real data.
  • Addresses are validated before sending.
  • The application separates acceptance from delivery.
  • Events update message status.
  • Bounces and complaints block future sends.
  • Retries are limited.
  • Duplicates are controlled.
  • Logs allow incident investigation.
  • The team receives alerts for recurring errors.
Mailiqo

Need to manage these controls from one place?

Mailiqo lets you send transactional emails via API or SMTP, validate recipients, and review send traceability.

Learn about Mailiqo
Mailiqo Labs

Put the guide into practice

The tools let you check SPF, DMARC, headers, bounces and HTML with your own data, without registering.