LabHub

Blog

Email Infrastructure 2026 — Resend, Postmark, Loops, SES, SendGrid, Mailgun Deep Dive

2026-05-14 · 24 min read · #email#resend#postmark#loops#ses#sendgrid#mailgun#deliverability#saas-infra#english

한국어English日本語

Prologue — Email Is Not Dead, Just Harder

In 2026, email is still the number-one channel for every SaaS. Password reset links, payment receipts, meeting invites, onboarding sequences, dormant-user re-engagement — no matter how much push, SMS, and in-app grow, those five flows ride on email. The problem is not sending. It is landing in the inbox.

In February 2024, Google and Yahoo tightened sender authentication. Any domain sending 5,000+ messages per day must pass SPF, DKIM, and DMARC. Marketing mail must include 1-click unsubscribe (the List-Unsubscribe-Post header). A spam complaint rate above 0.30% quarantines or rejects the entire domain. Microsoft 365 caught up with similar rules in 2025, and by 2026 even small ISPs run nearly the same playbook. The era of sending without DKIM is over.

Against that backdrop, the email-infrastructure market split into two camps.

  1. Transactional-first — Resend, Postmark, AWS SES. Each send is triggered by a single event: a receipt, a notice.
  2. Email-as-a-product — Loops, Customer.io, Brevo. Sequences, segments, and automation are first-class.

The two overlap. Eventually every SaaS needs both. This piece is about that choice — which tool at which stage, what 10,000 contacts cost per month, how to make Korean ISPs happy — captured in the actual state of things as of May 2026.

1. The Responsibility Line for Email Infrastructure

1.1 What an ESP Does and Doesn't Do

An ESP (Email Service Provider) is more than one SMTP server. Every ESP does:

What an ESP does NOT do:

The key idea: an ESP lends you tools, not outcomes. One bad campaign (a purchased cold list, for example) wrecks your domain reputation. Move to a different ESP and the spam folder follows you.

1.2 SPF, DKIM, DMARC — The 2026 Minimum

Three records in one line each.

Since the 2024 Google/Yahoo guidelines, effectively all three must pass to reach the inbox. That is why Resend, Postmark, and SES domain verification screens look almost identical now. Drop three or four TXT records into DNS, wait an hour, done.

; example.com SPF
example.com.    IN  TXT  "v=spf1 include:_spf.resend.com -all"

; resend._domainkey.example.com DKIM
resend._domainkey.example.com.  IN  TXT  "v=DKIM1; k=rsa; p=MIGfMA0GCSq..."

; _dmarc.example.com DMARC
_dmarc.example.com. IN  TXT  "v=DMARC1; p=quarantine; rua=mailto:dmarc@example.com; pct=100"

Start DMARC at p=none and just collect reports. After 1 ~ 2 weeks of monitoring, move to p=quarantine, then p=reject. Going straight to reject is how one wrong SPF line kills your legitimate mail.

1.3 IP Reputation vs. Domain Reputation

Through the 2010s, IP reputation was everything. Dedicated IPs were expensive and worth paying for. In 2026 domain reputation dominates. Gmail and Outlook score each domain + sender pair with a learned model.

Two consequences:

2. Resend — The Developer-First ESP's New Default

2.1 Position

Resend launched in 2023 and rapidly found its place in 2024 ~ 2025 among indie hackers and the Next.js crowd. It comes packaged with React Email — "write your emails in JSX" is the core pitch. Built by people out of Vercel and Stripe, it closed a Series B in 2024.

Pricing (as of May 2026):

// Resend — minimal transactional send
import { Resend } from 'resend'

const resend = new Resend(process.env.RESEND_API_KEY)

await resend.emails.send({
  from: 'Acme <hello@mail.acme.com>',
  to: ['user@example.com'],
  subject: 'Welcome',
  html: '<strong>Thanks for signing up.</strong>',
})

2.2 Strengths

2.3 Weaknesses

2.4 When to Use

3. Postmark (ActiveCampaign) — The Deliverability King

3.1 Position

Postmark was built by Wildbit in 2010 and acquired by ActiveCampaign in 2022. The product is religious about transactional deliverability — they publish median delivery times ("9.8s") and the analytics center on inbox arrival. Marketing mail is explicitly not run on the same infrastructure, and they sell that separation as a feature.

Pricing (as of May 2026):

// Postmark — one server token
import { ServerClient } from 'postmark'

const client = new ServerClient(process.env.POSTMARK_TOKEN!)

await client.sendEmail({
  From: 'hello@mail.acme.com',
  To: 'user@example.com',
  Subject: 'Password reset',
  HtmlBody: '<a href="https://acme.com/reset?token=xxx">Reset</a>',
  MessageStream: 'outbound', // must be distinct from 'broadcast'
})

3.2 Strengths

3.3 Weaknesses

