How an Email Travels from Your Outbox to Their Inbox: Delivery Basics and Spam Classification
"Why did my email land in their spam folder?" The question keeps coming back because most people carry a mental model of email with exactly one step: click send, then wait for an outcome. The real process is a chain with several links, and a failure in any one of them produces a different symptom.
What makes it harder is how unevenly those symptoms surface. Some failures return an error code instantly. Some produce a bounce minutes later. Some leave the message stuck at "sending" indefinitely. And some — the most common case of all — tell you nothing at all, and the mail simply disappears.
This guide splits the chain into seven stages and explains the mechanics of each instead of just naming them: what the stage does, how it completes normally, and what you see when it fails. It then separates the two sender identities that people constantly confuse, walks through the signals a receiver's anti-spam system actually weighs, and closes with a table that maps symptoms back to stages.
After reading, you should be able to point at a specific stage for a specific problem instead of filing everything under "email is broken." For the domain side of name resolution, see Domain DNS Records Basics; for server parameters, see SMTP Configuration Guide; and for the authentication layer that decides whether your domain is allowed to send at all, see SPF/DKIM/DMARC Configuration.
1. Delivery Is a Chain of Seven Stages
1.1 Stage One: Composition and Submission
The first stage happens between your mail client and the submission server that client belongs to. When you click send, the client does not hand the message to the recipient's server directly. It first hands it to a submission server — usually your mailbox provider, or the sending platform you are using.
Strictly speaking, this stage is not SMTP transport but SMTP in its submission role: the client authenticates first (password, app-specific password, OAuth token), and only after the server is satisfied that the account may send through it does it accept the message. The port is usually 587 with a STARTTLS upgrade, or 465 with TLS from the start.
Many later problems are seeded right here. The From header, Message-ID, and Date the client writes become the raw material for every downstream judgment. If the client writes a From domain the server neither recognizes nor is authorized for, no amount of later fixing will satisfy the receiver. With self-hosted sending, the classic mistake in this stage is confusing it with receiving: assuming that working IMAP/POP means mail can also go out, when the account model, ports, and authentication are all separate.
Another detail that gets overlooked is encoding. Non-ASCII subjects, bodies, and emoji all need correct encoding (typically UTF-8 with quoted-printable or base64). Clients handle this automatically, but when you assemble messages by script or with an old library, an encoding mistake shows up as a garbled subject on the receiving end — and garbled text is itself a suspicious feature to a spam filter.
1.2 Stage Two: Submission Authentication and Limits
Before accepting the message, the server runs a set of checks. When these fail, the result is an immediate error: the client shows it, and the message never leaves your account.
There are roughly four groups. The first is identity and authorization — whether the account is valid, whether sending has been restricted, whether risk controls have fired. The second is sender validation: many providers require that the From domain in the submission be a domain you have verified, and reject otherwise. That is the first gate preventing a platform from being used to impersonate someone else. The third is limits: daily volume, hourly volume, recipients per message, attachment size. The fourth is content policy, where some platforms refuse clearly prohibited attachment types outright.
Limits cause the most trouble for business systems and are the most often misdiagnosed. You may see "send failed: daily quota exceeded" while the business side reads it as "the mail system is down." The real cause is often a code path re-triggering notifications in a loop and consuming the quota. So the first thing to check when this stage fails is not DNS but the sender's logs and quota usage.
It is worth emphasizing that this is the only stage in the whole chain where failure is guaranteed to be reported clearly. If you already have an explicit error, the problem is almost certainly here and there is no need to look further down.
1.3 Stage Three: Queues, Retries, and Backoff
This is the most important stage in the article, because it explains why "sent successfully" does not mean "delivered."
After the submission server accepts a message, it does not deliver it immediately. It places the message in an outbound queue, and a queue manager attempts to reach the recipient's server. The reason is that networks and remote services are unreliable: the receiving server may be restarting, throttling, or temporarily refusing mail. Delivery is therefore asynchronous, and every message in the queue carries a state.
On failure the queue retries, and it does not spin in a tight loop. It backs off: the first attempts come minutes apart, later ones stretch to tens of minutes and then hours, continuing for tens of hours in total. Exact policies differ by provider, but the direction is the same — leave the remote side a window to recover. Only after the retry window expires is a bounce generated and returned to you.
That produces a very common mismatch in expectations: a sending platform reporting "sent" (accepted) means only that it took responsibility for delivery, not that the recipient's server took the message. In most event models this state is called accepted or queued. The actual "delivered" state is a separate event that may arrive seconds later, or never.
The right way to read this: the queue separates your action from the delivery outcome in time. The success you see in a dashboard is the success of the action, not of the outcome. To judge the outcome you must look at delivery events, not at the return value of the send call. For how to observe those events and logs, see Deliverability Monitoring Tools.
2. Finding the Recipient: DNS and Connection
2.1 Stage Four: DNS Lookup and MX Records
To deliver, the queue first needs to know which machine to talk to. It takes the domain after the @ in the recipient address and queries DNS for that domain's MX records (Mail Exchanger). MX records are ordered by priority, and the queue starts with the highest priority host.
This stage has three outcomes that differ a great deal.
A successful lookup gets a target hostname, and the process moves on. Note that MX records usually point at hostnames rather than addresses, so a second resolution is required — and a failure there is just as fatal.
No MX record: most senders fall back to the domain's A record, meaning they try the machine hosting the website. If nothing there listens for mail, the connection fails and the message eventually bounces.
Domain does not exist (NXDOMAIN): delivery ends immediately with a bounce. This is a hard bounce because retrying cannot help — the domain was never registered, or it is misspelled.
The practical implication people miss: an expired domain or an unpaid DNS provider breaks inbound mail before it breaks the website. A site that fails to load may just have a certificate problem, but missing MX records mean every message addressed to the domain cannot arrive, and the only signal is a hard bounce delivered to whoever sent it. You see nothing. This is why domain renewal and DNS hosting deserve incident-level attention rather than being treated as billing housekeeping.
2.2 Stage Five: Connection and SMTP Transfer
With the target address in hand, the sender opens a TCP connection to port 25 on the receiving host and starts an SMTP session. The session itself is plain question and answer: identify yourself (HELO/EHLO), declare the envelope sender (MAIL FROM), declare the recipient (RCPT TO), confirm readiness (DATA), write headers and body, then end with a line containing only a period and wait for the reply.
During this exchange the receiving server has several chances to refuse: after MAIL FROM (usually because your IP or domain reputation is poor), after RCPT TO (usually because the recipient does not exist or a blocking rule matched), or after DATA (because the content was classified as spam). The business meaning of these three refusals is completely different, and the position in the log is your clue.
This stage also runs into a structural obstacle of the modern internet: many cloud hosts and residential connections cannot open outbound connections to port 25 by default. Cloud providers do this for anti-abuse reasons — if any instance could reach port 25 directly, spammers would immediately use it as the cheapest possible relay. The result is that a self-hosted SMTP server on a cloud instance trying to deliver to external domains will time out or be refused, and the log typically shows only "connection timed out" with no explanation.
That is exactly why the least painful path for business mail is a professional sending service, which completes this stage on your behalf, rather than running SMTP yourself. For how platforms differ, see SendGrid and Mailgun Setup Guide. If you genuinely need self-hosting, requesting that outbound port 25 be unblocked is a viable route, but expect a provider review, and remember that the egress IP still starts with no reputation history of its own.
3. The Receiving Side: Filtering, Storage, and Retrieval
3.1 Stage Six: Spam Filtering and Classification
Once the message reaches the recipient's server, the stage that actually decides inbox versus spam begins. Its defining characteristic is that the decision is usually not reported to you.
Filtering systems combine multiple signal families into a score: sender IP and domain reputation, SPF/DKIM/DMARC results and alignment, content features (link-to-text ratio, image-to-text ratio, suspicious terms, shortened links), sending patterns (volume and recipient distribution from one IP in a short window), and the historical behavior of recipients toward this sender. The combined score lands in one of three buckets: deliver to the inbox, deliver to the spam folder, or discard.
The third bucket is silent dropping. From the sending side it looks identical to delivery: the SMTP session may even have returned acceptance after DATA (some systems deliberately accept first and discard later so that spammers get no feedback signal), the queue marks delivery complete, the event feed shows delivered, and the recipient never sees the message.
So even a delivered event is the receiving server's claim, not the user's confirmation. The only way to know what really happened is for users to actually look — or to infer the overall trend from aggregate reports and reputation dashboards. The mechanics of classification get a full treatment in the next chapter.
3.2 Stage Seven: Delivery to the Inbox and Retrieval
The last mile happens inside the receiving system: after filtering releases the message, it goes to an MDA (mail delivery agent), which writes it into that user's mailbox store — a file or directory in classic architectures, a row in a database or an object in storage in modern ones. This step checks whether the mailbox is over quota, whether forwarding rules apply, whether an auto-reply is configured, and whether the user's personal blocklist matches.
Failure here produces a soft bounce: mailbox full, over quota, temporarily undeliverable. These errors trigger retries, so once the user frees space the message may still arrive — a soft bounce is not a lost message. But if nothing is cleaned up, the retry window eventually expires and it becomes a hard bounce.
Once stored, how the user sees the message depends on the retrieval protocol. IMAP keeps mail on the server and syncs only state, so multiple devices see the same data and read flags and folder moves propagate back to the server. POP3 downloads mail to the local device and deletes it from the server, which suits a single-device account.
That division has real diagnostic value: if a user's client uses POP3 with "delete after download" enabled, not finding the message on the server does not mean it never arrived — it may already sit in a local folder. Deciding whether a message arrived means reconciling evidence on the server side (logs, mailbox store) with evidence on the client side (local folders), not simply asking the user "did you get it?"
4. Envelope and Header: Two Sender Identities
4.1 The Division of Labor Between Return-Path and From
An email contains two "senders," they are not the same thing, and the protocol allows them to differ. This is the root of most confusion about email authentication.
The envelope sender is written in the SMTP session's MAIL FROM and is recorded by the receiver as the Return-Path header. It decides two things: where bounces go, and which domain SPF is checked against. It is a transport-layer concept, and users never see it in their inbox.
The header sender is written in the From header, and it is the name and address a user sees in the message list. It decides who the user believes sent the message, and it is the domain DKIM's d= is normally expected to align with.
So the correct reading is: SPF checks the envelope; the user sees the header. A domain can pass SPF entirely legitimately — because the envelope domain is one it authorized — while the From header carries someone else's brand. That is the most common shape of impersonation, and it is precisely the gap DMARC exists to close by comparing the two.
In practice, when you send through a third-party platform, Return-Path often lands on a subdomain the platform assigns for bounce collection while From is your own domain. In that configuration SPF passes, DKIM passes, but the SPF side does not align with From — so DMARC either passes via DKIM alignment or fails outright. Only by understanding this division can you make sense of the rows in a report that say spf=pass while also saying dmarc=fail.
4.2 How to Read the Received Chain
The Received headers are the only evidence that can reconstruct the real delivery path. Every server that handles the message prepends a Received line recording who it is, who it received from, over which protocol, and when.
The reading order is therefore bottom to top. The lowest line is the hop closest to the sender; the topmost line is the hop closest to the recipient — the last server to process the message. Read it the other way and you will mistake the origin for the destination, inverting the conclusion.
The timestamps inside each Received line are the key diagnostic. A gap of a few minutes between adjacent hops means queueing or retrying. A gap of hours means the sender backed off. A hop whose timestamp is obviously earlier than the others usually means that server's clock is not synchronized.
Equally important is the Authentication-Results header, written by the receiving side, recording the verdict that server reached for SPF, DKIM, and DMARC individually. When you see dmarc=fail, combining it with the Received chain tells you whether the cause is the origin's configuration or a relay in the middle breaking the signature. For how these diagnoses map onto specific bounce codes, see Email Bounce Reason Analysis.
5. What Anti-Spam Systems Actually Look At
5.1 Sender Reputation: The History of an IP and a Domain
Reputation carries the highest single weight, and it is where new domains and new IPs are worst off. Receivers maintain IP reputation and domain reputation separately and consult both.
IP reputation reflects long-term sending behavior from an address or range: whether volume is stable, how high the bounce rate runs, whether users have hit "report spam," and whether the range appears on public blocklists. The problem with shared IPs is that you cannot control what others on the same address do. The problem with dedicated IPs is that you must build history from zero, and early damage takes a long time to repair.
Domain reputation looks at domain age, whether authentication is complete and stable, whether the volume curve is smooth, and whether the complaint rate stays low over time. That explains why "a brand-new domain sending ten thousand messages on day one" almost always fails: it scores zero on every reputation dimension while sending at maximum volume.
Reputation updates continuously. Climbing takes time; falling takes one incident. Operationally the important question is therefore not "how do I raise reputation fast" but "how do I keep it from dropping" — which is why cold outreach and new-domain warming need dedicated design. See Cold Email Sending Strategies.
5.2 Authentication Results, Content Signals, and Complaint History
Authentication results rank just below reputation, but they have a special property: they distinguish "who you are" from "we are not sure who you are," not "good" from "bad." Passing authentication does not guarantee the inbox, but failing it almost always costs points. That is why complete SPF/DKIM/DMARC is a necessary condition rather than a sufficient one. For the latest evolution of the specifications, see DMARC Specification Update.
Content signals are the family everyone knows and routinely overrates: suspicious terms, all-caps subjects, excessive exclamation marks, image-heavy layouts with little text, links whose domain differs from the sending domain, shortened URLs, unusual attachment types. Individually none is fatal; in combination they trigger interception.
Complaint history is a hard metric. One "report spam" click is an explicit negative vote, and its impact is far larger than simply not opening. Most sending platforms treat a complaint rate around one in a thousand as a warning line, at which point you should stop and investigate the source — not the content, but the list. Why are these people receiving this message at all?
5.3 User Behavior Signals
This is the one many people do not know about, and it carries high weight.
Receivers can observe how each user treats each message: open, click, reply, star, move to inbox, move to spam, report, delete unread. From those actions they infer whether this sender is valuable to this user, and that inference is more accurate than any content analysis. Replies and stars are the strongest positive signals; moving a message back to the inbox is an explicit correction saying the classification was wrong; never opening and deleting is slow negative accumulation.
The practical conclusion is direct: list quality matters more than content quality. Sending to people who do not want the mail accumulates negative behavioral signals even if the copy is excellent, and eventually drags down the whole sending stream. A small engaged list, by contrast, holds domain reputation firmly in place.
This also explains why re-engagement campaigns are inherently risky: dormant users are defined by long-term non-interaction, so blasting the entire dormant segment manufactures a large batch of negative signals on purpose. The safer approach is to probe in small batches and continue only with those still showing opens, rather than pushing the whole segment at once. For segmentation and list hygiene, see Email Deliverability Optimization.
6. Three Common Misconceptions
6.1 Assuming an SMTP 250 Means Delivered
250 is an SMTP status code meaning "I accepted this step." But acceptance happens at different points in the session, and the meanings differ: a 250 after RCPT TO only means "I accepted this recipient"; a 250 at the end of DATA only means "I took the message and will handle it." It does not mean filtering has passed, does not mean the message has been stored, and certainly does not mean the user will see it in the inbox.
More subtly, some systems deliberately return 250 for suspected spam and discard it afterwards, precisely so the sender gets no feedback signal and cannot probe the rules. Treating 250 as proof of delivery is treating "the envelope was accepted" as "the message was read."
The correct approach is to rely on delivery events and downstream feedback: the distribution of delivered, bounce, and complaint events in the platform, the pass rate in aggregate reports, and real opens and replies from users. Protocol-level and business-level evidence must be read separately.
6.2 Assuming the Spam Folder Means a Content Problem
Content does trigger interception, but in real incidents content problems are far less common than identity and reputation problems. When mail lands in spam, the investigation order should be: is authentication complete and aligned, then is IP and domain reputation healthy, then is the list source and complaint rate normal, and only then content.
Reversing that order wastes enormous time: you rewrite copy, change subjects, remove images, while the actual cause is broken DMARC alignment or a blocklisted IP range. A useful discriminator is to compare across recipient domains. If every receiver puts you in spam, it is likely identity or reputation. If only one does, it is that provider's rules or your list. If only one batch does, it is that batch of addresses or that sending window.
6.3 Assuming a New IP Fixes Everything
Switching IPs genuinely helps in specific cases — for example, when you share an IP with someone sending bulk unsolicited mail and get tarred with it. Moving to a clean IP improves things immediately there.
In more cases, switching only makes it worse. A new IP has no reputation history and receivers treat it conservatively; switching before the problem is diagnosed replaces "tainted but with history" with "no history at all" and throws away the data you would have used to diagnose. Worse, the reputation subject is not only the IP but also the domain. If the issue is domain reputation — a persistently high complaint rate, or the domain appearing on a list — a new IP changes nothing. The test is whether failures cluster by IP or by domain in the reports; switching without running that test is a gamble.
7. From Symptom to Investigation Path
7.1 Symptom to Stage
Chaining the stages together yields a reverse index. Locate the stage first, then read the details for that stage; it is much faster than trial and error.
| Symptom | Most likely stage | Check first |
|---|---|---|
| Client shows an error instantly, message not sent | Stages 1-2: submission and auth | Account permissions, quota, whether the From domain is verified |
| Platform says sent, but no subsequent events | Stage 3: queue | Queue backlog, whether it is backing off |
| Bounce saying the domain or recipient does not exist | Stage 4: DNS | MX records, recipient address spelling |
| Connection timeout or connection refused | Stage 5: connection | Whether outbound port 25 is restricted, whether the peer is throttling |
| Platform says delivered, recipient says otherwise | Stage 6: filtering | Authentication alignment, IP and domain reputation, spam folder |
| Bounce saying mailbox full | Stage 7: storage | Recipient quota, whether retries continue |
| Report shows spf=pass but dmarc=fail | Envelope versus header | Whether the Return-Path domain aligns with From |
The value of the table is not completeness but the habit of mapping symptom to stage: the shape of the symptom is itself informative. An instant error means you never left submission. A failure that takes hours means the queue backed off. A failure that reports nothing at all means the problem sits in the stage that deliberately does not answer.
7.2 Investigation Order and Ongoing Monitoring
Following a fixed order avoids wasting time in the wrong direction. First, check the sending-side logs: any refusals, any quota problems, what the event state distribution looks like. Second, check authentication: whether the three records still exist, whether they align, whether a selector has gone stale. Third, look at the bounce and complaint distribution grouped by recipient domain, by sending IP, and by batch — anomalies usually cluster in one group. Only fourth do you look at content and list quality.
Ongoing monitoring should track trends, not single points: moving averages of bounce rate, complaint rate, and inbox placement say more than any one day's number. Three signals deserve immediate attention — a sudden jump in volume, an unfamiliar new sending source, and every send to one recipient domain failing at once.
One last point worth remembering: the only stage in this chain that will never tell you anything is the one that most often goes wrong. "No bounce arrived" is therefore never evidence of delivery — only evidence that nobody thought it worth notifying you. Real visibility has to be built yourself: authentication results at the protocol layer, delivery events and user behavior at the business layer. For the full API integration and event model, see Transactional Email API Integration Guide.
Source: 16IDC original. Protocol specifications, client behavior, and platform capabilities follow the relevant IETF RFCs and provider documentation.
Original source: 16IDC Original ↗