Mail Round Trip Time: Measure It, Catch SMTP Failures
Key takeaways
- Mail round trip time is the elapsed time between sending a test email and confirming its arrival in a test mailbox via IMAP.
- A 250 SMTP response only confirms queue acceptance, not final delivery, so URL and port checks miss silent mail failures.
- Measure round trip time by timestamping three events: send, SMTP acceptance, and IMAP retrieval.
- Greylisting causes 5-10 minute delays on first probes, so require consecutive failures before paging to avoid false alarms.
- Healthy round trips complete in 5-30 seconds; alert on latency trends and repeated misses, not single slow samples.
Mail round trip time is the elapsed time between your system sending a test email and your monitor confirming its arrival in a dedicated test mailbox via IMAP. It's the only check that proves your entire SMTP pipeline, from outbound relay to final delivery, actually works, catching the silent failures a URL ping never sees.
What is mail round trip time?
Mail round trip time is the elapsed time from when a test message is handed to an SMTP server until it is confirmed retrieved from the destination mailbox. It covers the full delivery path, not just the send.
The distinction matters because SMTP is a two-stage protocol. When a server returns a 250 response, that confirms acceptance for relaying, not final delivery to the recipient's mailbox. SMTP is explicitly defined as a hop-by-hop, store-and-forward protocol, so acceptance and delivery are separate events (RFC 5321, SMTP definition). A message can pass the first stage and still fail silently in the second, which is why a round-trip check that includes retrieval catches failures URL pings never see.
StatusPulse's email probes (probe-email) measure exactly this loop: send, wait, retrieve, timestamp.
How is mail round trip time measured end-to-end?
Mail round trip time is the total elapsed time from the moment a probe sends an email to the moment that same email is retrieved from a test mailbox. You measure it by timestamping three events: send, acceptance, and retrieval. The difference between the first and last timestamp is your round trip time, and each stage contributes a different slice of latency.
Stage 1: SMTP send and queue acceptance
The probe opens an SMTP connection, issues MAIL FROM, RCPT TO, and DATA, and records the server's 250 acceptance response. This stage is usually fast, under a second if the receiving MX is healthy. What you're confirming here is that DNS resolves, the port is open, TLS negotiates, and the mailbox exists. A timeout or 4xx response at this stage means the problem is at the edge, not deeper in the delivery chain.
Stage 2: Relay and greylisting delays
After acceptance, your message sits in queues and may hop through several relays before it reaches the mailbox. Two things inflate this stage: greylisting, where receivers deliberately defer first-time senders by a few minutes, and spam filtering queues. Greylisting is why a single round trip test can show 5-10 minutes while subsequent tests from the same sender show seconds. Your monitor needs to distinguish a one-off greylisting delay from a persistent delivery failure, or you'll chase false alarms.
Stage 3: Delivery confirmation via IMAP or POP
The final stage polls the test mailbox over IMAP or POP, searching for the message ID the probe generated. The timestamp of that retrieval closes the loop. Polling interval sets your measurement floor: if you check the mailbox every 60 seconds, your reported round trip time includes up to a minute of waiting that isn't real latency. A protocol-level probe with tight polling gives you a number you can alert on; a URL check gives you nothing. We break down the full probe setup in our email monitoring guide.
Why URL checks miss silent SMTP delivery failures
Your HTTP check hits the web server and gets a 200. Mail delivery happens on a different port, through a different protocol, with a different failure mode: your monitoring shows green while every outbound email is bouncing or vanishing.
The 250 OK trap
When your app hands a message to your SMTP server, the server replies with a 250 acceptance code. Most URL-based or port-based checks treat that 250 as success. But 250 only means your server accepted the message into its queue. It says nothing about whether the message was ever delivered to the recipient's mailbox, passed their spam filters, or cleared greylisting. Postfix documents this explicitly: accepted mail can sit in the queue for extended periods while the server retries deferred deliveries, with no signal back to your app (Postfix documentation).
Where messages silently die
After the 250, several things can fail without any alert your current monitors would catch:
- Greylisting and queue deferrals: the receiving server rejects the first attempt and expects a retry; if your retry schedule is broken, the mail expires in your queue.
- Spam-folder black holes: the message is delivered, technically, straight to spam. No bounce, no error, no NDR.
- Auth and quota failures: an expired SMTP credential or a full mailbox quota produces errors only visible at the protocol level, not at the URL level.
The only check that catches all three is a full round trip: send a real message to a probe mailbox and confirm it arrives. That is what round-trip monitoring measures, and why a green uptime dashboard is not proof your mail works.
How to build a round-trip email monitor: step-by-step
A round-trip monitor needs four moving parts: a send address, a destination mailbox, a script that ties them together, and an alerting hook. You can assemble all four in an afternoon. Here is the vendor-neutral version of the setup.
Step 1: Create a dedicated test mailbox and send address
Create a mailbox like probe@yourdomain.com on the same mail infrastructure your customers depend on. If your product sends transactional email through a third-party provider, route the probe through that provider, not your personal Gmail. The point is to exercise the exact path a customer email takes: your app, your SMTP relay, the receiving MX, and the inbox.
Step 2: Send a tagged probe on a schedule
Every 5 minutes, send a message to roundtrip@yourdomain.com with a unique tag in the subject, for example [probe-20250611T0915]. Use a cron job, a GitHub Actions schedule, or your existing job runner. The tag matters because IMAP search will match on it, and it lets you detect stale probes from a previous run.
Step 3: Poll the destination mailbox via IMAP and match the tag
Sixty seconds after each send, log in over IMAP and search the destination mailbox for that tag. If the message is there, mark the probe as delivered and delete it. If it is not, retry the poll on an exponential backoff (60s, 120s, 240s) before declaring the probe failed. This retry ladder is what separates a real outage from normal queueing delay.
Step 4: Compute round trip time and record it
Round trip time is delivery_timestamp - send_timestamp, measured per probe. Write each result to a small time-series store, even a CSV or SQLite file, with the tag, the latency, and the outcome. Keep 30 days of data so you can spot drift, not just outages. For a worked example of the full send-to-delivery path, see our guide on email round trip monitoring and message delivery guarantees.
Step 5: Wire alerts to PagerDuty or Slack
Fire a PagerDuty event when two consecutive probes fail, which filters most false positives from a single dropped message. Post every result to a Slack channel so the team sees latency trends without paging. If latency exceeds your threshold for three consecutive probes, escalate that too: slow delivery is usually the first symptom of a throttled relay or a blacklisted sending IP, and it shows up minutes before hard failures do.
What alert thresholds should you set for round-trip monitoring?
Set two latency bands and require consecutive failures before paging anyone. A single slow delivery is noise; three in a row is an incident.
| Signal | Warning | Critical |
|---|---|---|
| Round-trip latency | > 120s | > 600s |
| No delivery confirmation | 2 consecutive misses | 3 consecutive misses |
| IMAP fetch failures | 2 in a row | 3 in a row |
Greylisting is the main source of false positives. Many MTAs temporarily reject first contact from an unknown sender with a 4xx response and expect a retry minutes later, so a probe that treats one deferral as downtime will cry wolf. Either allow one automatic retry before counting a failure, or set your warning threshold high enough (120s covers most greylist delays) that a normal deferral never triggers an alert. Postfix's greylisting behavior and retry conventions are documented in its configuration docs.
Poll your round-trip mailbox over IMAP rather than waiting for push, and keep polling intervals well above your warning threshold so a slow fetch never masquerades as a delivery failure. IMAP semantics for flagging and retrieving delivered messages are defined in RFC 3501 (https://www.rfc-editor.org/rfc/rfc3501).
We run the same thresholds in StatusPulse's email probes, and the honest gap: our free tier's 5 probes means one round-trip test consumes a fifth of your quota, so larger mail infrastructures need the $19/mo Pro tier. The mechanics are covered in more depth in our guide to monitoring SMTP/IMAP round trips.
What does normal mail round trip time look like?
Most round-trip deliveries complete in 5-30 seconds when the receiving mailbox accepts immediately. Gmail and Microsoft 365 both fall in that band for direct SMTP acceptance, so treat anything under a minute as healthy. Google's IMAP polling limits mean clients that fetch via IMAP rather than SMTP delivery can add minutes of lag, which is measurement noise, not an outage (Google IMAP documentation). Greylisting is the big caveat: some receivers reject the first attempt with a temporary 4xx and expect a retry minutes later, so a single 2-5 minute round trip is normal for those domains. Anomalies look like this: retries exhausting after 15+ minutes, repeated timeouts to one provider while others deliver fine, or round trips that used to take 10 seconds suddenly taking 90. Alert on the trend, not one slow sample.
Build vs buy: DIY scripts vs managed round-trip probes
A DIY cron job plus an IMAP mailbox is the cheapest path: a script sends a message, polls for the delivery, and alerts if the round trip exceeds your threshold. Total cost is your mail server and an hour of maintenance. The tradeoffs are real: no retry logic when your own SMTP is the thing that's broken, no incident history, no public status page, and you become the on-call for the monitor itself. If the script fails silently, you find out from a customer.
Open-source options like Uptime Kuma cover HTTP checks well, but round-trip mail probes usually still mean gluing the script together yourself.
Managed probes handle the send, the delivery confirmation, retries from a second region, and escalation to PagerDuty, at $5-19/mo on StatusPulse versus $25-85/mo for Better Stack's bundle. The honest gap on our side: we don't yet do per-mailbox routing rules or custom IMAP servers, so if your round-trip test must land in a specific internal mailbox rather than our probe address, a DIY script still wins today. Pick DIY when mail is your product; buy when it's one of several things that can silently fail.
FAQ
Does a round-trip test detect emails landing in spam?
Not reliably. A message delivered to the spam folder is still retrievable over IMAP, so the round trip completes and looks healthy. To catch spam-folder black holes, check whether the message landed in the inbox or spam folder, or alert on latency trends, since throttled or flagged senders usually slow down before vanishing entirely.
What's the difference between SMTP monitoring and round-trip email monitoring?
SMTP monitoring checks that your server accepts connections and returns a 250 response, which only confirms the message entered the queue. Round-trip monitoring sends a real tagged message, then retrieves it from a destination mailbox over IMAP and timestamps the loop. Only the second approach proves the message actually reached a mailbox, not just that a relay accepted it.
Can I monitor email delivery without access to the recipient mailbox?
No. Without IMAP or POP access to a mailbox at the destination, you can only confirm the 250 acceptance, which says nothing about final delivery. The practical workaround is a dedicated probe mailbox you control, routed through the same relay and receiving path your customer mail takes. Provider dashboards show aggregate stats, not per-message confirmation.
Why is my round trip time high even though SMTP returns 250 OK?
A 250 means your server accepted the message for relaying, not that it was delivered. After acceptance, the message sits in queues, hops through relays, and may hit greylisting, where receivers defer first-time senders by minutes with a temporary 4xx. A 5-10 minute round trip on a first probe is normal; persistent highs across repeated probes point to a throttled relay or blacklisted IP.