Notes from building email infrastructure
SPF, DKIM, and DMARC explained for SaaS founders
The three DNS records that decide whether your transactional email lands in the inbox or the spam folder, in plain language.
Why EU data residency matters for transactional email
GDPR, NIS2, and the questions your DPO asks before signing off on a US-hosted email provider, and what "EU-hosted" should actually mean.
Why 7-day log retention isn't enough
A customer says they never got the email. If your provider only keeps a week of logs, you've already lost the evidence to find out why.
A public deliverability report, starting next month
What we'll publish, where the numbers come from, and why we're not backdating a report with estimates.
Migrating from Resend to Envello
The codemod, the DNS changes, and the parts of a Resend migration that are actually manual, in the order you'll hit them.
Migrating from SendGrid to Envello
What's a mechanical swap and what actually needs manual rework, including the honest answer on dynamic templates.
Migrating from Postmark to Envello
Field-name changes, what Message Streams becomes, and the honest answer on Postmark's server-side templates.
Migrating from Mailgun to Envello
Mailgun already has an EU region, so the honest reasons to switch are elsewhere: request shape, log retention, and pricing predictability.
How to get a signed DPA without a sales call
What Envello's DPA actually is, where to get it, and why it doesn't require a demo, a champion, or a procurement cycle first.
Migrating from Mailchimp Transactional (Mandrill) to Envello
Field-by-field mapping from Mandrill's messages/send to Envello, and what to check before you cut over.
When to stop calling SES directly, use a control plane
Calling SES directly is sometimes the right call. Here's an honest breakdown of when it stops being the right call.
Dual-sending during a provider migration: worth it or not?
Running both providers at once sounds safer. Here's when that safety is real and when it's just extra complexity.
Changing SPF/DKIM records during a provider switch
The order that matters: add before you remove, verify before you cut over, and why a shared SPF record is safer than replacing one outright.
Switching transactional email providers with zero downtime
Putting the DNS, code, and rollout pieces together into one sequence that doesn't require a maintenance window.
The real checklist for migrating email providers
One list that pulls together DNS, code, and rollout steps from the provider-specific guides, for whichever provider you're actually switching from.
Why Envello locks your price for 24 months
The exact terms of the pledge: what's locked, what notice you get when it changes, and why that's published instead of buried in a contract.
The email API costs that don't show up on the pricing page
Overage rates, add-ons, and the questions worth asking before you pick a tier, using Envello's own published numbers as the example.
How much vendor lock-in does an email API actually create?
Less than your database or auth provider, but not zero. An honest look at what's actually hard to walk away from.
How pay-as-you-go overage billing works for email
What happens the moment you cross your tier's included volume, using the real published rate as the example.
Annual vs monthly email API billing: when the discount works
A 15% discount sounds like an easy yes. Here's when it actually is, and when monthly is the more honest choice.
Why free-tier email APIs cap at 100/day, the wrong limit
A daily cap breaks the moment you have a real traffic spike. A monthly cap doesn't.
Running multiple client domains on one email API account
What usage-by-domain reporting actually gives you, and why it matters more for agencies than the headline pricing does.
Why your email API needs roles, not a shared login
The three real roles Envello supports, and why a shared login is a bigger risk for an email API than it looks like.
What an audit log should capture (and what it shouldn't)
A closed action vocabulary, never a raw API key, never a recipient's address. The specific PII discipline behind Envello's audit log.
A no-questions-asked first-invoice refund is a trust signal
It costs the provider something real to offer this. That's exactly why it means more than a satisfaction guarantee banner.
NIS2 and what it changes for SaaS email infrastructure
NIS2 expands who counts as a regulated entity in the EU. What that means, and doesn't mean, for a SaaS company sending transactional email.
What belongs on a subprocessor list (most are stale)
A subprocessor list is only useful if it's current and specific. What Envello's actually looks like, and the notice period that keeps it honest.
Does the US CLOUD Act reach your "EU-hosted" email provider?
Data location and corporate jurisdiction are two different questions. Why that distinction matters when a vendor claims EU-hosted.
Standard Contractual Clauses for non-lawyers
What SCCs actually do, why they show up in a subprocessor list, and when you'd need to check for them at all.
GDPR's right to erasure and transactional email
There's no dedicated erasure button. Here's honestly how deletion actually works, and why the retention window is the mechanism, not an afterthought.
Verifying webhook signatures, the step most guides miss
The exact scheme, the exact header format, and the one step (verifying against the raw body, not re-serialized JSON) that breaks most implementations.
Idempotency keys: why your email-sending code needs them
A retried request without an idempotency key can send the same email twice. Here's the actual mechanism that prevents it.
Dedicated IP vs shared pool: when the upgrade matters
A dedicated IP is not a magic deliverability fix, and it can hurt you at low volume. When it's actually worth the add-on cost.
Sending transactional email from Django, done right
Skip Django's SMTP EmailBackend for transactional sends. A plain HTTP call to Envello, with async sending via Celery and webhook integration.
Sending email from Rails without ActionMailer's SMTP
There's no Ruby SDK yet, and that's fine. A plain HTTP call from ActionMailer's deliver method, with Sidekiq background delivery.
Sending transactional email from Laravel with a real API
Swap Laravel's Mail facade's SMTP transport for a direct HTTP call. Covers queued jobs, error handling, and webhook handling.
Sending email from a Cloudflare Worker
No Node SDK dependency needed. A Worker's built-in fetch is the whole integration, with error handling, suppression, and webhook handling.
Sending email from Supabase Edge Functions
Deno's built-in fetch, a Supabase secret for the API key, and a database webhook to call it. Covers RLS considerations and webhook handling.
Sending transactional email from Deno
Deno's built-in fetch and explicit permission model. Covers the basic send, error handling, async patterns, and webhook verification.
Sending transactional email from FastAPI
An async httpx call that fits FastAPI's async request handling. Covers BackgroundTasks, error handling, webhook verification, and testing.
Sending transactional email from NestJS, the right way
A dedicated EmailService, NestJS's HttpModule, and where dependency injection earns its keep. Covers BullMQ, error handling, and testing.
Sending transactional email from Remix
Send from an action, not a loader or the client. Fetch works the same on Node or an edge runtime. Covers validation and webhooks.
Sending transactional email from a Go service
The real Go SDK, now at a tagged v0.1.0. Plus the plain net/http version, goroutine-based async sending, and webhook verification.
Password reset emails: what actually needs to be in them
A short list of what matters (expiry, no password in the email, a real sender address) and what's just decoration.
Why 2FA email codes need faster delivery than you'd think
A 6-digit code that arrives 90 seconds late is a support ticket. What actually determines delivery speed, and where email fits vs. SMS.
Receipt and invoice emails: the fields customers look for
The specific line items people scan for when they open a receipt, and why a screenshot-friendly layout matters more than branding here.
Shipping notification emails: triggers, timing, what breaks
The three real trigger points, why timing relative to the carrier event matters, and the retry problem most integrations miss.
Magic link login emails: security tradeoffs most guides skip
A magic link is a bearer token sent over a channel you don't fully control. What that actually means for expiry, single-use, and email forwarding.
Failed payment emails: a dunning sequence, not nagging
How many emails, spaced how far apart, saying what. The real tradeoff between recovering revenue and burning goodwill.
Is a welcome email transactional or marketing?
The line isn't about tone, it's about whether the recipient took an action expecting this specific email. Where welcome emails actually fall.
Security alert emails: what to send, without crying wolf
Alert fatigue is a real deliverability and trust risk. Which events actually warrant an email, and which belong in an activity log instead.
Email verification at signup: blocking sends vs. test mode
You don't have to choose between verifying your own account and building your integration. How test-mode keys handle this in practice.
Building transactional email templates with React Email
Component-based email templates, rendered to HTML at send time. Where this fits for a real transactional flow, not just the quickstart example.
Gmail and Yahoo's bulk-sender rules in 2026: the checklist
Valid SPF and DKIM, a DMARC policy, a sub-0.3% spam complaint rate, and one-click unsubscribe. What's actually enforced and at what volume.
Moving from p=none to p=reject without breaking mail
The staged path, what the aggregate reports actually tell you, and why jumping straight to p=reject is the mistake that breaks legitimate mail.
What bounce and complaint rates trigger a suspension
The real numbers: 5% bounce, 0.3% complaint. Why these exist, and what they're actually protecting.
Why you can't send 50,000 emails on day one, new domain
The actual ladder: 100, 500, 2,000, 10,000, 50,000, with 3 consecutive good days required to climb each rung.
Suppression lists: why "just retry the bounce" is wrong
A hard bounce or complaint should permanently block future sends. Retrying it isn't resilience, it's the pattern that tanks your reputation.
How blocklist monitoring works (and what to do if listed)
Real public DNSBLs, checked against your verified domains, with alerts only on a state change, not constant noise.
Answering a security questionnaire without three weeks
The questions every security questionnaire asks about a transactional email vendor, and where to find the answers in minutes instead of weeks.
What to actually check in a DPA before signing it
A practical DPA checklist for SaaS teams: the eight clauses that matter, what good looks like in each, and the wording that should make you push back.
How long should you keep email logs? A compliance answer
GDPR's storage limitation principle applied to email event logs: what to keep, for how long, and how to pick a retention window you can defend.
AWS SES eu-central-1 vs us-east-1 for a European sender
Region choice in SES affects data residency, latency, quotas, and warmup, but not mailbox-provider reputation. Here's what changes and what doesn't.
Open and click tracking without the privacy landmines
How email open and click tracking actually works, why it's personal data under GDPR, and the defaults that keep it useful without becoming a liability.
What is transactional email? A guide for developers
Transactional email is any message triggered by a user action: password resets, order confirmations, login alerts. What it is and how to get it right.
Email deliverability guide: reach the inbox, not spam
A practical guide to email deliverability for developers: SPF, DKIM, DMARC, sender reputation, bounce handling, and monitoring, with concrete thresholds.
Sending transactional email from Spring Boot with Envello
Skip JavaMail and Spring's SMTP abstraction. A direct HTTP call to Envello from any Spring Boot app, with async sending and logging.
Sending transactional email from ASP.NET with Envello
Replace SmtpClient with a direct HTTP call to Envello's API. Covers HttpClient setup, dependency injection, async patterns, and error handling in ASP.NET Core.
Sending transactional email from Next.js with Envello
Send transactional email from Next.js API routes and Server Actions. Covers the fetch call, React Email integration, and edge runtimes.
Sending transactional email from Nuxt.js with Envello
Send transactional email from Nuxt 3 server routes using $fetch. Covers runtime config, error handling, and deployment options.
Sending transactional email from SvelteKit with Envello
Send transactional email from SvelteKit form actions and API routes. Covers server-only code, error handling, and deployment.
Sending transactional email from Elixir/Phoenix with Envello
Skip Bamboo's SMTP adapter. A direct HTTP call to Envello from Phoenix, with async sending, job queuing, and structured telemetry.
How to read a DMARC aggregate report
The XML your mailbox providers send back is unreadable by design. Here's what each field actually means and how to tell a real problem from noise.
Envello as Supabase Auth's custom SMTP provider
Supabase's built-in email sender is rate-limited and unbranded. Swap in Envello as a custom SMTP provider for confirmation, magic link, and reset emails.