Best Email Tools for Vibe Coders in 2026
For most vibe coders, the best pick is Resend. Its free plan covers 3,000 emails a month, its Pro plan is $20 a month for 50,000 emails, and its React Email templates are JSX components that sit in the same repository your AI assistant already edits.
Who This Page Is For
This guide is for developers who build products with AI coding assistants such as Cursor, GitHub Copilot and Claude, and who need email to work in the first week of a project. Most of the people searching for this topic are not hiring an email team. They are a founder or a small crew who generated an app in a few sessions and now need password resets, receipts, team invitations and a first onboarding sequence to go out reliably.
That narrows the question. You do not need a cold-outreach platform or a large marketing suite. You need a service with a clean API, a sending domain you can verify with a few DNS records, webhooks for bounces and complaints, and a price that stays predictable while you are still finding product-market fit. Everything below is written with that in mind.
The page covers ten tools that suit this use: nine email and notification services plus React Email, which is a template library rather than a sender. For each one you will see the free plan, the first paid price, what it does well for AI-assisted builds, and where it falls short. You will also find cost tables at three realistic volumes, a decision table, a setup checklist, notes on deliverability and list verification, and a workflow for prompting your assistant without letting it break your sending setup.
Prices come from each vendor's own pricing page, read on 7 October 2026. Vendors change plan limits, so treat the pricing page as the final word on any number you plan around. Where a vendor does not publish a usable price, this page says so instead of estimating.
The Short Answer
Pick Resend if your app is a React or Next.js project and your first emails are transactional. The reason is practical. Templates are React components, so when you ask an assistant to change the reset email's button colour or add an expiry line, the edit happens in the same codebase and the same review cycle as the rest of your code. The free plan is generous enough for development and a small launch, and the Pro plan at $20 a month covers 50,000 emails.
Pick Postmark if you want a transactional-only service with a long track record and you are happy paying from $15 a month for 10,000 emails. Pick Plunk if the cost per email matters more than anything else and you want an open-source project you can read. Pick Loops if your main job is lifecycle email for a SaaS product with a contact list that grows, and you are ready to pay $99 a month once you outgrow the free plan. The rest of the page explains each choice in detail.
Email Tools Compared for Vibe Coders
Each row shows the audience a tool serves best, its entry price with the plan name and billing view, and the limitation most likely to matter once you start building.
| Tool | Best for | Starting price (plan, billing) | Key limitation |
|---|---|---|---|
| Resend | Transactional email from React or Next.js apps, with JSX templates | Free: $0/month, 3,000 emails/month. Pro: $20/month, 50,000 emails/month | Free plan capped at 100 emails a day and 3 domains |
| Postmark | Transactional-only mail such as receipts, invoices and password resets | Free: $0/month, 100 emails/month. Basic: $15/month, from 10,000 emails/month | Free tier stops at 100 emails a month with no overages |
| SendGrid | Teams that want the largest library of examples and docs | Essentials: $19.95/month, 50,000 to 100,000 emails/month | API free trial is 100 emails a day for 60 days only |
| Mailgun | Developers who want an HTTP API and SMTP relay | Basic: $15/month, 10,000 emails/month. Free: 100 emails a day | More configuration than Resend; overages are usage-based |
| Loops | SaaS lifecycle and onboarding email tied to a growing contact list | Early Stage: $0 (up to 4,000 sends in 30 days). Growing Audience: $99/month | Large jump from the free plan to $99/month; free plan shows a Loops footer |
| Plunk | Budget projects and teams that value open-source code | Free forever: $0/month, 1,000 emails/month. Pay as you grow: $0.001 per email | Plunk branding appears on emails in the free plan |
| Novu | Apps that send email plus in-app, SMS, chat and push notifications | Free: $0/month, 10,000 workflow runs/month. Pro: $30/month, 30,000+ runs | Counts workflow runs, not single emails, and carries more setup |
| Courier | Routing one notification across several channels with a visual designer | Developer: free up to 10,000 sends/month. Business: $0.005 per send, pay as you go | Cost grows with every send; enterprise pricing is custom |
| Knock | Notification infrastructure that will grow beyond email | Developer: $0/month, 10K messages. Starter: $250/month, 50K messages | Jump from $0 to $250/month; a message is counted per channel |
| React Email | Building email templates as React components | No sending plan of its own; pair it with a sender from this list | Does not send mail, so you still need a provider |
What Each Tool Costs at Three Realistic Volumes
Most early products send somewhere between a few thousand and a few hundred thousand transactional emails a month. The table shows the lowest published plan that covers each volume, using the monthly view of each price. Where the arithmetic is not a plan price, the working is shown in the cell. Where a plan does not match the volume exactly, the nearest published volume is named.
| Monthly emails | Resend | Postmark | Mailgun | SendGrid | Plunk | Courier | Knock |
|---|---|---|---|---|---|---|---|
| 3,000 | $0 (Free plan, 3,000/month) | $15 (Basic, from 10,000) | $15 (Basic, 10,000) | Trial only: 100/day for 60 days | $2 (2,000 above the free 1,000 at $0.001 each) | $0 (Developer, up to 10,000 sends) | $0 (Developer, 10K messages) |
| 50,000 | $20 (Pro, 50,000) | $55 (Basic at 50,000) | $35 (Foundation, 50,000) | $19.95 (Essentials, 50,000 to 100,000) | $49 (49,000 above the free 1,000 at $0.001 each) | $250 (50,000 at $0.005 pay as you go) | $250 (Starter, 50K messages) |
| 100,000 | $90 (Scale, 100,000) | $115 (Basic at 125,000, nearest listed volume) | $90 (Scale, 100,000) | $89.95 (Pro, 100,000 to 2.5M) | $99 (99,000 above the free 1,000 at $0.001 each) | $500 (100,000 at $0.005 pay as you go) | Starter covers 50K; higher volumes need the Enterprise contact route |
Three things stand out. First, the free tiers of Resend, Courier and Knock all cover a development environment and a very small launch, which is what most vibe-coded projects need for their first weeks. Second, Plunk and Courier are priced per email or per send, so their cost is a straight line; that is useful at low volume and expensive at high volume. Third, Postmark's cheapest paid plan is priced for 10,000 emails a month, so a project sending 3,000 emails pays the same $15 as one sending 10,000.
Loops is not in this table because it prices by contact list rather than by send volume. Its Early Stage plan allows up to 4,000 sends in any rolling 30-day window to the 1,000 newest contacts. The Growing Audience plan is $99 a month and includes unlimited sends to subscribers, plus transactional sends to users outside your audience. If you have 1,000 or fewer active contacts and send lifecycle emails, Loops' free plan may be the cheapest option in this guide. Once the list grows beyond that, the $99 plan is the figure to budget for.
What a Vibe Coder Actually Needs From an Email Tool
Generic buying advice tends to start with features like automation builders and segmentation. For a project built in an AI-assisted workflow, the list is shorter and more specific. The first requirement is that the SDK's types are complete enough that an assistant's autocomplete proposes valid parameters. A send call with a wrong field name fails at runtime, and a generated call with a missing field can fail silently in a way that is hard to notice from the chat window.
The second requirement is an error object you can paste into a chat. When a send fails, the fastest fix is usually to hand the error text to the assistant along with the code that produced it. Services whose errors name the field, the domain or the key involved make that loop short. Vague errors turn it into a guessing game.
The third requirement is webhooks for delivery events. Bounces, complaints and unsubscribes arrive after the send has returned success, and your app needs to record them. If the tool gives you a webhook for these events, you can route them into the same database that stores the user, and your suppression logic can run without a manual export. This matters more than most vibe coders expect, because a product that keeps emailing addresses that bounced will eventually harm its sending reputation.
The fourth requirement is a free tier that is honest about its limits. Free plans in this market differ in what they cap. Some cap the monthly total, some cap the daily rate, some add branding, and some restrict how long a trial runs. A plan that caps per day can block a launch day even when the monthly total is fine, so read the limit that applies to your traffic pattern, not only the headline number.
The fifth requirement is a clear split between transactional and marketing mail. Password resets and receipts must arrive; a newsletter can wait. Mixing them on one sending domain, with one reputation, is a common mistake. Several tools here let you run both, but the cleanest setups send transactional mail from one subdomain and marketing from another, each with its own verified DNS records.
The 10 Tools, Explained for AI-Assisted Builds
Each section covers what the tool does well for a vibe coder, where it falls short, the prices that apply, and a link to the vendor's pricing page. The order follows the recommendation above, not any score.
1. Resend: the best pick for JSX-based transactional email
Starting price: Free at $0/month (3,000 emails/month), Pro at $20/month (50,000 emails/month)
Resend suits a React or Next.js app better than most alternatives because its template system is React itself. A password-reset email is a component with a button, a heading and an expiry line. Your assistant can read the component, change it and keep the props typed in the same pass as the route handler that calls it. That keeps template work out of a separate design tool and inside the code review you already do.
For AI-assisted work, the value is consistency. The send call takes a from, a to, a subject and either html or a react element, and it returns a data object or an error. A prompt such as "send a receipt email and log the id, handle the error case" produces a short, readable function. The free plan includes 3,000 emails a month, which covers development and a small launch, and the Pro plan at $20 a month covers 50,000.
Where it falls short: the free plan is capped at 100 emails a day and 3 domains, so a launch-day spike can hit the daily cap even when the monthly total is well within range. Marketing features are priced on a separate contact-based scale; the Marketing Free tier covers 1,000 contacts and the Pro marketing plans step up from $40 a month at 5,000 contacts to $450 a month at 100,000. If your main job is large newsletters rather than product mail, a marketing-first tool may fit better.
Setup notes: verify the sending domain in the dashboard before you write the first send call, because the from address must use a verified domain. Keep the API key in server-side environment variables, never in client bundles. Full pricing is on resend.com/pricing.
2. Postmark: transactional mail with a long track record
Starting price: Free at $0/month (100 emails/month), Basic at $15/month (from 10,000 emails/month)
Postmark is built around transactional mail: receipts, invoices, password resets, login alerts and status notices. That focus shows in the product. The API is small, the templates can be managed in the dashboard and sent by alias, and the service is organised around separate streams so that transactional and broadcast mail do not share a reputation. For a vibe-coded app whose email is mostly one-to-one messages triggered by the product, that narrowness is an advantage.
For AI assistance, Postmark's predictable request shape keeps generated code short. Ask for a function that sends a template with a model object and the output is usually close to working. The trade-off is that the free plan is small: 100 emails a month with no overages, so anything beyond a test account needs a paid plan. The Basic plan starts at $15 a month for 10,000 emails, with Pro at $16.50 and Platform at $18 for the same starting volume. At 50,000 emails the Basic figure is $55 a month, and at 125,000 it is $115.
Where it falls short: because Postmark is transactional-first, it is not the place to run a broad newsletter or a lifecycle automation series. Pair it with a marketing tool if you need both, or choose a combined service in this guide. Pricing is at postmarkapp.com/pricing.
3. SendGrid: the largest pool of examples
Starting price: Essentials at $19.95/month (50,000 to 100,000 emails/month); Marketing Campaigns Free at $0 (up to 2,000 contacts, 6,000 emails/month)
SendGrid has been in use for many years, so its documentation, tutorials and community answers are everywhere. For a vibe coder, that breadth means an assistant has likely seen many SendGrid integrations, and a prompt about sending transactional email often produces a usable starting point. If you want the most examples to compare against, SendGrid has them.
The cost of that breadth is size. The API surface is large, the web interface is extensive, and the plan selector lists many tiers. Older examples online sometimes use patterns that have since been replaced, so when you prompt an assistant, name the current API version and ask it to check the call against the current docs before you rely on it. The API free trial is 100 emails a day for 60 days, which is useful for a development period but not an ongoing free plan. After that, Essentials at $19.95 a month covers 50,000 to 100,000 emails, and Pro at $89.95 a month covers 100,000 to 2.5 million.
For marketing mail, the Marketing Campaigns Free plan covers up to 2,000 contacts and 6,000 emails a month. The paid Basic plan is $15 a month for up to 100,000 contacts and 300,000 emails, and Advanced is $60 a month for up to 200,000 contacts and 1 million emails. These figures are the vendor's plan-selector limits, so check them against your own contact count before you choose. Pricing is at the Twilio email API pricing page.
4. Mailgun: an HTTP API and SMTP relay
Starting price: Free at $0 (100 emails/day); Basic at $15/month (10,000 emails/month)
Mailgun offers both a RESTful email API and an SMTP relay. That matters for a vibe coder who already uses an SMTP library in a framework, or who wants one service behind a mail server that other tools also use. The API is documented, the TypeScript support is adequate, and the service handles transactional sending at scale.
For AI-assisted coding, Mailgun is workable but needs more guidance than the simplest APIs in this guide. An assistant can generate the basic send call well, but routes, mailing lists and webhooks take more explicit prompting, and you should check the generated webhook signature handling yourself. Mailgun's plans are monthly by email volume: Basic at $15 a month for 10,000 emails, Foundation at $35 a month for 50,000 and Scale at $90 a month for 100,000. Mailgun describes a one-month free period on Foundation and Scale, which can help when you move up a tier during a launch.
Where it falls short: the free plan is capped at 100 emails a day, so it is a development plan rather than a launch plan, and overages are billed by usage for email and for validation. If you plan to use address validation alongside sending, read the overage terms on the pricing page before you commit. Details are at mailgun.com/pricing.
5. Loops: lifecycle email for a SaaS product
Starting price: Early Stage at $0/month (up to 4,000 sends in any rolling 30 days, 1,000 newest contacts); Growing Audience at $99/month
Loops is designed for the situation many vibe-coded SaaS products reach after launch: a list of users who sign up, activate, churn or upgrade, and who should receive email tied to those events. Its model is contact-based, and events from your app update a contact's properties, which can then trigger a sequence. For a founder who wants onboarding and re-engagement emails without building a queue, that is a good fit.
For AI-assisted work, the attraction is a small surface. The minimal API means fewer ways for generated code to go wrong, and the most common operations are contact creation and event sending. The trade-off is that you must decide early which events matter and name them consistently, because the sequences you build depend on those names. Ask your assistant to keep event names in one constants file and reuse them, so a renamed event does not silently stop a sequence.
Where it falls short: the free plan covers up to 4,000 sends in a rolling 30 days to the 1,000 newest contacts, carries a Loops footer, and allows 10 emails per second. Once you need more, the Growing Audience plan is $99 a month, which is a large step. It includes unlimited sends to subscribers and transactional sends to users outside your audience. Pricing details are at loops.so/pricing.
6. Plunk: open source and the lowest per-email cost
Starting price: Free forever at $0/month (1,000 emails/month); Pay as you grow at $0.001 per email
Plunk is an open-source email service with transactional emails, workflow automation and campaign broadcasts, plus custom domains and unlimited contacts on its free plan. For a vibe coder who wants to read the code behind a send, that transparency is the main draw. When an assistant generates a Plunk integration, you can open the project and check what the request does, which is useful when you are learning as you ship.
The price structure is simple. Free forever covers 1,000 emails a month. Pay as you grow charges $0.001 per email, which is $1 per 1,000, and removes Plunk branding from your emails. The plan includes a monthly spend cap, so an unexpected loop in your code cannot run up an unlimited bill. At 50,000 emails a month the arithmetic is 49,000 billable emails at $0.001, or $49, after the free 1,000.
Where it falls short: the free plan adds Plunk branding to emails, which many products will not want in front of customers. Plunk's ecosystem is smaller than the largest vendors', so an assistant has fewer published examples to draw on, and you should expect to read the docs more closely. Check the current terms on useplunk.com/pricing before you rely on the cap.
7. Novu: email plus other notification channels
Starting price: Free at $0/month (10,000 workflow runs/month); Pro at $30/month (30,000+ workflow runs/month)
Novu is for products that need more than email. A single workflow can send an email, an in-app message, an SMS, a chat message or a push notification, depending on the user's preferences. If your app will need several of those channels within a few months, learning one notification model is cheaper than adding a second tool later.
For AI-assisted coding, the workflow model is powerful but has more moving parts than an email-only API. An assistant can generate a trigger call and a subscriber update, but the workflow definitions and preference logic need careful review. Use the visual editor to lay out the flow and ask your assistant to write the trigger code against the workflow identifiers, which keeps the code short and the logic visible.
The free plan includes 10,000 workflow runs a month, up to 20 workflows, two environments and a 24-hour activity feed. Pro is $30 a month for 30,000 or more runs, with seven days of activity-feed retention and removal of Novu branding. Team is $250 a month for 250,000 or more runs, with 10 environments and 90 days of retention. Note that a workflow run is not the same as one email, so count your runs before you compare against a per-email price. Details are at novu.co/pricing.
8. Courier: notification routing with a visual designer
Starting price: Developer at $0/month (10,000 sends/month, free); Business at $0.005 per send, pay as you go
Courier focuses on routing a single notification across channels and templating it in one place. Its Developer plan includes journeys and broadcasts, an MCP server, a CLI and SDKs, and single sign-on through Google and GitHub. That combination suits a team that wants a designer for notification copy alongside code that calls it.
For AI-assisted work, the SDK is typed and basic sends are straightforward to generate. Routing rules and journey logic are the harder part, and the most reliable approach is to keep routing decisions in the designer and ask the assistant only for the trigger code. That split keeps generated code small and makes changes visible to non-engineers on the team.
Where it falls short: the cost scales with every send. The Business plan is pay as you go at $0.005 per send, so 100,000 sends is $500 before any other charge, and Enterprise pricing is custom and tied to volume discounts. For a pure email product at high volume, a plan-based sender in this guide is usually cheaper. Pricing is at courier.com/pricing.
9. Knock: notification infrastructure for a growing product
Starting price: Developer at $0/month (10K messages included); Starter at $250/month (50K messages included)
Knock provides notification infrastructure: workflows, broadcasts, delivery channels and team members, with the Developer plan including unlimited workflows, broadcasts, channels and team seats. It suits a product that expects to send across several channels and wants a managed layer between the app and each provider.
The API is TypeScript-first, so an assistant's autocomplete on trigger payloads and subscriber properties is usually reliable. Keep the workflow keys in a shared file, the same way you would for event names in another tool, so generated calls stay consistent across the codebase.
Where it falls short: the jump from $0 to $250 a month is large, and Starter includes 50,000 messages with prepaid usage after that at $0.005 per message. A message is one successful send to one user on one channel, so a user who receives an email and an SMS counts twice. Enterprise is priced on contact. Check the definition on knock.app/pricing before you model costs.
10. React Email: templates as components
No sending plan of its own; pair it with a sender from this list
React Email is a template library. You write email layouts with React components such as containers, buttons, text and links, preview them locally, and render them to HTML for a sending provider. It does not send mail, and it does not store contacts or track events. It belongs in this guide because it is the most natural way for a React-based vibe coder to build the body of a transactional email.
For AI assistance, it is an excellent target. Assistants generate React components reliably, so a prompt such as "create a purchase confirmation with an order table and a support link" usually produces a layout you can preview in a minute. Keep the components in a separate emails folder, pass typed props from the route handler, and render the component to HTML before handing it to Resend, Postmark, Mailgun or Plunk.
Where it falls short: email clients are inconsistent, so generated markup needs a preview check in more than one client before you trust it, and a component that looks right in a browser can still break in an older mail client. The library is open source, so the cost is your time to review the output, not a subscription.
Deliverability and List Verification
Deliverability is the part of email that vibe coders most often skip, and it is the part most likely to hurt a product later. Every tool above will ask you to add DNS records for your sending domain. These usually include an SPF record that names the services allowed to send for the domain, a DKIM record with a public key that signs your messages, and a DMARC record that tells receivers what to do with mail that fails those checks. The vendor's dashboard shows the exact values. Ask your assistant to explain each record and to check that the values match the dashboard, but add the records in your DNS provider yourself and wait for the vendor to mark the domain verified.
Use a subdomain for product mail, such as mail.yourproduct.com, rather than your root domain. That keeps the reputation of your transactional stream separate from anything you send to a list later. Start the DMARC policy in monitoring mode, read the reports for a few weeks, and tighten it once legitimate senders are all passing. This is a manual step that no SDK can do for you.
Bounces and complaints are the second half of the job. Hard bounces mean an address does not exist, and continued sends to such addresses damage the reputation of your sending domain. Each tool in this guide either sends delivery webhooks or can be configured to, and your app should write those events to the user record and stop sending to addresses that hard-bounced. Ask your assistant to write the webhook handler with a signature check and an idempotency key, then test it with the vendor's sample events before you connect it to production.
List verification is a separate category. Services such as ZeroBounce, NeverBounce and Kickbox check whether an address is valid before you send to it. They are useful when you import a list from elsewhere, or when a signup form accepts addresses that are not real. They are not sending services, so they do not replace the tools above. This page lists no prices for them because the vendors publish their own plans and the figures change; read each vendor's pricing page directly before you budget for verification. A common pattern is to verify a list once at import, keep the valid results, and run the webhook suppression described above for anything that bounces later.
Decision Table: Which Tool for Which Need
Read the first column for the need closest to yours, then take the pick and the reason. The last column names the constraint to check before you commit.
| If you need | Pick | Because | Check before you commit |
|---|---|---|---|
| Transactional mail from a Next.js or React app | Resend | Templates are JSX components in your repository; Pro is $20 a month for 50,000 emails | The 100-emails-a-day free cap on launch days |
| Receipts, invoices and resets only, with a long track record | Postmark | Transactional-only focus; Basic from $15 a month for 10,000 emails | Free plan stops at 100 emails a month |
| The most examples for an assistant to draw on | SendGrid | Large documentation and community footprint; Essentials at $19.95 a month | The API free trial lasts 60 days; name the current API version in prompts |
| An HTTP API plus SMTP relay for an existing mail setup | Mailgun | Both interfaces; Basic at $15 a month for 10,000 emails | Usage-based overages for email and validation |
| Onboarding and lifecycle email for a SaaS list | Loops | Contact-based model; free up to 4,000 sends in 30 days to the newest 1,000 contacts | The $99 a month Growing Audience price once the list grows |
| The lowest per-email cost with open-source code | Plunk | $0.001 per email on pay as you grow, with a monthly spend cap | Plunk branding on the free plan |
| Email plus in-app, SMS, chat and push from one workflow | Novu | Multi-channel workflows with a visual editor; Free includes 10,000 runs a month | Workflow runs are not the same as emails; the 24-hour free activity feed |
| Routing one notification across channels with a designer | Courier | Routing and templating in one place; free Developer plan for 10,000 sends | Pay-as-you-go cost of $0.005 per send at volume |
| Notification infrastructure that will outgrow email | Knock | TypeScript-first API; Developer plan at $0 with 10K messages | The $250 a month Starter step; messages counted per channel |
| Email layouts written as React components | React Email | Assistants generate React reliably; open source | It does not send mail; pair it with a sender |
Setup Checklist for a New Sending Domain
Work through this list in order the first time you connect an email service to a vibe-coded app. Each step ends with a check you can confirm before moving on.
| Step | Action | Done when |
|---|---|---|
| 1. Choose by volume | Pick the plan from the cost table that covers your expected monthly sends with room to spare | The plan's monthly limit and daily cap both fit your launch week |
| 2. Use a subdomain | Send product mail from a subdomain such as mail.yourproduct.com | The root domain has no new sending records added for this service |
| 3. Add DNS records | Add the SPF, DKIM and DMARC values shown in the vendor dashboard | The vendor shows the domain as verified |
| 4. Store the key safely | Put the API key in server-side environment variables and never in client code | Searching the repository for the key returns nothing |
| 5. Send a test message | Send one email to a test inbox from the route that will use it in production | The message arrives, and the id returned by the API is logged |
| 6. Wire delivery webhooks | Route bounce and complaint events to the user record and a suppression check | A hard bounce in the vendor's sample events stops future sends to that address |
| 7. Separate streams | Keep transactional and marketing mail on different subdomains or tools | Marketing sends are the only ones carrying an unsubscribe link |
| 8. Verify imported lists | Run any imported list through a verification service before the first campaign | Invalid addresses are removed from the sendable list |
How to Choose
Start with the kind of email you will send in the first ninety days. If it is almost entirely triggered by your product, such as sign-ups, resets, receipts and invoices, you need a transactional service and nothing more. Resend, Postmark, Mailgun and SendGrid all cover that. If it is a sequence that depends on who has signed up and what they did, you need lifecycle tooling, and Loops is the closest fit in this list. If you expect to add SMS, push or in-app messages soon, Novu or Knock avoids a second integration later.
Then price the next step up, not only the free plan. Free plans are built for development, and a launch week can hit a daily cap or a contact limit within days. Write down the monthly volume you expect after launch, read the matching row in the cost table, and check the daily limit as well. A tool that is cheap at 3,000 emails and expensive at 50,000 may be the wrong long-term choice even if it is the right first one.
Finally, look at the errors and the types. For vibe coders, the practical test is how the tool behaves when your assistant gets something wrong. Clear errors and complete types make that correction quick. Vague errors and loose types make it slow. Try a deliberately wrong send call in a scratch project before you commit, and see what the error says.
Avoid two common mistakes. The first is choosing the tool with the most examples and ignoring the cost of the plan you will need in three months. The second is choosing the cheapest per-email price and ignoring the free-plan branding or the cap that will block a launch. Both mistakes are easy to avoid by reading the limit that applies to your own traffic, not the headline figure.
A Workflow for Prompting Your Assistant
Assistants are good at the code around email and weaker at the account settings that email depends on. Divide the work accordingly. You handle the dashboard, the DNS records and the key. The assistant handles the send function, the template component and the webhook handler. Keep the boundary explicit in your prompts so the assistant does not try to invent a dashboard setting.
A reliable first prompt names the service, the sending domain placeholder and the function signature you want, and asks for error handling that logs the id. For example: "Using the Resend SDK, write a server function sendPasswordReset that takes a user with an email and a name, renders the PasswordResetEmail component to the html field, sends from the verified domain stored in an environment variable, and throws a typed error with the vendor message when the send fails." That prompt is specific enough to produce working code and narrow enough to review.
Review the output against the vendor's documentation for three things: the from address format, the handling of the error object, and the webhook signature check. Assistants tend to get these details right in outline and wrong in small ways, so read them rather than trusting the completion. Then send one message to a test address and check the headers in the received copy to confirm the DKIM and SPF results.
Here is a minimal example for Resend. It uses the public SDK, reads the key and sender from the environment, and surfaces the vendor's error instead of hiding it:
import { Resend } from 'resend';
const resend = new Resend(process.env.RESEND_API_KEY);
export async function sendPasswordReset(user: { email: string; name: string }, html: string) {
const { data, error } = await resend.emails.send({
from: process.env.MAIL_FROM,
to: user.email,
subject: 'Reset your password',
html,
});
if (error) {
console.error('reset email failed', error);
throw new Error('Password reset email could not be sent');
}
return data;
} The example leaves rendering out on purpose. Keep the template render step in its own function so you can preview the component on its own and so a rendering error is not mistaken for a sending error. The MAIL_FROM variable should hold an address on the verified subdomain from the checklist above.
For payment events such as failed charges, the pattern is the same. Your payment provider's webhook calls a handler, the handler checks the signature, looks up the user, and calls the sending function with the right template. Keep the webhook handler small, put the template logic in the component, and log the vendor's event id so you can match a complaint to the event that caused it.
Related Guides
For Cursor Developers
Email tools whose TypeScript types work well with editor autocomplete.
For React Developers
Email tools that integrate with React and JSX templates.
For Startups
Email tools priced for early-stage volume and growth.
For the full list of email services across use cases, see the main comparison.
Frequently Asked Questions
Practical questions about choosing and setting up email for a vibe-coded product.
Which email service should a vibe coder pick first?
If your app is a React or Next.js project and your first emails are transactional, start with Resend. Its templates are React components in the same repository, its free plan covers 3,000 emails a month, and its Pro plan is $20 a month for 50,000 emails. If you need lifecycle sequences tied to a contact list, Loops is the closer fit, and if you want only the cheapest per-email price, Plunk.
Is a free plan enough to launch?
It can be, for a small launch. Resend's free plan allows 3,000 emails a month but only 100 a day. Postmark's free plan allows 100 emails a month. Plunk's free plan allows 1,000 emails a month with branding. Courier's Developer plan allows 10,000 sends a month. Check the daily cap as well as the monthly one, because a launch day can exceed a daily cap while the month is still well within range.
Do I need to separate transactional and marketing email?
In most cases, yes. Password resets and receipts must be delivered, while a newsletter can be delayed or skipped. Sending both from one domain puts them under one reputation. Using a subdomain for product mail and a separate stream for marketing keeps the important messages protected and makes it easier to read your bounce and complaint numbers.
Can an AI assistant set up SPF, DKIM and DMARC for me?
It can explain the records and draft them from the values in your vendor's dashboard. You still need to add them in your DNS provider, and the vendor must mark the domain verified. Check the record values against the dashboard by hand, because a single wrong character will fail verification.
Do I need list verification as well as a sending service?
Only if you send to a list you did not collect directly from confirmed sign-ups, or if your sign-up form accepts unchecked addresses. Services such as ZeroBounce, NeverBounce and Kickbox verify addresses before you send. They are separate from the sending tools in this guide, and this page does not list their prices; use each vendor's pricing page.
Why does Resend's price jump from free to $20 a month?
The free plan is sized for development and small launches, with 3,000 emails a month and 100 a day. The Pro plan at $20 a month raises the monthly allowance to 50,000 emails. Plans step up by volume, so the next step to consider is the one that matches the monthly volume you expect after launch, not only the first one you need.
Does React Email send email?
No. React Email builds the email layout as React components and renders it to HTML. You still need a sending service such as Resend, Postmark, Mailgun or Plunk to deliver the message. Because it is open source, the cost is the time you spend reviewing the generated markup across mail clients.