3.4 When to Use

4. Loops — Email as a Product

4.1 Position

Loops launched in 2022 and raised a Series A in 2024. It owns a narrow, sharp position: "the unified marketing + transactional ESP for indie SaaS." Audience management, sequences (loops), and transactional all in one screen. The UI feels like a SaaS product itself and shows up in the customer-facing email of teams like Slack-adjacent indie tools.

Pricing (as of May 2026):

// Loops — trigger transactional event
import { LoopsClient } from 'loops'

const loops = new LoopsClient(process.env.LOOPS_API_KEY!)

await loops.sendTransactionalEmail({
  transactionalId: 'cltt6abcd1234', // created in the Loops dashboard
  email: 'user@example.com',
  dataVariables: {
    firstName: 'Youngju',
    resetUrl: 'https://acme.com/reset?token=xxx',
  },
})

4.2 Strengths

4.3 Weaknesses

4.4 When to Use

5. AWS SES — Cheapest by Far, but You Own Everything

5.1 Position

SES (Simple Email Service) launched in 2011. Pricing is effectively the industry floor. Deliverability, warmup, UI, and automation features are entirely on the user. It is the foundation of DIY email.

Pricing (as of May 2026):

// AWS SES v2 — Node SDK
import { SESv2Client, SendEmailCommand } from '@aws-sdk/client-sesv2'

const ses = new SESv2Client({ region: 'us-east-1' })

await ses.send(new SendEmailCommand({
  FromEmailAddress: 'hello@mail.acme.com',
  Destination: { ToAddresses: ['user@example.com'] },
  Content: {
    Simple: {
      Subject: { Data: 'Welcome' },
      Body: { Html: { Data: '<strong>Account created</strong>' } },
    },
  },
}))

5.2 Strengths

5.3 Weaknesses

5.4 When to Use

6. SendGrid (Twilio) — The Enterprise Default

6.1 Position

SendGrid launched in 2009 and was acquired by Twilio in 2019. The transactional + marketing giant. Enterprise teams pick it first; the API, integrations, and SDKs are unmatched in breadth. The downside is a UI that carries scars from another era and pricing that is heavily negotiated.

Pricing (as of May 2026):

// SendGrid — v3 API
import sgMail from '@sendgrid/mail'

sgMail.setApiKey(process.env.SENDGRID_API_KEY!)

await sgMail.send({
  to: 'user@example.com',
  from: 'hello@mail.acme.com',
  subject: 'Payment receipt',
  html: '<p>Thanks for your purchase.</p>',
})

6.2 Strengths

6.3 Weaknesses

6.4 When to Use

7. Mailgun (Sinch) — The OG Dev-Friendly ESP in 2026

7.1 Position

Mailgun launched in 2010, was acquired by Rackspace in 2017, and Sinch acquired the parent in 2021. The original dev-friendly ESP of the early 2010s. The API is clean and EU data residency (EU region) was offered early.

Pricing (as of May 2026):

// Mailgun — REST API
import formData from 'form-data'
import Mailgun from 'mailgun.js'

const mg = new Mailgun(formData).client({
  username: 'api',
  key: process.env.MAILGUN_API_KEY!,
})

await mg.messages.create('mail.acme.com', {
  from: 'hello@mail.acme.com',
  to: ['user@example.com'],
  subject: 'Welcome',
  html: '<p>Hello</p>',
})

7.2 Strengths

7.3 Weaknesses

7.4 When to Use

8. The Rest — Brevo, Mailtrap, Customer.io, Plunk

8.1 Brevo (formerly Sendinblue)

Paris-based, an all-in-one for marketing + transactional + SMS + CRM. Popular among European indie hackers. Pricing is reasonable and the free tier is generous (300 sends/day). The center of gravity is marketing, so pure transactional deliverability sits a touch below Postmark or Resend.

8.2 Mailtrap — Dev-Environment Testing

A tool that mimics email delivery for staging and local development. It accepts SMTP without actually sending and stores messages in a fake inbox so the developer can inspect body, headers, and HTML. Common in CI as a regression test. Mailtrap launched real sending (Mailtrap Email Sending) in 2024 ~ 2025, but the main use is still the test environment.

// Mailtrap — Nodemailer SMTP test inbox
import nodemailer from 'nodemailer'

const transporter = nodemailer.createTransport({
  host: 'sandbox.smtp.mailtrap.io',
  port: 2525,
  auth: { user: process.env.MAILTRAP_USER, pass: process.env.MAILTRAP_PASS },
})

await transporter.sendMail({
  from: 'hello@mail.acme.com',
  to: 'qa@example.com',
  subject: 'staging test',
  html: '<p>Hello, Mailtrap</p>',
})

8.3 Customer.io — Real Marketing Automation

