Skip to content
Published on

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

🇰🇷KO🇺🇸EN🇯🇵JA
Split View필사 모드
Authors

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:

  • Exposes SMTP/REST APIs to accept your send requests.
  • Sends from shared or dedicated IPs.
  • Helps you align SPF, DKIM, and DMARC for your domain.
  • Returns bounce, complaint, delivery, open, and click events via webhooks or dashboards.
  • Manages a suppression list so the same address is not re-sent.

What an ESP does NOT do:

  • It does not build your domain reputation for you. Reputation grows from accumulated sending history.
  • It does not police your content. Spam keywords, HTML-to-text ratio, image sizes are your job.
  • It does not enforce CAN-SPAM, GDPR, or user consent for you.

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.

  • SPF (Sender Policy Framework): TXT record declaring which IPs/hosts may send for the domain. The ESP's SMTP servers are added via include:.
  • DKIM (DomainKeys Identified Mail): Your outbound mail is signed with the domain's private key. Receivers verify with the public key in DNS.
  • DMARC (Domain-based Message Authentication, Reporting & Conformance): Policy chosen by the domain owner for what to do with messages that fail SPF or DKIM (quarantine/reject).

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:

  • Dedicated IPs matter less. For 5,000 ~ 50,000 sends/month, shared IPs are fine. Above that, or for time-critical traffic (2FA codes), a dedicated IP starts to matter.
  • Switching domains resets reputation to zero. acme.com to acme.io means re-earning trust. Most teams use a sending subdomain like mail.example.com so reputation is isolated.

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):

  • Free: 3,000/month, 100/day.
  • Pro: $20/month for 50,000 sends, 10,000/day.
  • Scale: $90/month for 100,000 sends, additional ~$0.90 per 1,000 above.
  • Enterprise: negotiated.
// 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

  • React Email integration is first-class. Write email components in JSX and import them straight into the body.
  • Developer experience is overwhelming. Domain verification, logs, webhooks, batch sends — all clean.
  • Batching API sends up to 100 messages in one call.
  • Webhook events — email.sent, email.delivered, email.bounced, email.complained, email.opened, email.clicked.
  • Audiences and Broadcasts (since 2024) — lightweight marketing features now overlap with what Loops offered.

2.3 Weaknesses

  • Heavy marketing automation is thin. Sequences, branches, segments are simpler than Loops or Customer.io.
  • At very large send volumes (1M+/month) self-hosting on SES is materially cheaper.
  • Deliverability data is published often, but for full dedicated-IP warmup Postmark still has the better reputation.

2.4 When to Use

  • Transactional mail for Next.js/React SaaS.
  • Indie hackers and solo founders.
  • Teams where "manage email design as code" is the top priority.

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):

  • Free trial: 100 sends.
  • Starter: $15/month for 10,000 sends.
  • Premium: $115/month for 100,000 sends. Higher tiers come as packages.
  • Marketing (Streams): separate — Postmark forces a split between transactional and broadcast streams.
// 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

  • Transactional deliverability is best in class. A 9 ~ 12 second median to inbox is the core marketing claim and it largely holds.
  • Message Streams are enforced — transactional and broadcast share neither IPs nor reputation, even on the same domain.
  • Analytics are deliverability-first. Complaints, bounce reasons, opens, clicks — all immediately visible.
  • Free DMARC Digests — a GUI for analyzing DMARC reports on your domain.

3.3 Weaknesses

  • Pricey. $115 for 100k sends is roughly 10x SES's $10.
  • Weak marketing automation. Sequences and segments live in the ActiveCampaign parent, not Postmark itself.
  • Global IP pools are limited. Reputation warmup for Japanese and Korean ISPs reportedly takes longer.

3.4 When to Use

  • Finance, healthcare, B2B SaaS — anywhere a delayed or lost send turns into a complaint.
  • Domains where revenue is directly tied to delivery (auth codes, payment receipts, legal notices).
  • Teams that have already decided "marketing will live in a different tool."

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):

  • Free: 1,000 contacts, 2,000 sends/month.
  • Pro: from $49/month — 5,000 contacts, 25,000 sends.
  • Business: from $249/month — 25,000 contacts, 100,000 sends.
  • Additional contacts and volume tier up step-wise.
