4 Email Flows Your Supabase App Needs Before Going Live

Every production Supabase app needs four email flows. Supabase handles one of them (partially). The other three are completely on you. Here's what each flow requires, the common approaches, and the tradeoffs you'll hit.

Magic links, password resets, signup confirmations. Supabase Auth handles these out of the box — but the defaults have real problems in production.

What Supabase Gives You

Supabase Auth sends emails automatically when users sign up, reset passwords, or request magic links. Zero configuration needed to get started.

The Fix: Custom SMTP

Supabase lets you configure a custom SMTP provider in Dashboard → Authentication → SMTP Settings. This means your auth emails send from your domain, with your branding, through your infrastructure.

Host:     email-smtp.us-east-1.amazonaws.com
Port:     587
Username: AKIAIOSFODNN7EXAMPLE      # SES SMTP credentials
Password: wJalrXUtnFEMI/K7MDENG...  # (not your AWS secret key)
Sender:   noreply@yourdomain.com

Cost Comparison for Auth Emails

Auth emails alone probably won't break the bank. But this is just one of four flows — the costs add up.

Welcome emails, comment notifications, payment receipts, order confirmations. These bring users back to your app — and Supabase Auth doesn't handle any of them.

Option A: Edge Functions + fetch

Call an email API from a Supabase Edge Function. Works, but you're building email infrastructure from scratch — no templates, no tracking, no retry logic.

import { serve } from "https://deno.land/std/http/server.ts";

serve(async (req) => {
  const { email, name } = await req.json();

  // Raw fetch to an email API
  const res = await fetch("https://api.resend.com/emails", {
    method: "POST",
    headers: {
      Authorization: "Bearer re_xxxxx",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      from: "hello@yourdomain.com",
      to: email,
      subject: "Welcome to the app",
      html: `<p>Hey ${name}, welcome aboard!</p>`,
    }),
  });

  return new Response(JSON.stringify({ ok: res.ok }));
});

This works for a single email. But you'll need to add error handling, retry logic, template management, and tracking yourself. That's a lot of code for "send a welcome email."

Option B: Next.js API Route + Email SDK

If your frontend is Next.js, you can send from an API route instead. This gives you better error handling and keeps email logic close to your application code.

import { WrapsEmail } from "@wraps.dev/email";

const email = new WrapsEmail();

export async function POST(req: Request) {
  const { to, name } = await req.json();

  const result = await email.send({
    from: "hello@yourdomain.com",
    to,
    subject: "Welcome to the app",
    html: `<p>Hey ${name}, welcome aboard!</p>`,
  });

  return Response.json(result);
}

Option C: Database Webhooks

Trigger emails based on database changes. When a row is inserted into your orders table, fire a webhook that sends a confirmation email. More robust than manual API calls, but you can't preview what goes out and debugging is harder.

Newsletters, product updates, announcements. One-time sends to a group of users. Supabase doesn't support this at all — and the workarounds all have significant tradeoffs.

The Common Approaches

The Real Problem: Contact-Based Pricing

Most broadcast tools charge by the number of contacts you store. Your Supabase auth.users table grows, and your email bill grows with it — even if half those users are inactive.

Wraps + SES = Wraps platform fee + AWS SES sending cost. All tiers include unlimited contacts.

Weekly digests, onboarding drip sequences, usage alerts, renewal reminders. The hardest flow to get right — and the most dangerous to get wrong, since you're sending to everyone without seeing the email first.

The pg_cron Approach

Most Supabase developers wire up a pg_cron job that calls an Edge Function on a schedule. It works, but has real limitations.

-- Run every Monday at 9am UTC
SELECT cron.schedule(
  'weekly-digest',
  '0 9 * * 1',
  $$
  SELECT net.http_post(
    url := 'https://your-project.supabase.co/functions/v1/weekly-digest',
    headers := '{"Authorization": "Bearer YOUR_SERVICE_KEY"}'::jsonb
  );
  $$
);

import { createClient } from "@supabase/supabase-js";

serve(async () => {
  const supabase = createClient(
    Deno.env.get("SUPABASE_URL")!,
    Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!,
  );

  // Get all active users
  const { data: users } = await supabase
    .from("profiles")
    .select("email, name")
    .eq("digest_enabled", true);

  // Send to each user... but what does the email look like?
  // No preview. No visual builder. Hope for the best.
  for (const user of users ?? []) {
    await fetch("https://api.resend.com/emails", {
      method: "POST",
      headers: { Authorization: "Bearer re_xxxxx" },
      body: JSON.stringify({
        from: "digest@yourdomain.com",
        to: user.email,
        subject: "Your weekly digest",
        html: buildDigestHtml(user), // hand-rolled HTML
      }),
    });
  }

  return new Response("ok");
});

The Alternative: Visual Workflows

A dedicated email platform with a workflow builder lets you design automated sequences visually — with triggers, delays, conditions, and preview. You see exactly what gets sent before it goes out.

Here's how all four flows come together. Supabase handles auth and database. Wraps handles email as a platform. Everything sends through SES in your AWS account.

Setup: 3 Steps

# 1. Install the CLI
npm install -g @wraps.dev/cli

# 2. Deploy email infrastructure to your AWS
wraps email deploy

# 3. Send your first email
wraps email send --to user@example.com --subject "Hello from Wraps"

The CLI deploys SES, DynamoDB, Lambda, and IAM resources to your AWS account. DKIM, SPF, and DMARC are configured automatically. Takes about 2 minutes.