The heavyweight in event-driven marketing automation. The sequence builder goes deep (if/else, A/B, branch-and-join, timezone-aware sending). Pricing climbs fast — adoption typically starts above $50k MRR. Liquid templates, webhooks, and in-app messaging all included.

8.4 Plunk — Open-Source Self-Host

plunk.com. An open-source ESP launched in 2024. There is a hosted version that sits on top of SES, and the GitHub repo can be self-hosted. Indie's "self-host option." Deliverability ultimately depends on the SES underneath. Strong fit for price-sensitive setups and teams with data-sovereignty needs.

9. The 10,000-Subscriber Cost Matrix

Assume: 10,000 contacts, 100,000 sends/month (10 sends per contact average), 50% transactional, 50% marketing.

ServiceMonthlyTransactionalMarketing AutomationDeliverabilityNotes
AWS SES$10StrongNoneOn youDIY, build infrastructure yourself
Resend Pro/Scale$90StrongMediumGoodReact Email integration
Postmark Premium$115StrongestSeparatedStrongestTransactional only
Mailgun Scale$90StrongWeakMediumEU data residency
SendGrid Pro$89.95StrongStrongVariableTwilio integration
Loops Business$249StrongStrongGoodIndie SaaS integrations
Brevo Business$65+MediumStrongGoodMarketing-heavy
Customer.io Premium$200+StrongStrongestGoodPair with a dedicated transactional ESP
Plunk + SES$10 ~ $30SES-dependentSimpleSES-dependentSelf-host option

Two takeaways:

  1. On pure price, SES is the clear winner. Add operator cost and the gap narrows at 100k/month; at 1M/month the gap reopens.
  2. For marketing automation depth, Loops and Customer.io lead at this price band. Resend added Broadcasts, but branch depth still trails.

9.1 Recalculating at 100,000 Subscribers

Assume: 100,000 contacts, 1M sends/month.

ServiceMonthly (est.)Ops HeadcountTotal (incl. ops)
AWS SES$100~0.3 FTEops + $100
Resend$900 ~ $1,5000$900 ~ $1,500
Postmark$1,200+0$1,200+
SendGrid Pro/Premier$500 ~ $2,000 (negotiated)0 ~ 0.2 FTEnegotiated
Customer.io$2,000 ~ $5,0000$2,000 ~ $5,000
SES + custom tooling$100 + ops1 FTEserious build

At 1M/month, SES + custom tooling starts to pay off — assuming you have the engineering hours to build it.

10. React Email, MJML, Maizzle — The HTML Email Reality

10.1 Why HTML Email Is Awful

Email clients run rendering engines frozen circa 1999. Outlook still uses the Word engine (2007+). Gmail accepts only a subset of <style> and ignores some media queries. iOS Mail does not know CSS Grid. Modern CSS is basically off-limits.

Two coping strategies:

Writing this by hand is punishment, so tools exist.

10.2 React Email

// React Email — components in, email out
import { Body, Button, Container, Head, Html, Text } from '@react-email/components'

export function WelcomeEmail({ name }: { name: string }) {
  return (
    <Html>
      <Head />
      <Body style={{ fontFamily: 'sans-serif' }}>
        <Container>
          <Text>Hello {name},</Text>
          <Button href="https://acme.com/welcome">Get started</Button>
        </Container>
      </Body>
    </Html>
  )
}

The build step inlines styles into table-based HTML. Resend is from the same team so integration is first-class; the output works fine in Postmark and SES too.

10.3 MJML

A markup language from Mailjet. You write custom tags (mj-section, mj-column) and the build compiles to standard table HTML. It set the 2015-era standard and is still common in PHP and Ruby stacks.

<mjml>
  <mj-body>
    <mj-section>
      <mj-column>
        <mj-text>Welcome.</mj-text>
        <mj-button href="https://acme.com/welcome">Start</mj-button>
      </mj-column>
    </mj-section>
  </mj-body>
</mjml>

10.4 Maizzle

A Tailwind-based email framework. You write plain HTML + Tailwind classes; PostCSS inlines styles at build. The most natural choice for designers. Static build, not SSR/JSX, which makes it a good fit for CMS-driven campaign workflows.

10.5 Which to Pick

All three produce the same inlined table HTML. Pick by your team's stack.

11. Webhooks, Bounces, Complaints — Handling Inbound Events

11.1 Every ESP Sends the Same Events

The names differ slightly, but the core events are the same.

11.2 The Idempotent Webhook Handler

// Next.js Route Handler — idempotent Resend webhook
import { headers } from 'next/headers'
import { db } from '@/lib/db'
import { Webhook } from 'svix' // Resend uses svix signatures