// 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

  • Transactional + marketing in one tool. A contact's transactional events and campaign sends share the same timeline.
  • Loops (sequences) — a builder with branches, delays, and conditions. Powerful enough for the simple cases.
  • Event-driven — start sequences from events like userSignedUp or subscriptionPaid.
  • Indie-friendly integrations — Stripe, PostHog, Segment work cleanly.

4.3 Weaknesses

  • Limited as a full marketing tool. Multi-step branching, A/B testing, user scoring are thinner than Customer.io or HubSpot.
  • Expensive at high volume. Pricing climbs quickly past 100k contacts.
  • Domain authentication and deliverability stats are sparser than Resend or Postmark.

4.4 When to Use

  • Indie SaaS in the $1k ~ $50k MRR band — too small for a dedicated marketing tool, too campaign-heavy for transactional-only.
  • "A solo founder without a marketing hire who wants every email managed in one screen."

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):

  • Sending: $0.10 per 1,000 messages (same from EC2 or external).
  • Receiving: $0.10 per 1,000 plus $0.09 per chunk.
  • Dedicated IP: $24.95/month per IP.
  • VDM (Virtual Deliverability Manager): scales with send volume.
// 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

  • Crushingly cheap. 100,000 sends for $10. Roughly 1/10 of Postmark at the same volume.
  • Native to AWS — pairs naturally with EventBridge, SNS, and Lambda.
  • Unlimited after sandbox exit — no real ceiling on volume (API quotas notwithstanding).
  • VDM — the 2023 deliverability dashboard with reputation monitoring and send recommendations.

5.3 Weaknesses

  • Sandbox by default. Exit requires an AWS Support ticket with a stated use case — typically 24 ~ 72 hours.
  • UI is bare. No template editor, no sequences, no segments.
  • Deliverability is on you. SPF, DKIM, DMARC, warmup, content quality — all hand-rolled.
  • Bounce and complaint handling is on you — pipe SNS notifications into your own suppression list.

5.4 When to Use

  • 1M+ sends/month — the cost gap becomes meaningful.
  • Teams already on AWS for everything else.
  • Internal email infra teams that can own deliverability and warmup themselves.

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):

  • Free: 100/day (with a monthly cap).
  • Essentials: from $19.95/month — 50,000/month.
  • Pro: from $89.95/month — 100,000/month with dedicated IP options.
  • Premier: negotiated — millions of sends.
// 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

  • It runs everywhere. SDKs in 30+ languages. The most common pick for legacy stacks and enterprise SI.
  • Twilio integration — SMS, WhatsApp, and Voice billed under one account.
  • Marketing campaigns are deep — sequences, segments, A/B tests.
  • Dedicated-IP automation — Pro and above give you proper IP-pool management.

6.3 Weaknesses

  • Aged UI. Navigation still shows the seams of a 13-year-old product.
  • Shared-IP reputation drifts. Big customers get the attention; smaller senders feel the volatility.
  • Support varies by tier. Below Pro, responses are slow.

6.4 When to Use

  • Large companies and legacy systems — when you need email coming out of SAP, Oracle, etc.
  • Teams already on Twilio SMS/Voice and want unified billing.
  • Global teams running marketing + transactional in a single tool.

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):

  • Foundation: $15/month for 10,000 sends.
  • Growth: $35/month for 50,000.
  • Scale: $90/month for 100,000.
  • Enterprise: negotiated.
// 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

  • EU region — api.eu.mailgun.net — your data stays in the EU. Meaningful for GDPR-heavy customers.
  • 7-day event log by default, 30-day option. Strong for debugging.
  • Email validation API — verify addresses before sending.

7.3 Weaknesses

  • Feels stagnant in the 2020s. UI and DX have not kept pace with newer ESPs.
  • Shared-IP reputation drifts more than the leaders.
  • Mid-tier pricing — not as cheap as SendGrid/Resend, not as delivery-focused as Postmark.

