B2B SaaS where billing/auth emails are business-critical Apps with existing deliverability problems Healthcare or fintech apps where missing an email is a compliance issue Teams that want the highest possible inbox placement

High volume (>100k emails/month) where per-email cost matters Need both transactional + marketing in one platform Existing SendGrid contracts/integrations Need advanced analytics and suppression management

Email Providers in SaaS Boilerplates 2026

TL;DR

Resend for new SaaS projects — best developer experience, React Email integration, generous free tier (3k/month). Postmark for apps where deliverability is critical (password resets, billing alerts). SendGrid for high-volume (>100k/month) or if you already have it. Most boilerplates now default to Resend.

The Email Landscape in 2026

Every SaaS needs at minimum:

Welcome email on signup
Password reset
Email verification
Billing receipts and failure alerts
Subscription upgrade/downgrade notifications

Transactional email is not optional — it's infrastructure. Get it wrong and users miss critical notifications or go to spam.

Provider Comparison

Feature	Resend	Postmark	SendGrid
Free tier	3k/month	100/month	100/day
Paid starts	$20/mo (50k)	$15/mo (10k)	$19.95/mo (50k)
React Email	✅ First-class	✅ Compatible	✅ Compatible
Templates	Code-first	Visual + code	Visual + code
Deliverability	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Transactional API	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Marketing email	❌	❌	✅
Analytics	Basic	Good	Excellent
Webhooks	✅	✅	✅
Developer experience	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐

Resend: The Modern Developer Email API

Resend launched in 2023 and immediately became the default for new projects. Built by the team behind React Email.

import { Resend } from 'resend';

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

// Send email — clean API, TypeScript-first
const { data, error } = await resend.emails.send({
  from: 'YourSaaS <hello@yoursaas.com>',
  to: [user.email],
  subject: 'Welcome to YourSaaS',
  react: <WelcomeEmail name={user.name} dashboardUrl={`${BASE_URL}/dashboard`} />,
});

if (error) {
  console.error('Email send failed:', error);
  // Don't throw — email failure shouldn't crash the signup flow
}

React Email Integration

React Email lets you build email templates with React components:

// emails/welcome.tsx
import { Body, Button, Container, Head, Heading, Hr, Html, Preview, Section, Text } from '@react-email/components';

interface WelcomeEmailProps {
  name: string;
  dashboardUrl: string;
}

export default function WelcomeEmail({ name, dashboardUrl }: WelcomeEmailProps) {
  return (
    <Html>
      <Head />
      <Preview>Welcome to YourSaaS, {name}!</Preview>
      <Body style={{ backgroundColor: '#f6f9fc', fontFamily: 'Arial, sans-serif' }}>
        <Container style={{ maxWidth: '600px', margin: '0 auto', padding: '20px' }}>
          <Heading>Welcome, {name}!</Heading>
          <Text>
            Your account is ready. Let's get you started.
          </Text>
          <Section style={{ textAlign: 'center', marginTop: '32px' }}>
            <Button
              href={dashboardUrl}
              style={{ backgroundColor: '#5469d4', color: '#fff', padding: '12px 24px', borderRadius: '4px' }}
            >
              Go to Dashboard
            </Button>
          </Section>
          <Hr />
          <Text style={{ color: '#8898aa', fontSize: '12px' }}>
            You received this because you signed up for YourSaaS.
          </Text>
        </Container>
      </Body>
    </Html>
  );
}

Preview in browser:

npx react-email dev  # Opens email preview at localhost:3000

Resend Limitations

Free tier is 3k/month — enough for side projects, not for growth-stage SaaS
No marketing email (use Mailchimp/ConvertKit for newsletters)
Analytics are basic vs Postmark or SendGrid
Newer company — less battle-tested than Postmark or SendGrid

Postmark: Deliverability First

Postmark has the best deliverability in the industry. Industry-leading 99%+ inbox placement for transactional emails. If your users are missing password reset emails, Postmark fixes it.

import * as postmark from 'postmark';

