There's a specific kind of panic that hits every founder at the worst possible moment: you're mid-outbound-campaign, your pipeline is finally filling up, and then — silence. Opens drop to zero. Replies stop. You log into Apollo or Instantly and there it is: a compliance flag, a rate-limit warning, or a "your account is under review" banner. Your entire outreach machine just got switched off by a company you pay $99/month to, and you have exactly zero recourse.
That moment is almost always a cold email deliverability problem, and it's the ugly stepchild of the self-hosting world. I wrote about self-hosted transactional email and self-hosted email for receiving before — but cold email is a different beast entirely. It's not "send a password reset." It's "send a thousand personalized messages to people who didn't ask for them, at volume, and land in the inbox anyway." That's the hardest email problem there is, and it's also the one where renting your reputation is the most dangerous.
Here's the uncomfortable truth the SaaS marketing hides: Apollo and Instantly are selling you access to their sending infrastructure and their domain reputation — and they can revoke it anytime. One complaint spike, one bad list, one algorithm change on their end, and your outreach is dead. Not throttled. Dead. And when your cold email dies, your pipeline dies with it.
The good news: the tools to self-host this are mature, open-source, and genuinely better in one specific way that matters more than anything else — you own the sending infrastructure, which means you own the reputation, which means nobody can pull the plug on you. Here's the full picture: the stack, the DNS, the warmup, and the exact docker-compose config that makes cold email land.
Why Cold Email Is a Completely Different Problem From Transactional Email
Let me draw the line clearly, because this is where 90% of self-hosters go wrong before they even start.
Transactional email sends to people who expect the mail — your users, your customers, people who asked for a reset or signed up for a notification. The receiving side wants to hear from you, or at least tolerates it. Deliverability is a matter of clean SPF/DKIM/DMARC and a warm, established domain.
Cold email sends to people who never heard of you and didn't ask to be contacted. The receiving side — Gmail, Outlook, Yahoo — is actively trying to figure out whether you're a legitimate sender or a spammer. And the default assumption is spammer. You're starting from a position of suspicion, on a brand-new domain with zero reputation, asking for the most forgiving treatment inbox providers are capable of.
The failure modes are different too:
- Transactional email fails when you can't be trusted. Bad DNS, misaligned DKIM, a DMARC policy that contradicts itself.
- Cold email fails when you can't be proven human. Too much volume too fast, a domain that's only days old, a list that's been scraped and blasted, zero warmup — the signals that scream "this is a spam operation."
And critically, the consequences are different. If a transactional email goes to spam, it's an annoyance. If a cold email domain gets burned — blocklisted by Gmail, blacklisted by Spamhaus — that domain is done forever. You can't un-burn a domain. You throw it away, buy a new one, and start the months-long reputation climb over from zero. This is why cold email is the one place where owning your infrastructure and your strategy matters so much.
The Stack: Postal, Mautic, and a Warmer
There are three layers to self-hosted cold email, and they map cleanly onto three open-source tools. Let me introduce the field.
Postal — the self-hosted SMTP relay that IS the sending infrastructure
Postal is the workhorse. It's a self-hosted mail delivery platform that's been around for a decade and powers some genuinely large senders. Think of it as your own private SendGrid: it handles SMTP and API-based sending, DKIM signing, bounce handling, delivery webhooks, and — crucially for cold email — per-IP and per-domain reputation isolation.
What makes Postal special for cold email specifically is that it lets you run multiple sending IPs and domains from one install, each with its own reputation. That's the killer feature. In cold email you don't send from one domain — you send from a fleet of warmed-up domains and IPs, so that when one inevitably gets dinged, the others keep working. Postal is built for exactly that.
Best for: the core sending infrastructure — the relay your outreach tool talks to.
Mautic — the self-hosted marketing automation / outreach engine
Mautic is the open-source answer to HubSpot, and in this stack it plays the role Apollo plays in the SaaS world: it's the tool that manages your campaigns, contacts, and sequences. It handles list management, segmentation, drip campaigns, A/B testing, and tracking. You build your outreach sequence in Mautic, point it at Postal to actually send the mail, and Mautic tracks opens, clicks, and replies.
Where Apollo/Instantly give you a closed ecosystem, Mautic + Postal is a completely open one. You control the data, the sending, the tracking, and the pacing. It's more setup, but the payoff is total ownership.
Best for: the campaign/sequence layer — the brain that decides who gets what and when.
The warmer — the secret weapon that builds reputation before you send anything
Here's the piece that separates cold email pros from amateurs, and the piece most self-hosters completely miss: you cannot send cold email from a fresh domain. A domain that's three days old sending 200 emails a day to strangers is an instant spam signal. Gmail doesn't need to read your content — the age and velocity alone are enough to junk you.
The fix is a domain warmer: a tool that sends a gradually increasing volume of automated emails to real inboxes that are known to reply and mark as not-spam, thereby building a reputation signal. Commercial warmers like Warmbox or Instantly's own warmup do this for you. On the self-hosted side, there are open-source options that do the same thing — essentially a tool that exchanges email with a pool of other warmed inboxes, opens each other's mail, replies, and moves things to the inbox, teaching Gmail that "mail from this domain gets opened and answered."
The open-source landscape here is younger than Postal or Mautic, but the pattern is well-understood and you can wire together a warmer with Postal's API and a bit of scripting. The key insight: warmup is a months-long, gradual, ongoing process, not a one-time step. You warm a domain for 4-8 weeks before you send your first real cold email from it, and you keep the warmup volume going alongside your real sends.
Best for: the reputation-building phase — the thing you do before you send a single outreach email.
The Strategy Layer: How Cold Email Actually Works (And Why It's All About Reputation)
Before we get to the config, we need to talk about the strategy, because cold email self-hosting isn't a software problem — it's a reputation-management problem. The software just gives you the controls.
The fleet model: many domains, not one
This is the single biggest conceptual shift from transactional email. In transactional email you send from one clean, established domain. In cold email, you send from a fleet of dedicated domains — tryproduct.com, getproduct.io, producthq.co, etc. — each pointing at the same Postal install, each with its own warmup, each sending a small slice of your total volume.
Why? Because cold email domains burn. No matter how good your list and your copy, some percentage of recipients will mark you as spam, and enough of those marks kill a domain. If you're sending from one domain, one bad week ends your entire operation. If you're sending from ten domains at 20 emails/day each, one domain burning costs you 10% of your capacity — and you buy a replacement domain and keep going.
This is the thing Apollo and Instantly do for you (they run the fleets), and the thing you need to replicate when you self-host.
Volume discipline: the 30-email-per-day ceiling
The second rule is the one everyone wants to cheat, and it's the one that gets you burned: a cold email domain should not send more than ~30 emails per day, per inbox, especially in the first few months. Even after warmup, the safe ceiling is 20-50/day per domain. The people doing "1000 emails a day" from a single domain are either lying, burning through domains like kindling, or paying for dedicated IPs with months of history.
This is where self-hosting actually helps you, in a counterintuitive way. When you rent from Instantly, their pricing pushes you toward volume — more sends, more money for them. When you self-host, the economics are inverted: sending slower and safer is free, so you have no incentive to over-send and burn your domains. You can afford the discipline that a SaaS's pricing model quietly discourages.
List quality: the thing that matters more than your copy
I'll say it once and then move on, because it's the least technical but most important point: a bad list kills a good domain faster than anything else. Scraped emails, outdated addresses, bought lists — these generate bounces and spam complaints at a rate that burns domains in days. The single highest-leverage thing you can do for deliverability is verify your list before you send, and prune hard. Cold email self-hosting doesn't make bad lists work — it just makes it more obvious when they don't.
A Working docker-compose Stack
Let me make this concrete. Here's a docker-compose stack that runs the whole thing: Postal for sending, Mautic for campaigns, and a database/queue to hold it together. This is a starting point — you'll want to tune the resources and add a warmer, but this is a genuinely runnable foundation.
version: "3.8"
services:
# --- Postal: the sending relay ---
postal:
image: ghcr.io/postalserver/postal:latest
restart: unless-stopped
depends_on:
- postal-db
- redis
ports:
- "25:25" # inbound (bounce handling)
- "5000:5000" # SMTP for your apps / Mautic
environment:
POSTAL_DB_HOST: postal-db
POSTAL_DB_USERNAME: postal
POSTAL_DB_PASSWORD: ${POSTAL_DB_PASSWORD}
POSTAL_REDIS_HOST: redis
POSTAL_WEB_HOST: postal.yourdomain.com
volumes:
- postal-data:/config
postal-db:
image: mariadb:11
restart: unless-stopped
environment:
MYSQL_ROOT_PASSWORD: ${POSTAL_DB_ROOT_PASSWORD}
MYSQL_DATABASE: postal
MYSQL_USER: postal
MYSQL_PASSWORD: ${POSTAL_DB_PASSWORD}
volumes:
- postal-db-data:/var/lib/mysql
redis:
image: redis:7-alpine
restart: unless-stopped
volumes:
- redis-data:/data
# --- Mautic: the campaign / outreach engine ---
mautic:
image: mautic/mautic:latest
restart: unless-stopped
depends_on:
- mautic-db
ports:
- "8080:80"
environment:
MAUTIC_DB_HOST: mautic-db
MAUTIC_DB_USER: mautic
MAUTIC_DB_PASSWORD: ${MAUTIC_DB_PASSWORD}
MAUTIC_DB_NAME: mautic
volumes:
- mautic-data:/var/www/html
mautic-db:
image: mariadb:11
restart: unless-stopped
environment:
MYSQL_ROOT_PASSWORD: ${MAUTIC_DB_ROOT_PASSWORD}
MYSQL_DATABASE: mautic
MYSQL_USER: mautic
MYSQL_PASSWORD: ${MAUTIC_DB_PASSWORD}
volumes:
- mautic-db-data:/var/lib/mysql
volumes:
postal-data:
postal-db-data:
redis-data:
mautic-data:
mautic-db-data:
Step 1: Warm up your domains BEFORE you send anything
This is non-negotiable and it comes first, not last. Before a single outreach email leaves this stack:
- Buy 3-5 dedicated domains (not your main brand domain — these are sacrificial).
- Set up SPF, DKIM, and DMARC on each (the next section).
- Run a domain warmer against each for 4-8 weeks, ramping from ~5 emails/day to ~50/day.
- Only start real sends once the warmer has established "this domain gets opened and replied to."
I cannot overstate this. Skipping warmup is the #1 way people burn a brand-new domain in a week and then declare "self-hosted cold email doesn't work." It works. You just can't skip the part where you build reputation.
Step 2: Point Mautic at Postal
In Mautic's email settings, configure the SMTP transport to talk to Postal:
SMTP Host: postal (or your Postal server's address)
SMTP Port: 5000
SMTP Username: <your Postal credential>
SMTP Password: <your Postal credential>
From Address: you@tryproduct.com
Now every campaign Mautic sends routes through Postal, which does the actual delivery with proper DKIM signing and reputation isolation per-domain.
Step 3: Run one sending domain per campaign identity
In Postal, create a separate sender identity for each domain — tryproduct.com, getproduct.io, producthq.co — each with its own DKIM key and its own sending IP (if you have multiple IPs). Then in Mautic, segment your lists so each campaign uses a single identity. This is the fleet model in practice: one domain never carries the whole load, so one burn never kills the operation.
The DNS That Keeps You Out of the Spam Folder
Cold email needs the same SPF/DKIM/DMARC discipline as transactional email — but with a twist: you're doing it across a fleet of domains, each of which needs its own records, and each of which starts from zero reputation.
SPF — who can send as you
v=spf1 include:spf.tryproduct.com ~all
For cold email, ~all (softfail) is the safer choice than -all (hardfail) while you're warming up — you want the receiving side to softly flag anything off-list rather than reject outright, because during warmup your sending patterns are still stabilizing.
DKIM — prove it's really you
Postal generates a DKIM key per domain automatically. Publish the matching TXT record at the selector Postal gives you:
postal._domainkey.tryproduct.com TXT "v=DKIM1; k=rsa; p=<public-key>"
The alignment rule from my transactional email post applies here too: the d= domain in the DKIM signature must match your From: domain. Since you're sending from dedicated domains, that means one DKIM record per domain — no shortcuts.
DMARC — start lenient, tighten slowly
_dmarc.tryproduct.com TXT "v=DMARC1; p=none; rua=mailto:dmarc@tryproduct.com"
For cold email, p=none is not just a starting point — it's the correct long-term policy for most senders. You're sending unsolicited mail; the last thing you want is a strict p=reject policy adding to your rejection risk while you're already fighting the spam-classifier battle. Read the rua reports, fix alignment issues, but keep the policy lenient and let your content and reputation do the work of landing in the inbox.
The Honest Verdict: Should You Ditch Apollo / Instantly?
I've been making the case for self-hosting, so let me be straight about the tradeoffs.
Keep Apollo or Instantly if:
- You want to send volume today and don't have months to warm up domains. Their infrastructure is pre-warmed, and that's genuinely valuable when you need speed.
- You don't want to manage a fleet of domains, warmers, and bounce lists. The abstraction has real value if you're a founder who'd rather spend the time selling.
- You need their data — Apollo's contact database is a real moat that self-hosting can't replicate.
Self-host if:
- You've been burned by an account flag or rate limit. This is the #1 reason people go self-hosted: a compliance flag killed their pipeline, and they refuse to let a third party hold that lever again.
- You want to own your reputation. When you self-host, your deliverability is yours — good or bad. Nobody can throttle you, pause you, or "review" you out of existence.
- You send low-to-moderate volume over a long horizon. Self-hosting rewards patience and discipline. If you're building a slow, steady outbound motion (not a blast), the economics and control both favor owning the stack.
- You're already in the self-hosting world. If you run a homelab, self-host your email, and self-host your apps, cold email is the last outreach tool you're still renting. This closes the loop.
The honest middle path — and what I'd actually recommend to most people — is hybrid: keep Apollo/Instantly for their data (the contact database is the real moat), but route the actual sending through your own Postal infrastructure. Export the contacts from the SaaS, run your sequences in Mautic, and send through your own warmed domains. You get the data advantage without surrendering the reputation — and if the SaaS ever flags you, your sending keeps working because it was never theirs to begin with.
The Bottom Line
Self-hosted cold email in 2026 is a solved problem if you understand that the hard part was never the software — it's the reputation discipline. The stack (Postal + Mautic + a warmer) is mature and open-source. What separates the people who make it work from the people who burn out in a week is the strategy: warm your domains for months before sending, run a fleet instead of a single domain, cap your volume at 30-ish per day per domain, and treat list quality as sacred.
The moment that started this post — the founder staring at a compliance flag that killed their pipeline — is almost always a rented reputation problem. You built your entire outreach on a foundation someone else controls, and they pulled it. Self-hosting doesn't make cold email easy — it makes it yours. And when your sending infrastructure, your reputation, and your pipeline are all things you own, nobody can switch them off on you.
My advice: if you're serious about outbound and tired of renting the engine, start small. Spin up Postal, buy two sacrificial domains, warm them for six weeks, and send your first 20-emails-per-day campaign. Watch the DMARC reports, watch the open rates, and build the reputation slowly. The service you're renting is just a relay; the reputation that makes cold email land is something you can own.
Are you self-hosting your cold email? Have you ever had an account flag kill your pipeline, and did you go self-hosted afterward? I'd love to hear what worked — find me on GitHub or drop a note in the comments.
If you found this useful, you might also like my posts on self-hosted transactional email and self-hosted email for receiving.