Back to Blog

Resend vs Plunk: Which Email Service Should Indie Hackers Use in 2025?

By Aziz Ali••
emailresendsaasindie hackerstransactional email
Resend vs Plunk: Which Email Service Should Indie Hackers Use in 2025?

I spent two weeks evaluating email providers before shipping BetterStarter. I looked at SendGrid, Postmark, Mailgun, and eventually narrowed it down to two: Resend and Plunk. Both are aimed squarely at developers. Both have clean APIs. Both have free tiers. But they are not the same product, and picking the wrong one will bite you.

Here's my honest take after running both in production and choosing one for BetterStarter.

What We're Actually Comparing

Before I get into the weeds, let me set the context. BetterStarter is a TanStack Start boilerplate for indie hackers who want to ship a SaaS without wiring up infrastructure from scratch. Email is a core part of that — welcome emails, password resets, billing receipts. The email service needs to:

  1. Have a great developer experience (ideally React Email support)
  2. Be affordable at low volume and scale reasonably
  3. Actually deliver emails to inboxes (not spam folders)
  4. Have an API that doesn't make me want to flip a table

Both Resend and Plunk check most of those boxes. The differences are in the details — and for indie hackers, the details matter.

Resend: The Developer's Email API

Resend launched in 2023 and immediately became the darling of the indie hacker community. The pitch is simple: an email API built by developers, for developers. Clean REST API, first-class React Email support, and a dashboard that doesn't look like it was designed in 2009.

Developer Experience

Resend's DX is genuinely excellent. Installing it in a TypeScript project takes about 90 seconds:

import { Resend } from 'resend';

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

await resend.emails.send({
  from: 'onboarding@yourdomain.com',
  to: 'user@example.com',
  subject: 'Welcome to your new SaaS',
  react: <WelcomeEmail userName="Aziz" />,
});

That react parameter is what makes Resend special. You're writing your email templates as React components. No Handlebars, no Mjml, no wrestling with inline styles in HTML strings. Just components. I've used React Email with Resend in production and it's the best email authoring experience I've had.

The SDK handles retries, TypeScript types are tight, and error messages are actually useful. This sounds basic but I've used providers where error responses were just { "status": "error" } with no context.

Pricing

Resend's pricing is clean:

Plan Price Emails/month Domains
Free $0 3,000 1
Pro $20/mo 50,000 Unlimited
Scale $90/mo 100,000 Unlimited
Enterprise Custom Unlimited Unlimited

For a new SaaS, 3,000 emails/month on the free tier is enough to get started. Once you're past that, $20/month is reasonable. The price-per-email at scale is competitive but not the cheapest option on the market.

Deliverability

Resend's deliverability is solid. I haven't had inbox placement issues with properly configured DKIM/SPF/DMARC records. They're built on top of AWS SES under the hood (like many providers), which means you get AWS's infrastructure without the AWS console complexity.

Analytics

The analytics dashboard is clean but basic. You get open rates, click rates, bounces, and spam complaints. It's enough to know if something is broken, but don't expect deep segmentation or campaign analytics. Resend is a transactional email service, not an email marketing platform.

Free Tier Limits

3,000 emails/month on one domain. For most SaaS products at launch, this is plenty. If you're sending more than 3,000 transactional emails with fewer than a few hundred users, something is very wrong with your email strategy.

Plunk: The Open-Source Challenger

Plunk is newer and takes a different approach. It's open-source (MIT license), you can self-host it, and it's designed to be an all-in-one email platform — transactional emails AND marketing emails in a single product.

Developer Experience

Plunk's API is clean and the SDK is well-documented:

import Plunk from '@plunk/node';

const plunk = new Plunk(process.env.PLUNK_API_KEY);

await plunk.emails.send({
  to: 'user@example.com',
  subject: 'Welcome to your new SaaS',
  body: '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
});

Notice the difference: Plunk uses HTML strings, not React components. If you're already using React Email, you can render your component to HTML first and pass it in — but it's an extra step:

import { render } from '@react-email/render';
import WelcomeEmail from '@/emails/welcome';

const html = render(<WelcomeEmail userName="Aziz" />);

await plunk.emails.send({
  to: 'user@example.com',
  subject: 'Welcome to your new SaaS',
  body: html,
});

It works, but it's not as elegant as Resend's native React Email integration. If you're building a TypeScript SaaS in 2025 and you care about your email templates being maintainable, this friction adds up.

Pricing

Plunk's cloud pricing is aggressive:

Plan Price Emails/month Contacts
Free $0 3,000 1,000
Starter $9/mo 30,000 10,000
Growth $19/mo 100,000 50,000
Enterprise Custom Unlimited Unlimited

At $9/month for 30,000 emails, Plunk is meaningfully cheaper than Resend for early-stage products. If budget is tight (and when is it not at the indie hacker stage?), this matters.

But Plunk's real pricing advantage is self-hosting. If you're comfortable with Docker and have a server, you can run Plunk for free. Zero email infrastructure costs. This is a genuinely compelling option for technical founders who want to keep costs near zero and aren't afraid of a bit of DevOps.

Marketing Emails + Transactional in One

This is Plunk's strongest differentiation. With Plunk, you get:

  • Transactional emails (password resets, receipts)
  • Event-based automation (welcome sequences, onboarding drips)
  • Broadcasts to your contact list
  • Contact management

Resend is transactional-only. If you need to send a newsletter or a product update to your user list, you need another tool (Loops, Mailchimp, ConvertKit, etc.). With Plunk, it's all in one place.

For solo founders building a SaaS, consolidating tools is attractive. One API key, one dashboard, one vendor.

Deliverability

Plunk's deliverability is generally good, but it's less battle-tested than Resend at scale. As a newer, smaller provider, their IP reputation is still being established. For a new SaaS with low-to-medium volume, you likely won't notice any difference. At scale (100k+ emails/month), I'd want more data before committing.