const client = new postmark.ServerClient(process.env.POSTMARK_API_KEY!);

// Send transactional email
await client.sendEmail({
  From: 'hello@yoursaas.com',
  To: user.email,
  Subject: 'Reset your password',
  HtmlBody: passwordResetHtml,
  TextBody: passwordResetText,
  MessageStream: 'transactional',
});

// Send via template (Postmark has a visual template builder)
await client.sendEmailWithTemplate({
  From: 'hello@yoursaas.com',
  To: user.email,
  TemplateAlias: 'password-reset',
  TemplateModel: {
    name: user.name,
    resetUrl: `${BASE_URL}/reset-password?token=${token}`,
  },
  MessageStream: 'transactional',
});

Postmark Streams

Postmark separates transactional and broadcast emails into "streams" — separate sending contexts with different IPs and reputations:

// Transactional stream — highest deliverability, fastest
MessageStream: 'transactional'  // Password resets, billing, auth

// Broadcast stream — for newsletters, announcements
MessageStream: 'broadcast'  // Same account, different reputation

This matters: a spam complaint on your newsletter doesn't affect your transactional email deliverability.

When Postmark Wins

B2B SaaS where billing/auth emails are business-critical
Apps with existing deliverability problems
Healthcare or fintech apps where missing an email is a compliance issue
Teams that want the highest possible inbox placement

Postmark Limitations

Free tier is only 100 emails/month (testing only)
More expensive than Resend at low volume
No marketing email features
API is less modern than Resend (works great, but verbosity shows its age)

SendGrid: The Enterprise Option

SendGrid (Twilio) is the category leader by volume. Powers billions of emails per month. Strong choice when you need both transactional AND marketing email, or at very high volumes (>500k/month).

import sgMail from '@sendgrid/mail';

sgMail.setApiKey(process.env.SENDGRID_API_KEY!);

await sgMail.send({
  to: user.email,
  from: 'hello@yoursaas.com',
  subject: 'Your invoice',
  html: invoiceHtml,
  text: invoiceText,
});

When SendGrid Wins

High volume (>100k emails/month) where per-email cost matters
Need both transactional + marketing in one platform
Existing SendGrid contracts/integrations
Need advanced analytics and suppression management

SendGrid Limitations

Developer experience is dated compared to Resend
React Email works but isn't first-class
Interface complexity has grown with the Twilio acquisition
Free tier is only 100/day (3k/month) — same as Resend but slower API

Boilerplate Defaults

Boilerplate	Email Provider	Notes
ShipFast	Resend	React Email templates included
Supastarter	Resend	React Email components
Makerkit	Resend	Nodemailer + Resend adapter
T3 Stack	None (add yourself)	Usually Resend in community setups
Open SaaS	Resend	React Email

Setup Best Practices

Regardless of provider, follow these patterns:

// lib/email.ts — abstracted email utility
const emailAdapter = {
  send: async (options: EmailOptions) => {
    // Swap provider here without changing call sites
    return resend.emails.send(options);
  }
};

// Never await email in critical paths — fire and forget with error handling
export async function sendWelcomeEmail(user: User) {
  try {
    await emailAdapter.send({
      to: user.email,
      subject: 'Welcome!',
      react: <WelcomeEmail name={user.name} />,
    });
  } catch (error) {
    // Log but don't throw — email failure shouldn't break signup
    console.error('[Email] Welcome email failed:', error);
    Sentry.captureException(error, { extra: { userId: user.id } });
  }
}

// Always include unsubscribe header for CAN-SPAM/GDPR
await resend.emails.send({
  from: 'hello@yoursaas.com',
  to: user.email,
  subject: 'Monthly digest',
  react: <DigestEmail />,
  headers: {
    'List-Unsubscribe': `<mailto:unsubscribe@yoursaas.com?subject=unsubscribe>, <${BASE_URL}/unsubscribe?token=${unsubToken}>`,
    'List-Unsubscribe-Post': 'List-Unsubscribe=One-Click',
  },
});