7.4 When to Use

  • EU data residency is a hard legal requirement.
  • You already have years of customer data accumulated in Mailgun.
  • For greenfield work, pick Resend, Postmark, or SES first.

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:

  • Table-based layout — 2003-style nested <table><tr><td>.
  • Inline styles — survive even when <style> is stripped.

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

  • Next.js/React stack: React Email. Component reuse, TypeScript autocomplete.
  • Localized campaigns and designer collaboration: Maizzle. Tailwind-friendly.
  • PHP/Ruby legacy: MJML.

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.

  • delivered — SMTP 250 response.
  • bounce.hard — permanent failure (no such address). Suppress immediately.
  • bounce.soft — temporary failure (mailbox full, etc.). Retry; typically escalates to hard within 7 days.
  • complaint / spam_report — user clicked "Report Spam." Stop all marketing to that address immediately.
  • opened — tracking pixel loaded (noisy). Largely unreliable since Apple Mail Privacy Protection in 2022.
  • clicked — link clicked (rewritten by the ESP for tracking).

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:

  • Fixed-IP trust is stronger. Shared-IP reputation is more volatile against Korean ISPs.
  • Korean body text with an English-only sending domain triggers heuristics meant to catch fake auth mail.
  • Bounce reasons sometimes return Korean text mixed in with the SMTP codes.

12.2 Practical Steps for Korean ISP Inboxing

  • All three of DKIM, SPF, DMARC must pass — same as globally.
  • From domain must read as legitimate alongside Korean body — a domain like noreply@mail.gmail-fake.tk is blocked instantly.
  • Above 30% Korean users, consider a dedicated IP or separate IP pool.
  • Naver mailbox whitelist — Naver's sender registration page helps in some cases.
  • Warm up first sends — for campaigns heavy on Korean users, start with small batches (100/day) and scale up.

12.3 Decision by Korean Share

  • Below 5%: A global ESP alone is fine. Use Resend or Postmark as-is.
  • 10 ~ 30%: Add domain reputation monitoring. Sample inbox arrival at Naver and Daum weekly via test accounts.
  • Above 30%: Consider a Korean-ISP-specific path — Stibee, Mailbluster, a domestic SMTP relay. Track global deliverability separately.

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.

  • Postmark: enforced split — MessageStream: 'outbound' vs 'broadcast'. Different IPs even on the same domain.
  • SendGrid: split via IP Pools. Recommended at Pro and above.
  • Resend: separate by domain or subdomain (mail.acme.com for transactional, news.acme.com for marketing).
  • SES: split via Configuration Sets + Dedicated IP Pools.

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.

  • Buying a cold list and blasting 10,000 messages on day one — domain reputation gone instantly. Recovery is usually 3 ~ 6 months.
  • noreply@ sender, ignored replies — replies vanish, and it is not great for CAN-SPAM either. Use support@ or auto-reply.
  • Setting DMARC to p=reject on day one — one wrong SPF line kills your legitimate mail. Go p=none → quarantine → reject.
  • Ignoring bounces and continuing to send — hard-bounce rate above 1% and ISPs start blocking the whole domain.
  • No 1-click unsubscribe — required for marketing since 2024. Without it, Gmail routes you to spam.
  • Relying on tracking pixels and short-link clicks — Apple Mail Privacy Protection made opened largely untrustworthy since 2022. Measure with clicks and replies.
  • Sending email synchronously inside an HTTP response — send latency becomes user-perceived latency. Queue it (BullMQ, SQS) and process async.

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

  • Day 1: choose your sending subdomains (mail.acme.com for transactional, news.acme.com for marketing).
  • Day 1: pick a primary ESP (Resend or Postmark).
  • Day 2: drop in SPF and DKIM TXT records. Wait for DNS propagation.
  • Day 3: DMARC p=none + a report mailbox address.
  • Day 4: idempotent bounce and complaint webhook handler keyed on event.id.
  • Day 5: send the first transactional. Verify arrival at Gmail, Outlook, Naver, Daum.
  • Day 7: List-Unsubscribe header + a 1-click unsubscribe endpoint.
  • Day 14: review DMARC reports, then move to p=quarantine.
  • Day 30: as volume nears 5,000/day, split into dedicated IPs or IP pools.

Anti-Patterns (Recap)

  • Buying a cold list and torching the domain on day one.
  • Mixing marketing and transactional on the same IP and sending your auth mail to spam.
  • noreply@ + ignored replies + no 1-click unsubscribe.
  • Ignoring bounces until you cross 1% and get blocked.
  • Setting DMARC to p=reject on day one and killing legitimate mail.
  • 30% Korean users on a global-only ESP without ever measuring Naver/Daum inbox rates.

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

Discuss on Twitter • View on GitHub