React Email Support

Plunk does not have native React Email support. As I showed above, you can still use React Email by rendering to HTML first, but it's not a first-class integration. For teams already invested in the React Email ecosystem, this is a real drawback.

Head-to-Head Comparison

Feature Resend Plunk
React Email integration ✅ Native ⚠️ Manual render
Self-hosting ❌ ✅
Open source ❌ ✅ MIT
Marketing emails ❌ ✅
Free tier 3,000/mo 3,000/mo
Paid from $20/mo $9/mo
TypeScript SDK ✅ ✅
Deliverability Excellent Good
Dashboard quality Excellent Good
React ecosystem fit Excellent Moderate
Community / ecosystem Large Growing

Why I Chose Resend for BetterStarter

I went with Resend, and I'd make the same call again.

The decision came down to one thing: React Email integration. BetterStarter is a React/TypeScript stack, and having email templates as proper React components is a huge DX win. When I'm building product features at 11pm trying to ship before a launch, I don't want to context-switch to HTML string templates. I want to open a .tsx file, write JSX, and know it'll render correctly.

The second reason is ecosystem. Resend has a larger developer community, more tutorials, more GitHub examples, and more "it just works" integrations with popular full-stack frameworks. When something breaks at 2am, that community matters.

The third reason is focus. Resend does one thing — transactional email — and does it exceptionally well. Plunk tries to do transactional + marketing in one. That's ambitious, and I respect it, but I'd rather have a specialized tool that's excellent at its job.

BetterStarter comes pre-configured with Resend. You drop in your API key, your domain DNS records, and your first email works in under 5 minutes. No config files to modify, no provider abstraction layer to understand — just a clean sendEmail() function backed by Resend. If you're building a SaaS starter kit with Stripe and Drizzle, having email already handled is one less thing to wire up.

When Plunk Makes Sense

I'm not here to trash Plunk. It's a genuinely good product and there are real scenarios where I'd recommend it:

Choose Plunk if:

  • You want to self-host and eliminate email infrastructure costs entirely
  • You need marketing email automation (drip sequences, broadcasts) without adding another tool
  • You're budget-constrained and $9/month vs $20/month matters right now
  • You like open-source and want to contribute or audit the codebase
  • You're building a simpler stack where HTML templates are fine

Choose Resend if:

  • You're using React/TypeScript and want React Email templates
  • You want battle-tested deliverability with a large ecosystem
  • You value a polished developer experience over cost savings
  • You're on a team that will maintain email templates long-term
  • You want the path of least resistance and best documentation

Setting Up Resend in TanStack Start

Since BetterStarter uses TanStack Start, here's the setup pattern if you're rolling your own:

// lib/email.ts
import { Resend } from 'resend';

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

export async function sendWelcomeEmail(to: string, name: string) {
  return resend.emails.send({
    from: 'hello@yourdomain.com',
    to,
    subject: `Welcome to [Your App], ${name}!`,
    react: <WelcomeEmail name={name} />,
  });
}

// app/routes/api/auth/register.ts
import { sendWelcomeEmail } from '~/lib/email';

// After creating user in DB:
await sendWelcomeEmail(user.email, user.name);

That's it. No provider abstraction, no factory pattern. Just a function. Keep it simple until you have a reason to complicate it.

If you'd rather skip this setup entirely, BetterStarter ships with this pre-wired — including welcome, password reset, and magic link emails. One-time $99, and you're past all this infrastructure work before you even start.

Frequently Asked Questions

Is Resend better than Plunk for transactional email? For most TypeScript/React developers, yes. Resend has native React Email support, a larger ecosystem, and excellent deliverability. Plunk is a strong alternative if you want self-hosting or need marketing email features, but Resend is the better fit for pure transactional email in a modern React stack.

Can Plunk send marketing emails as well as transactional? Yes — this is one of Plunk's key differentiators. Plunk handles both transactional emails (password resets, receipts) and marketing emails (newsletters, onboarding sequences, broadcasts). Resend is transactional-only.

What is the free tier for Resend vs Plunk? Both offer 3,000 emails/month on their free tier. Resend limits you to one custom domain on the free plan. Plunk's free plan includes 1,000 contacts and the same 3,000 email limit. Both are sufficient for a SaaS in early stages.

Can I self-host Plunk? Yes. Plunk is open-source (MIT license) and provides Docker-based self-hosting. This makes it effectively free to run on your own infrastructure. Resend is cloud-only with no self-hosting option.

Does Resend work with React Email? Yes — React Email was built to work natively with Resend. You pass your React component directly to the react parameter in the API call, and Resend renders it server-side. This is the cleanest email templating experience available for React developers.

Which email service is best for indie hackers in 2025? Resend is the default recommendation for indie hackers building React/TypeScript SaaS products. It has the best DX, strong deliverability, and a generous free tier. Consider Plunk if you want self-hosting, lower paid plan costs, or built-in marketing email capabilities without adding another tool to your stack.

The Bottom Line

Resend and Plunk are both excellent choices compared to legacy options like SendGrid or Mailgun. You won't make a catastrophically wrong choice with either one.

But if you're building a modern TypeScript SaaS and you want the path of least resistance, Resend wins. The React Email integration alone is worth it. You'll write better email templates, ship faster, and thank yourself six months later when you need to update your onboarding sequence and it's just a .tsx file.

Plunk is the right call if cost is the primary constraint, you want the flexibility of self-hosting, or you need marketing and transactional email in a single platform.

If you want to skip this decision entirely and get back to building your actual product, check out the BetterStarter vs ShipFast comparison to see what a fully-configured SaaS boilerplate looks like — email, auth, Stripe, and database all pre-wired and ready to go.