Deliverability Infrastructure: What You Control

Email deliverability is partly determined by your sending provider and partly by domain configuration you control. Even on a provider with excellent deliverability like Postmark, poor domain configuration will land emails in spam.

The three DNS records that matter: SPF authorizes which servers can send email from your domain; DKIM cryptographically signs each email to verify it wasn't modified in transit; DMARC tells receiving servers what to do with emails that fail SPF or DKIM checks. All three should be configured before you send a single production email. Resend, Postmark, and SendGrid all provide the exact DNS records to add; follow their setup guides precisely.

Warming up a new domain is necessary if you're sending transactional email from a domain you've never used for email before. IP reputation builds gradually — ISPs are skeptical of new domains that start sending at high volume immediately. For a new SaaS domain, start with low daily volume (50-100 emails/day), ramp up over two weeks, and send to engaged users first (people who explicitly requested the email, like password resets). Sending to an unwarmed domain at high volume will result in spam folder placement that's difficult to recover from.

Domain reputation monitoring catches problems before they affect users. Google Postmaster Tools (free) shows your Gmail inbox placement rate and spam rate for your sending domain. Yahoo's Complaint Feedback Loop catches spam complaints from Yahoo Mail users. Configure monitoring for both within the first week of sending production email.

Abstracting the Email Provider in Your Codebase

Regardless of which provider you start with, build an abstraction layer that makes switching providers a one-line change. This is a 20-minute investment that pays off if your provider raises prices, has downtime, or if you need to switch for compliance reasons.

The abstraction pattern: a single sendEmail function in your codebase that accepts a consistent interface, with the provider implementation swappable behind it. Every feature in your app calls sendEmail(); no feature calls resend.emails.send() or postmark.sendEmail() directly. When you swap providers, you update one file, not forty call sites.

This pattern also makes local development easier. In development, replace the provider implementation with a function that logs emails to the console or saves them to a file. No actual emails sent during development, no risk of accidentally emailing real users from a local environment, and no need to configure real API keys for development work.

Testing email sending behavior becomes simpler with the abstraction. Unit tests mock the sendEmail function; integration tests can use the real provider against a test inbox, or a service like MailHog for local SMTP testing. Without the abstraction, every test that triggers email sending requires mocking the specific provider's SDK methods.

The abstraction pattern also positions you well for multi-provider configurations — sending security-critical emails (password resets) through Postmark while routing marketing and notification emails through Resend. The routing logic lives in the sendEmail function based on the email type parameter, invisible to the calling code. This multi-provider approach combines Postmark's deliverability for critical flows with Resend's cost efficiency for high-volume notifications. The separation also provides resilience: if Resend experiences a brief outage, your password reset and billing emails continue flowing through Postmark without user impact, while only the notification emails queue for retry. For B2B SaaS where a missed billing notification or failed authentication email can result in direct revenue loss, this resilience architecture is worth implementing from the start rather than retrofitting after the first outage. The investment in the abstraction layer — typically less than a day of engineering time — pays for itself the first time you need to swap providers or debug why a particular email type is landing in spam across a specific mail client.

Find boilerplates with email provider integrations on StarterPick.

Compare the full email stack including React Email templates: React Email vs Resend vs Loops for SaaS 2026.

See email in context of the full SaaS infrastructure stack: Ideal tech stack for SaaS in 2026.

Find production-ready SaaS boilerplates with email configured: Best SaaS boilerplates 2026.

Transactional Email Templates That Actually Work

Email template quality directly affects deliverability and conversion. ISPs filter on engagement signals — open rates, click rates, and complaint rates. A well-designed template with a clear call-to-action gets better inbox placement over time because it generates more engagement.

For SaaS, the five templates that matter most follow a consistent pattern: a clear heading identifying the email's purpose, a brief plain-language explanation, a single primary action button, and a fallback plain-text version for email clients that don't render HTML. Resist the temptation to include multiple calls-to-action — welcome emails that ask users to verify their email, complete their profile, explore three features, and follow on social media perform worse than welcome emails with a single "Go to dashboard" button.

