Thesis

Accepted is not delivered.

Why email infrastructure stopped at the handshake, what actually decides inbox placement, and what we built for the gap in between.

The Sendlib teamOctober 20269 min read

Three events, one green bar

When you send an email through an API, three separate things happen, and they are not the same thing.

First, the API accepts your request. You get a 202 and an identifier. The vendor has the message. Nothing has left the building.

Second, the vendor’s mail server opens a connection to the recipient’s mailbox provider, has an SMTP conversation, and the provider either takes the message, defers it, or rejects it. If it takes it, the message is delivered, in the only sense that word has ever meant in the protocol: the receiving server said 250 OK.

Third, the provider decides what to do with it. Inbox, promotions tab, spam, or silent discard. That is placement, and no server on your side of the connection is ever told the answer directly.

Most dashboards collapse the first two into one number and never mention the third. The result is a delivery rate that measures how reliably the vendor accepted your traffic, dressed up as a measure of how reliably your customers received it. It is not lying, exactly. It is answering a question nobody asked.

How the industry got here

The email API companies of the late 2000s did something genuinely useful. They took a protocol that required running your own mail servers, managing IP reputation, and reading RFCs, and turned it into a single HTTP call. The SDKs were good. The dashboards were good. Sending became easy, and the business of email became the business of sending.

But the hard part of email was never sending. The hard part is what Gmail, Microsoft, and Yahoo do with your mail after they receive it, and how they adjust their behaviour toward you over time based on what you send and who complains. That part did not get easier. It got outsourced to a role: the deliverability specialist, a person with a spreadsheet, a few Postmaster Tools logins, and a support ticket open with the vendor asking what the provider actually said.

Infrastructure optimised for the part it could measure. Everything after the handshake became the customer’s problem, and the industry built a services tier to sell the customer help with it.

What is actually happening after the handshake

It is worth being concrete, because the details are the argument. Here is a single message to a Gmail address on an ordinary afternoon.

message timeline · msg_01HP3GZK7E3D2C4P2J6Q1E9N2X

delivered
14:22:08.012  accepted    202 · Idempotency-Key inv-2026-1042
14:22:08.015  queued      lane transactional · pool txn-eu-1
14:22:08.089  attempt 1   alt1.gmail-smtp-in.l.google.com
14:22:09.201  deferred    421-4.7.28 Our system has detected an unusual
                          rate of unsolicited mail originating from your IP
14:22:09.204  pacing      gmail.com budget −10% · retry in 30s
14:22:39.003  attempt 2   alt2.gmail-smtp-in.l.google.com
14:22:39.445  delivered   250 2.0.0 OK 1708784559 b7si2q - gsmtp
Seven events. One of them is Gmail telling you, in writing, that it thinks your IP is sending too much. Your incumbent's dashboard reports this message as delivered, which is true, and tells you nothing else.

Every one of those lines exists in the vendor’s mail server logs. The 421, the enhanced status code, the hostname of the MX that answered, the thirty-second gap. The vendor has all of it. The question is whether you do.

Multiply this by a few million messages a day and the deferrals stop being noise. They are the earliest signal you will ever get that a provider is losing patience with you. They arrive hours or days before the spam-folder placement shows up in engagement metrics, and weeks before anyone opens a ticket. A sender who can see deferral rates per provider, per IP, per stream, in real time, is operating a different business from one who cannot.

Three claims

We built Sendlib around three claims. They are opinions, and we hold them strongly.

1. Evidence is the product

If the SMTP conversation is the ground truth about what happened to a message, then the job of an email API is to deliver that conversation to you, not a summary of it. Every attempt, every response code, every MX, every retry, as typed events, pushed to your systems as they happen and queryable afterwards. A delivery event with no reason attached is a rumour.

This sounds obvious. It is also almost nobody’s default, because it is expensive to store and awkward to show on a dashboard, and because a green bar sells better than a log.

2. Deliverability is a control problem

Every experienced deliverability person knows the rules: ramp new IPs gradually, slow down when a provider defers you, never send promotional volume in front of transactional, honour suppressions without exception. The rules are not the hard part. The hard part is that they are enforced by people, on Monday, after the campaign already went out at 2am on Saturday.

Rules that matter belong in the pipeline. A warmup schedule should be a policy the system enforces per provider and per pool, with adaptive slowdowns when deferrals rise. Suppression should be checked at the moment a message is accepted, not discovered in a bounce report. Pacing should be a budget the queue respects, not advice in a help-centre article. When the policy lives in the infrastructure, the 2am campaign gets slowed down by the system, and the person reads about it on Monday instead of discovering it.

3. Isolation is a right, not an enterprise tier

Reputation is per IP and per domain. On a shared pool, the sender next to you with a 0.4% complaint rate is, as far as Gmail is concerned, partly you. Transactional mail that shares a queue with promotional mail waits behind it when the provider throttles. A platform sending on behalf of a thousand tenants has a thousand reputations to protect from each other.

So the pipeline separates things by default: transactional and promotional traffic run in different lanes with different budgets and different reputations. Pools are yours. Tenants are isolated down to the database. This is not a premium feature. It is how the system is shaped.

What this means if you send a lot

Nobody should migrate a large program on faith, least of all to a new vendor. The right way to evaluate a claim like ours is to run it in parallel. Move one stream. Send the same kind of traffic to the same providers through both pipelines. Put our timelines next to their dashboard and see which one explains the week you just had.

The ritual of asking support what Gmail said goes away, because it is in the event. The warmup spreadsheet goes away, because it is a policy. The argument about whether the campaign hurt the receipts goes away, because they never shared a lane.

What we do not claim

Mailbox providers still make the final decision about placement and always will. We do not have a trick that changes that, and we would not trust anyone who said they did.

What we have is a pipeline that makes the provider’s decision legible and gives you levers that act on it before it becomes a reputation problem. That is a narrower promise than “99.9% deliverability”. It is also one we can keep.

Accepted is a receipt for a promise. Delivered is the promise kept. We built the infrastructure for the gap between them.

If you send millions of messages a month and your dashboard has stopped explaining things, talk to one of our engineers. If you are just getting started, the big vendors will serve you well, and we would rather say so than waste your week.

Compare the evidence on one of your streams.

Tell us your sending domain and current provider. An engineer will come back with a parallel-run plan, usually within one business day.

What happens next

  1. We review the domain

    Every sender is vetted before it sends. A small, clean network is part of the product.

  2. We provision the environment

    Scoped keys, SMTP credentials, DNS records for SPF and DKIM, a webhook endpoint to test against.

  3. You move one stream

    Usually sign-in codes or receipts, measured against its objective from the first message.

The first call is with an engineer, not a sales script. We ask about your streams before we talk about us.