export async function POST(req: Request) {
  const body = await req.text()
  const h = await headers()

  const wh = new Webhook(process.env.RESEND_WEBHOOK_SECRET!)
  let event
  try {
    event = wh.verify(body, {
      'svix-id': h.get('svix-id')!,
      'svix-timestamp': h.get('svix-timestamp')!,
      'svix-signature': h.get('svix-signature')!,
    }) as any
  } catch {
    return new Response('Bad signature', { status: 400 })
  }

  // Idempotency: use the event id as PK
  const stored = await db.emailEvent.create({
    data: { id: event.data.email_id + ':' + event.type, payload: body },
  }).catch(() => null)

  if (!stored) return new Response('Already processed', { status: 200 })

  switch (event.type) {
    case 'email.bounced':
      await suppressUser(event.data.to[0], 'hard_bounce')
      break
    case 'email.complained':
      await suppressUser(event.data.to[0], 'complaint')
      break
  }

  return new Response('ok', { status: 200 })
}

The point: bounces and complaints go into the suppression list immediately. Sending one more is reputation damage.

11.3 1-Click Unsubscribe (RFC 8058)

Since the 2024 Google/Yahoo guidelines, every marketing message needs these headers.

List-Unsubscribe: <https://acme.com/unsub?t=xxx>, <mailto:unsub@mail.acme.com?subject=unsub>
List-Unsubscribe-Post: List-Unsubscribe=One-Click

When the recipient hits "Unsubscribe" in their client, the ESP POSTs to that URL. The user is removed in one click without opening a page. Resend, Postmark, SendGrid, and SES all let you set these headers per send.

12. Korean ISP Deliverability — The Reality of Naver and Daum

12.1 Why Korea Is Hard

Roughly 40 ~ 50% of Korean users mix Naver Mail (@naver.com), Daum/Hanmail (@daum.net, @hanmail.net), and Gmail Korea. Global ESPs optimize for Gmail/Outlook, but Naver and Daum run more conservative policies.

Specifically:

12.2 Practical Steps for Korean ISP Inboxing

12.3 Decision by Korean Share

13. Marketing vs. Transactional — Separate the Streams

13.1 Send Them from Different IPs

Marketing and transactional mail have different reputations. Marketing inherently has higher complaint rates; transactional is near zero. Mixing them on one IP lets marketing damage the transactional reputation.

13.2 Subdomain Strategy

acme.com              ← root (no sending)
mail.acme.com         ← transactional (receipts, auth)
news.acme.com         ← marketing (newsletters, campaigns)
notifications.acme.com ← system alerts (Slack-style)

Each gets its own SPF, DKIM, DMARC and may use a different ESP. For example: Postmark for transactional, Loops for marketing, SES for system alerts.

14. Operational Anti-Patterns

Common failures.

15. The Decision Tree

Q1: Transactional-first or marketing-first?
  ├─ Transactional first (auth, receipts, alerts)
  │   ├─ Next.js/React stack → Resend
  │   ├─ Delivery is everything (finance, healthcare) → Postmark
  │   ├─ AWS-native with operator headcount → SES
  │   └─ Legacy/SAP/enterprise → SendGrid
  │
  └─ Marketing + transactional combined
      ├─ Indie SaaS ($1k ~ $50k MRR) → Loops
      ├─ Heavy marketing automation → Customer.io + a separate Postmark/Resend for transactional
      └─ EU data residency + marketing + CRM → Brevo

Q2: Monthly volume?
  ├─ < 50,000 → Any of the above. Price gap is small.
  ├─ 50k ~ 500k → Compare ESP pricing seriously.
  └─ 1M+ → SES with custom tooling, or negotiate Premier.

Q3: Korean user share?
  ├─ < 10% → Global ESP alone.
  ├─ 10 ~ 30% → Global ESP + domain-reputation monitoring.
  └─ > 30% → Pair the global ESP with a Korean ESP.

Epilogue — Break Email Once and Lose Six Months

The scary thing about email infrastructure is that one mistake can cost six months. Lose domain reputation and you either buy a new domain or wait 3 ~ 6 months of recovery. So before the first send, set up SPF/DKIM/DMARC, separate marketing from transactional, and wire up idempotent bounce and complaint webhooks. That is the first-week work for any indie founder.

The 2026 email market looks nothing like it did eight years ago. Resend captured developer mindshare via React Email. Postmark established itself as the deliverability standard. Loops opened the marketing+transactional door for indie SaaS. SES remains crushingly cheap. The Google/Yahoo 2024 guidelines shook the market but everyone moved the same direction — no SPF/DKIM/DMARC, no sending.

First-Week Checklist

Anti-Patterns (Recap)

What's Next

The next piece picks up after the message arrives. Once a mail lands in the inbox, how does it become a click, a reply, and revenue — what metrics survive in a post-Apple-Mail-Privacy-Protection world, how to design A/B tests on email, and how open/click/reply/unsubscribe/attribution actually wire together in practice.

References

Comments

No comments yet.

Sign in to leave a comment