Plain-text versions are more than a fallback. Many enterprise mail servers and some ISPs weight plain-text presence positively in spam filtering. React Email's render function generates both HTML and text versions from the same React component, which removes the maintenance burden of keeping two separate template versions in sync. Configure your provider to send both versions with every email: { html: htmlContent, text: textContent }.

Email subject lines and preview text are the primary open-rate drivers. The preview text (also called preheader) is the grey text shown next to the subject line in most email clients. Without explicit preview text, email clients show the first text content of the email body — often an unsubscribe link or legal footer if your template isn't carefully structured. Set preview text explicitly in React Email using the Preview component, and keep subject lines under 50 characters for mobile display.

Handling Bounces and Unsubscribes

Bounce and complaint handling is not optional for SaaS email. ISPs track your sender reputation across all customers sharing an IP address; consistently sending to bounced addresses degrades deliverability for everyone on the shared IP, including you. All three providers deliver bounce and complaint notifications via webhooks.

// app/api/webhooks/resend/route.ts — handle bounces
import { NextRequest } from 'next/server';

export async function POST(req: NextRequest) {
  const event = await req.json();

  if (event.type === 'email.bounced') {
    // Mark email as invalid in your database
    await db.update(users)
      .set({ emailStatus: 'bounced' })
      .where(eq(users.email, event.data.to[0]));
  }

  if (event.type === 'email.complained') {
    // Unsubscribe the user from all emails
    await db.update(users)
      .set({ emailOptOut: true })
      .where(eq(users.email, event.data.to[0]));
  }

  return new Response('OK');
}

Building bounce handling from day one prevents a gradual reputation problem that's difficult to diagnose after the fact. Most boilerplates omit bounce handling in their default configuration — it's worth adding within the first sprint of any SaaS project.

The best SaaS boilerplates guide reviews which boilerplates include email configuration out of the box, including React Email templates and provider setup. The Next.js SaaS tech stack guide covers how email fits into the full production infrastructure picture. For a broader view of what free tier services fit the full SaaS stack, the best free open-source SaaS boilerplates guide identifies open-source starters that include working email configuration.

One aspect of email that boilerplates handle inconsistently is the queue pattern for sending. Sending email synchronously in a request handler — completing the API response only after the email is sent — introduces provider latency into your response time and can fail user-facing operations if the email provider is having a transient issue. The correct pattern is to enqueue the email job (via a background queue like BullMQ, Trigger.dev, or Inngest) and return a success response immediately. The queue worker sends the email asynchronously; if the send fails, the job retries automatically. Most mature boilerplates use this pattern for welcome emails and notifications but sometimes skip it for password reset emails, reasoning that the user is waiting for the email. Even for password resets, the queue pattern is safer — the retry mechanism handles provider blips invisibly rather than surfacing a failed request to the user.

Key Takeaways

Resend is the default email provider for 2026 SaaS boilerplates: React Email integration, developer-friendly API, generous free tier (3,000 emails/month), and $20/month for 50k
Postmark's deliverability premium is worth it specifically for password reset and billing emails in B2B contexts where a missed email ends a deal — its dedicated IP infrastructure outperforms shared-IP providers for critical transactional messages
SendGrid makes sense above 100k emails/month or when a dedicated account team and advanced deliverability tooling matter; below that volume, Resend's developer experience advantage outweighs SendGrid's scale features
Abstract email sending behind a single sendEmail interface in your codebase — provider-specific SDK calls scattered across features make future migrations painful and testing harder
Configure email delivery webhooks from day one: bounce handling protects sender reputation, and failed password resets are completely invisible without webhook instrumentation pointing failures back to your monitoring system
Domain authentication (SPF, DKIM, DMARC) takes 24-48 hours to propagate — configure DNS records before your first production deploy, not after you notice emails landing in spam

The SaaS Boilerplate Matrix (Free PDF)