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
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 - gsmtpEvery 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.
