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 actually 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.
Starting next month: a public deliverability report, every 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.
Mailchimp Transactional (Mandrill) is winding down. Here's the migration path
What's actually changed about Mandrill's standalone availability, and what a straightforward path off it looks like.
When to stop calling the SES API directly and use a control plane instead
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 your SPF/DKIM records during a provider switch without a delivery gap
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 without a deliverability dip
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 actually works for transactional email
What happens the moment you cross your tier's included volume, using the real published rate as the example.
Annual vs monthly billing for an email API: when the discount is worth it
A 15% discount sounds like an easy yes. Here's when it actually is, and when monthly is the more honest choice.
Why most "free tier" email APIs cap you at 100/day, and why that's the wrong limit
A daily cap breaks the moment you have a real traffic spike. A monthly cap doesn't.
Running multiple client domains through 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 role-based access, not one 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 actually 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.
Why a no-questions-asked first-invoice refund is a real 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 actually 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 actually belongs on a subprocessor list (and why 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, explained for people who aren't 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: what actually has to happen
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 correctly (most guides get one step wrong)
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 even if nothing else does
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 actually 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, and where the (not yet on PyPI) Python SDK fits in.
Sending transactional email from Rails without ActionMailer's SMTP defaults
There's no Ruby SDK yet, and that's fine. A plain HTTP call from ActionMailer's deliver method covers it.
Sending transactional email from Laravel with a real API, not SMTP
Swap Laravel's Mail facade's SMTP transport for a direct HTTP call, and where the (not yet on Packagist) PHP SDK fits in.
Sending email from a Cloudflare Worker
No Node SDK dependency needed. A Worker's built-in fetch is the whole integration.
Sending email from Supabase Edge Functions
Deno's built-in fetch, a Supabase secret for the API key, and a database webhook or trigger to call it. No extra dependency required.
Sending transactional email from Deno
Deno's built-in fetch and explicit permission model. No import, no --allow-net surprise if you know it's coming.
Sending transactional email from FastAPI
An async httpx call that fits FastAPI's async request handling, plus a background-task pattern so sending doesn't block the response.
Sending transactional email from NestJS, the right way
A dedicated EmailService, NestJS's HttpModule or plain fetch, and where dependency injection actually earns its keep here.
Sending transactional email from Remix
Send from an action, not a loader or the client. Fetch works the same whether you're on Node or an edge runtime.
Sending transactional email from a Go service
The real Go SDK, and the honest caveat that it isn't a versioned module yet. Plus what the plain net/http version looks like.
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 codes over email need faster delivery guarantees than you 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 actually 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, and 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: the dunning sequence that doesn't feel like 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? It matters for deliverability
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 when, 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. letting test mode through
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 current 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 your own 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 rate and complaint rate actually 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 from a 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: what they are and why "just retry the bounce" is wrong
A hard bounce or complaint should permanently block future sends to that address. Retrying it isn't resilience, it's the exact pattern that tanks your reputation.
How domain blocklist monitoring actually works (and what to do when you're listed)
Real public DNSBLs, checked against your verified domains, with alerts only on a state change, not constant noise.
Answering a vendor security questionnaire for your email provider, without three weeks of email
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 actually keep email logs? A compliance-driven 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: what actually changes 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.