DEV Community: Peter Park

How to Set Up SPF, DKIM, and DMARC for Cold Email in 2026: A Developer's Guide

Peter Park — Wed, 11 Nov 2026 03:52:33 +0000

If you're building a SaaS and plan to send emails to users — whether transactional, marketing, or outbound — email authentication is non-negotiable. Without proper SPF, DKIM, and DMARC records, your emails will land in spam or get rejected entirely.

Here's a practical, no-fluff guide to setting all three up correctly.

Why This Matters

Email providers like Gmail and Outlook use authentication records to decide whether your email is legitimate. If you skip this step:

Your emails go to spam
Your domain reputation drops
Automated systems may block your domain entirely

This applies whether you're sending 10 emails or 10,000.

1. SPF (Sender Policy Framework)

SPF tells receiving servers which IP addresses are allowed to send email on behalf of your domain.

Setup

Add a TXT record to your domain's DNS:

v=spf1 include:_spf.google.com include:sendgrid.net ~all

Replace the include: values with your actual email providers. Common ones:

Provider	SPF Include
Google Workspace	`_spf.google.com`
SendGrid	`sendgrid.net`
Mailgun	`mailgun.org`
Amazon SES	`amazonses.com`

Common Mistakes

Having multiple SPF records (only one is allowed per domain)
Using +all instead of ~all or -all
Exceeding the 10 DNS lookup limit

2. DKIM (DomainKeys Identified Mail)

DKIM adds a cryptographic signature to your outgoing emails. The receiving server checks this signature against a public key in your DNS.

Setup

Your email provider generates a DKIM key pair. You add the public key as a TXT record:

selector._domainkey.yourdomain.com TXT "v=DKIM1; k=rsa; p=MIIBIjANBg..."

Most providers (Google Workspace, SendGrid, etc.) walk you through this in their dashboard. The key thing is to make sure the selector matches what your provider expects.

Verification

Send a test email to a Gmail account and check the email headers. Look for:

dkim=pass header.d=yourdomain.com

3. DMARC (Domain-based Message Authentication, Reporting & Conformance)

DMARC ties SPF and DKIM together and tells receiving servers what to do when authentication fails.

Setup

Add a TXT record at _dmarc.yourdomain.com:

v=DMARC1; p=none; rua=mailto:dmarc@yourdomain.com; pct=100

Policy Levels

Policy	Meaning
`p=none`	Monitor only (start here)
`p=quarantine`	Send failures to spam
`p=reject`	Block failures entirely

Start with p=none to collect reports, then gradually move to quarantine and eventually reject once you're confident your legitimate emails are passing.

Verification Tools

Use these free tools to check your setup:

MXToolbox — check SPF, DKIM, DMARC records
Google Admin Toolbox — check MX records
mail-tester.com — send a test email and get a score

Real-World Impact

Proper email authentication directly affects whether your emails reach inboxes. If you're building outbound features or any kind of email-sending functionality, this is foundational infrastructure.

I built ColdMailAI to help founders write better cold emails, and the number one question that comes up is deliverability. The answer almost always starts with "Did you set up SPF, DKIM, and DMARC?"

Quick Checklist

[ ] One SPF record with all sending sources
[ ] DKIM enabled for each sending service
[ ] DMARC record starting with p=none
[ ] Test email headers showing pass for all three
[ ] Monitor DMARC reports for 2-4 weeks before tightening policy

If you're launching a product that sends email, get authentication right from day one. It's much harder to fix a damaged domain reputation than to set it up correctly from the start.

Questions? Drop them in the comments — happy to help debug specific setups.

The Cold Email Deliverability Checklist Every SaaS Founder Needs in 2026

Peter Park — Mon, 09 Nov 2026 01:07:49 +0000

You built a great product. You wrote compelling outreach emails. You hit send on 200 emails.

And 40 of them never reached anyone's inbox.

This is the reality for most SaaS founders doing cold outreach in 2026. Email providers like Google and Microsoft have tightened their filtering dramatically, and if your email infrastructure isn't set up correctly, your messages go straight to spam — no matter how good the copy is.

Here's a practical checklist to make sure your emails actually land where they're supposed to.

1. Set Up SPF (Sender Policy Framework)

SPF tells receiving mail servers which IP addresses are authorized to send email on behalf of your domain.

v=spf1 include:_spf.google.com include:sendgrid.net ~all

Key points:

Add a TXT record to your domain's DNS
Include every service that sends email for you (Google Workspace, SendGrid, Mailchimp, etc.)
Use ~all (soft fail) or -all (hard fail) at the end
Don't exceed 10 DNS lookups — SPF has a lookup limit

2. Configure DKIM (DomainKeys Identified Mail)

DKIM adds a cryptographic signature to your emails that proves they weren't tampered with in transit.

Setup steps:

Generate a DKIM key pair (most email providers do this for you)
Add the public key as a TXT record in your DNS
Your email provider signs outgoing emails with the private key
Receiving servers verify the signature against your DNS record

3. Publish a DMARC Policy

DMARC ties SPF and DKIM together and tells receiving servers what to do when authentication fails.

v=DMARC1; p=quarantine; rua=mailto:dmarc-reports@yourdomain.com; pct=100

Start with p=none to monitor without blocking, then move to p=quarantine or p=reject once you're confident everything is aligned.

4. Warm Up New Domains and Mailboxes

Sending 500 emails from a brand-new domain on day one is the fastest way to get blacklisted.

Warm-up schedule:

Week 1: 10-20 emails/day to engaged contacts
Week 2: 30-50 emails/day
Week 3: 50-100 emails/day
Week 4+: Gradually scale to your target volume

Use a separate domain for cold outreach (e.g., getcompany.com instead of company.com) to protect your primary domain's reputation.

5. Monitor Your Sender Reputation

Use these free tools regularly:

Google Postmaster Tools — shows your domain reputation with Gmail
MXToolbox — checks blacklists and DNS configuration
Mail Tester (mail-tester.com) — scores individual emails on spam likelihood

6. Keep Your Lists Clean

High bounce rates destroy sender reputation fast.

Remove hard bounces immediately
Re-verify email lists every 30 days
Use email verification services before sending to new lists
Aim for a bounce rate under 2%

7. Write Like a Human

Spam filters in 2026 are sophisticated enough to detect templated, mass-produced emails. A few patterns that trigger filters:

ALL CAPS in subject lines
Excessive exclamation marks!!!
Image-heavy emails with minimal text
URL shorteners (bit.ly, etc.)
Too many links in a single email

The best-performing cold emails tend to be short, plain-text, and conversational.

Putting It All Together

Before you send your next outreach campaign, run through this checklist:

[ ] SPF record configured and under 10 lookups
[ ] DKIM signing enabled and verified
[ ] DMARC policy published (at least p=none)
[ ] Sending domain warmed up (2+ weeks of gradual volume)
[ ] Google Postmaster Tools connected
[ ] Email list verified within last 30 days
[ ] Test email scores 9+ on Mail Tester

Getting emails delivered is a prerequisite, not a bonus. No amount of copywriting skill matters if your emails never reach the inbox.

If you're looking for a tool that helps with cold email creation while keeping deliverability in mind, check out ColdMailAI — it's designed to help SaaS founders write effective cold emails without the guesswork.

What deliverability issues have you run into? Drop them in the comments.

Email Authentication 101: SPF, DKIM, and DMARC Explained for SaaS Founders

Peter Park — Fri, 06 Nov 2026 02:27:11 +0000

If you're a SaaS founder sending transactional or outbound emails, there's a good chance your messages are landing in spam folders without you even knowing it. The culprit? Missing or misconfigured email authentication records.

In this guide, I'll break down the three pillars of email authentication: SPF, DKIM, and DMARC. No fluff, just what you need to know as a developer or technical founder to get your domain's email reputation right from day one.

Why Email Authentication Matters

Every time your server sends an email, the receiving mail server asks three questions:

Is this sender allowed to send on behalf of this domain? (SPF)
Was this message tampered with in transit? (DKIM)
What should I do if SPF or DKIM fails? (DMARC)

If you can't answer these questions with properly configured DNS records, inbox providers like Gmail, Outlook, and Yahoo are increasingly likely to reject or quarantine your messages.

According to Google's 2024 sender guidelines, bulk senders (5,000+ messages/day to Gmail) are now required to have SPF, DKIM, and DMARC configured. Yahoo has adopted similar requirements. This isn't optional anymore.

SPF: Sender Policy Framework

What It Does

SPF lets you declare which mail servers are authorized to send email on behalf of your domain. It's a DNS TXT record that receiving servers check against the IP address of the sending server.

How to Set It Up

Add a TXT record to your domain's DNS:

Type:  TXT
Host:  @
Value: v=spf1 include:_spf.google.com include:sendgrid.net ~all

Breaking this down:

v=spf1 declares this is an SPF record
include:_spf.google.com authorizes Google Workspace servers
include:sendgrid.net authorizes SendGrid's servers
~all soft-fails anything not listed (use -all for hard-fail once you're confident)

Key Constraints

You can only have one SPF record per domain. Multiple records will cause validation failures.
SPF has a 10 DNS lookup limit. Each include: counts as a lookup. Nested includes count too. Exceeding this limit silently breaks your SPF.

DKIM: DomainKeys Identified Mail

What It Does

DKIM adds a cryptographic signature to every outgoing email. The receiving server can verify this signature using a public key published in your DNS. This proves the message hasn't been altered in transit and that it originated from an authorized sender.

How to Set It Up

Your email service provider (ESP) will generate a DKIM key pair. You publish the public key as a DNS TXT record:

Type:  TXT
Host:  selector1._domainkey
Value: v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFA...

Breaking this down:

selector1._domainkey is the selector name (provided by your ESP) plus the fixed _domainkey suffix
v=DKIM1 is the DKIM version
k=rsa is the key type
p=... is your public key (the long base64 string your ESP gives you)

How to Verify

Send a test email to a Gmail address and open the original message headers. Look for:

Authentication-Results:
  dkim=pass header.d=yourdomain.com

You can also use command-line tools:

dig TXT selector1._domainkey.yourdomain.com

DMARC: Domain-based Message Authentication, Reporting & Conformance

What It Does

DMARC ties SPF and DKIM together with a policy. It tells receiving servers what to do when authentication fails, and where to send reports about it.

How to Set It Up

Add a TXT record:

Type:  TXT
Host:  _dmarc
Value: v=DMARC1; p=none; rua=mailto:dmarc-reports@yourdomain.com; pct=100

Breaking this down:

v=DMARC1 is the DMARC version
p=none is the policy (monitor only, no action on failures)
rua=mailto:... is where aggregate reports get sent
pct=100 applies the policy to 100% of messages

The Three Policy Levels

Policy	Meaning	When to Use
`p=none`	Monitor only, deliver everything	Starting out, collecting data
`p=quarantine`	Send failures to spam	After reviewing reports, confident in setup
`p=reject`	Block failures entirely	Full confidence, all legitimate sources covered

Recommended rollout: Start with p=none for 2-4 weeks while reviewing reports. Move to p=quarantine, then p=reject once you're sure all legitimate sending sources are authenticated.

Common Mistakes to Avoid

1. Multiple SPF Records

Adding a second SPF TXT record instead of merging include: statements into one record. DNS returns both, and validators may reject them.

Wrong:

v=spf1 include:_spf.google.com ~all
v=spf1 include:sendgrid.net ~all

Right:

v=spf1 include:_spf.google.com include:sendgrid.net ~all

2. Exceeding the SPF Lookup Limit

Every include:, a, mx, and redirect mechanism counts toward the 10-lookup cap. If you use multiple ESPs, CRM tools, and support desk platforms, you can easily exceed this. Use an SPF flattening tool or consolidate your sending infrastructure.

3. Skipping DMARC Entirely

SPF and DKIM alone aren't enough. Without DMARC, there's no policy for what happens on failure, and you won't receive reporting data. Even p=none is better than no DMARC record at all.

4. Setting p=reject Too Early

Jumping straight to a reject policy before auditing all sending sources (marketing tools, transactional email, CRM, support platforms) will cause legitimate emails to bounce.

5. Forgetting Subdomains

If you send from mail.yourdomain.com or news.yourdomain.com, those subdomains need their own SPF and DKIM records. DMARC on the root domain can cover subdomains with the sp= tag, but SPF and DKIM don't inherit automatically.

Quick Verification Checklist

Once you've set everything up, validate your configuration:

MXToolbox (mxtoolbox.com/spf.aspx) for SPF syntax and lookup count
Mail-tester (mail-tester.com) for a test email deliverability score
Gmail headers by sending to Gmail, clicking "Show original," and checking Authentication-Results
DMARC reports by waiting 24-48 hours after setup and reviewing aggregate XML reports at your rua address

Simplifying the Setup

If you're building a SaaS that sends cold outreach or transactional email, getting authentication right is table stakes. But it's also the kind of infrastructure work that eats into time you'd rather spend on product.

That's one of the reasons I built ColdMail. It handles email infrastructure concerns like domain warm-up guidance and deliverability so founders can focus on writing emails that actually convert, rather than debugging DNS records.

TL;DR

Protocol	Purpose	Record Type	Key Thing to Remember
SPF	Authorize sending servers	TXT on `@`	One record only, 10 lookup limit
DKIM	Verify message integrity	TXT on `selector._domainkey`	Get keys from your ESP
DMARC	Set failure policy + reporting	TXT on `_dmarc`	Start with `p=none`, graduate up

Set up all three. Monitor your DMARC reports. Graduate your policy. Your deliverability will thank you.

Have questions about email authentication or cold email infrastructure? Drop a comment below.

How to Build a Prospect Research Pipeline for Cold Email

Peter Park — Thu, 05 Nov 2026 01:04:16 +0000

Cold email gets a bad reputation, and honestly, most of it is deserved. The biggest reason? People skip the research step entirely.

Sending a well-researched, relevant email to the right person beats blasting hundreds of generic templates every time. In this post, I'll walk through a practical prospect research pipeline that any developer can build or adapt.

The Problem with "Spray and Pray"

Most cold email workflows look like this:

Buy a list of emails
Write one template
Send to everyone
Wonder why the reply rate is near zero

The missing step is research. Understanding who you're emailing and why they should care is what separates effective outreach from spam.

A Simple Research Pipeline

Here's a framework you can implement:

Step 1: Define Your Ideal Customer Profile (ICP)

Before writing a single email, document:

Industry: Which sectors benefit most from your product?
Company size: Startup? Mid-market? Enterprise?
Role: Who is the actual decision-maker?
Pain point: What specific problem does your product solve for them?

Step 2: Find and Validate Contacts

Use publicly available data sources:

Company websites (team pages, about pages)
LinkedIn profiles (public information)
Business directories and databases

Always validate email addresses before sending. A high bounce rate damages your sender reputation and can get your domain blacklisted.

Step 3: Research Each Prospect

For each contact, spend 2-3 minutes gathering:

Their recent posts or articles
Company news or announcements
Shared connections or interests
Specific challenges their company might face

This research becomes your personalization layer.

Step 4: Write Contextual Emails

Structure your email around what you learned:

Subject: [Something specific to their situation]

Hi [Name],

[Reference something specific - a post they wrote, a company milestone, etc.]

[Connect that to the problem you solve - one sentence]

[Your value proposition - keep it brief]

[Clear, low-friction CTA]

Step 5: Track and Iterate

Monitor these metrics:

Bounce rate: Should be under 2%. Higher means your data is bad.
Open rate: Subject line effectiveness indicator.
Reply rate: Content relevance indicator.
Positive reply rate: The metric that actually matters.

Technical Implementation Notes

If you're building this as a developer:

Email validation: Use DNS MX record checks + SMTP verification. Libraries like email-validator handle the basics.
Rate limiting: Respect sending limits. Major providers flag accounts that spike volume suddenly.
Authentication: Set up SPF, DKIM, and DMARC records. These are non-negotiable for deliverability.
Warm-up: New domains need gradual volume increases over 2-4 weeks.

Why We Built ColdMailAI

This research pipeline is exactly the thinking behind ColdMailAI. We wanted to make prospect research and personalized email generation accessible without requiring a massive sales team or expensive tools.

The tool helps you:

Generate research-backed email drafts
Maintain personalization at scale
Follow deliverability best practices automatically

If you're interested, check it out at getcoldmail.com.

Key Takeaways

Research before you write. Always.
Quality over quantity. 50 well-researched emails outperform 500 generic ones.
Validate everything. Bad data costs you more than no data.
Track metrics and iterate. What works changes over time.

Cold email done right is just helpful communication between people who might benefit from working together. The research step is what makes it helpful instead of annoying.

What's your approach to cold email research? Drop your tips in the comments.

Email Deliverability Checklist for Developers: SPF, DKIM, DMARC, and Beyond

Peter Park — Wed, 04 Nov 2026 01:58:13 +0000

If you're building any tool that sends email — whether it's transactional notifications, marketing campaigns, or cold outreach — deliverability is the invisible layer that determines whether your emails actually reach inboxes.

Here's a practical checklist for developers who want to get email delivery right from the start.

1. Set Up SPF (Sender Policy Framework)

SPF tells receiving mail servers which IP addresses are authorized to send email on behalf of your domain.

v=spf1 include:_spf.google.com include:sendgrid.net ~all

Key points:

Add a TXT record to your domain's DNS
Include all services that send email for you (ESP, transactional provider, etc.)
Use ~all (soft fail) or -all (hard fail) at the end
Keep your SPF record under 10 DNS lookups — exceeding this silently breaks validation

2. Configure DKIM (DomainKeys Identified Mail)

DKIM adds a cryptographic signature to your email headers, letting receivers verify the message wasn't altered in transit.

selector._domainkey.yourdomain.com  TXT  "v=DKIM1; k=rsa; p=MIGfMA0GCSqGSIb3..."

Key points:

Generate a public/private key pair (most ESPs provide this)
Publish the public key as a DNS TXT record
The private key signs outgoing messages automatically
Rotate keys periodically (every 6-12 months is reasonable)

3. Publish a DMARC Policy

DMARC ties SPF and DKIM together and tells receivers what to do when authentication fails.

_dmarc.yourdomain.com  TXT  "v=DMARC1; p=quarantine; rua=mailto:dmarc-reports@yourdomain.com; pct=100"

Policy options:

p=none — Monitor only (start here)
p=quarantine — Send failures to spam
p=reject — Block failures entirely

Start with p=none to collect reports, then gradually tighten.

4. Warm Up New Domains and IPs

Sending a large volume from a brand new domain or IP is the fastest way to get flagged as spam.

Warming strategy:

Week 1: 20-50 emails/day to engaged recipients
Week 2: Double the volume
Week 3-4: Continue scaling gradually
Monitor bounce rates and spam complaints at each step

5. Monitor Your Sender Reputation

Use free tools to check your domain and IP reputation:

Google Postmaster Tools — Shows domain reputation, spam rate, authentication results
MXToolbox — DNS record validation and blacklist monitoring
Mail-tester.com — Send a test email and get a deliverability score

6. Handle Bounces and Complaints

Hard bounces (invalid addresses) and spam complaints directly damage your sender reputation.

// Example: webhook handler for bounce processing
app.post('/webhook/bounce', (req, res) => {
  const { email, bounceType } = req.body;

  if (bounceType === 'hard') {
    // Immediately remove from all lists
    removeFromMailingList(email);
  } else if (bounceType === 'soft') {
    // Retry up to 3 times, then remove
    incrementRetryCount(email);
  }

  res.sendStatus(200);
});

7. Content Best Practices

Even with perfect authentication, poor content triggers spam filters:

Avoid ALL CAPS subjects and excessive punctuation
Include a plain-text version alongside HTML
Keep your text-to-image ratio reasonable (not image-only emails)
Always include an unsubscribe link
Use a consistent "From" name and address

Why This Matters for SaaS Builders

When we built ColdMailAI, one of the core design decisions was to generate emails that follow these deliverability principles by default — proper structure, natural language patterns, and no spam trigger words. The tool doesn't send emails itself; it generates content designed to work well with whatever sending infrastructure you already have.

Deliverability isn't a one-time setup. It's an ongoing practice. Get the foundation right, and your emails will actually reach the people you're writing to.

Resources:

The Anatomy of a High-Converting Cold Email Subject Line: A Technical Breakdown

Peter Park — Tue, 03 Nov 2026 01:16:17 +0000

If you've ever sent cold emails, you know the feeling: you spend an hour crafting the perfect pitch, hit send, and... crickets. The problem usually isn't your email body. It's your subject line.

Your subject line is the gatekeeper. If it doesn't earn the open, nothing else matters. Let's break down the technical anatomy of what makes cold email subject lines actually work, with frameworks you can apply today.

The 3-Second Window

Email clients display subject lines differently. Gmail on desktop shows roughly 70 characters. On mobile, you get about 35-40. Outlook varies depending on the preview pane.

This means your most important words need to land in the first 35 characters. Anything after that is a bonus, not a requirement.

// Character limits by client (approximate visible characters)
Gmail Desktop:   ~70 chars
Gmail Mobile:    ~35-40 chars
Outlook Desktop: ~55-60 chars
Apple Mail:      ~50-60 chars
Yahoo:           ~45 chars

Takeaway: Front-load your value proposition. If your subject line reads well when cut at 40 characters, it works everywhere.

Framework 1: The Relevance Hook

The most reliable cold email subject lines pass what I call the "why me, why now" test. The recipient should immediately understand why they're getting this email.

Pattern: [Specific Reference] + [Value Hint]

Examples:

"Quick question about your checkout flow"
"Idea for [Company]'s onboarding sequence"
"Noticed your team is hiring SDRs"

What makes these work:

They reference something specific about the recipient
They imply you did your research
They don't try to sell anything in the subject line itself

Framework 2: The Curiosity Gap

This technique creates a small gap between what the recipient knows and what they want to know. It's not clickbait. It's selective omission.

Pattern: [Partial Information] + [Implied Completion Inside]

Examples:

"Two things I noticed on your site"
"A thought about your recent launch"
"Question about your approach to [topic]"

The key is specificity. "I have an idea" is spam. "I have an idea about your pricing page" is curiosity.

Framework 3: The Direct Ask

Sometimes the best approach is being straightforward. No tricks, no hooks. Just clarity.

Pattern: [Clear Intent] + [Time Expectation]

Examples:

"15 min chat about cold outreach?"
"Worth a conversation?"
"Quick feedback request"

Direct subject lines work best when your sender reputation is established or when targeting senior decision-makers who respect their own time.

The Technical Side: What to Avoid

Beyond frameworks, there are technical factors that affect deliverability before a human ever sees your subject line.

Spam Trigger Patterns

Certain patterns consistently trigger spam filters:

ALL CAPS words (one is fine, a whole subject in caps is not)
Excessive punctuation (!!!, ???, or $$$)
Known spam phrases: "act now," "limited time," "free money," "guaranteed"
Emoji overuse in B2B contexts
RE: or FW: prefixes on first-touch emails (dishonest and detectable)

Character Encoding Issues

If you're building email tools or templates, watch out for:

// Common encoding pitfalls
"Smart quotes" > Use straight quotes in subject lines
Em dashes > Some clients render these as ???
Non-ASCII characters > Test across clients before sending

Preview Text Interaction

Modern email clients show preview text alongside the subject line. This is technically the first line of your email body (or a hidden preheader). Your subject line and preview text should work as a pair, not repeat each other.

Subject: "Quick question about your onboarding"
Preview: "I signed up for a trial last week and..."

// vs.

Subject: "Quick question about your onboarding"  
Preview: "Quick question about your onboarding flow..."  // Redundant

A Simple Testing Approach

Before sending any cold email campaign, run your subject lines through this checklist:

The 40-character test - Does it read well when truncated?
The "why me" test - Would the recipient know why they got this?
The inbox scan test - Read it among 20 other subject lines. Does it stand out without being loud?
The spam word check - Run it through a basic spam word list
The honesty test - Does the email body deliver what the subject promises?

Building These Into Your Workflow

When I built ColdMail, one of the core design decisions was keeping email generation client-side in the browser. No emails stored on a server, no subject line data collected. This matters because subject lines are where most personalization lives, and personalization data should stay with the sender.

Whether you use a tool or write manually, the principles are the same: specificity beats cleverness, clarity beats creativity, and relevance beats everything.

The Bottom Line

Cold email subject lines aren't about being clever. They're about being relevant and clear within a tight technical constraint: a few dozen characters, filtered by algorithms, scanned by humans in under three seconds.

Master the frameworks, respect the technical limits, and always test before you scale.

What subject line patterns have worked best in your outreach? Drop them in the comments.

How I Built a Cold Email Generator Without Storing a Single Email

Peter Park — Mon, 02 Nov 2026 01:12:10 +0000

When I started building ColdMailAI, one of the first architectural decisions I had to make was: should I store user emails?

The answer was no. Here's why, and how the system works without it.

The Privacy-First Approach

Most email tools store your generated emails, contacts, and campaign data on their servers. That's fine for full-blown CRM platforms, but for a tool that generates cold email copy, it's unnecessary overhead and a liability.

ColdMailAI generates personalized cold emails using AI, but it doesn't need to remember what it generated. The user provides context (who they're reaching out to, what they're selling, the tone they want), the AI generates the email, and the user copies it. Done.

The Tech Stack

Here's what powers the app:

Next.js on Vercel for the frontend and API routes
OpenAI API for email generation
PayPal for subscription payments
Vercel Blob for minimal asset storage
No database for user-generated content

The lack of a traditional database for email content keeps things simple. No migrations, no backup strategy for PII, no GDPR data deletion requests to handle.

How Generation Works

The flow is straightforward:

User fills in the form (recipient info, product/service description, desired tone)
Frontend sends a POST request to an API route
API route calls OpenAI with a carefully crafted system prompt
Response streams back to the user
User copies the result - nothing is stored server-side

Lessons From Building It

1. Start with the simplest architecture that works.
I could have built a full platform with saved drafts, campaign management, and A/B testing. Instead, I shipped a focused tool that does one thing well: generate cold email copy.

2. Streaming responses matter for UX.
Nobody wants to stare at a loading spinner for 5 seconds. Streaming the AI response token-by-token makes the app feel fast and responsive.

3. Cost management is everything with AI products.
Using gpt-4o-mini instead of gpt-4o for email generation cut costs significantly while maintaining quality. For structured, shorter outputs like emails, the smaller model performs well.

4. The landing page matters more than the product (initially).
I spent way too long perfecting the generation logic and not enough time on the landing page copy. The conversion rate improved once I rewrote the hero section to focus on the user's pain point rather than the technology.

What's Next

I'm working on adding:

Multiple email variations in a single generation
Industry-specific templates
Follow-up sequence suggestions

If you're building an AI-powered tool and debating architecture, consider whether you actually need to store the output. Sometimes the simplest approach is the right one.

Check it out at getcoldmail.com - feedback welcome.

How I Handle 10,000 Email Generations per Day on a Shoestring Budget

Peter Park — Fri, 30 Oct 2026 01:04:44 +0000

When I launched ColdMailAI, I had one goal: keep the price at $9/month and still handle serious volume. Six months later, we're generating over 10,000 personalized cold emails per day. Here's the exact technical playbook that makes it possible without burning through cash.

The Problem: AI APIs Are Expensive at Scale

Let's do the math. If you're calling GPT-4 for every email generation:

Average prompt: ~800 tokens
Average completion: ~200 tokens
Cost per email: ~$0.01-0.03
10,000 emails/day = $100-300/day
Monthly: $3,000-9,000

At $9/month per user, you'd need 333-1,000 paying users just to cover API costs. That's before servers, domains, or your coffee budget.

Solution 1: Intelligent Model Routing

Not every email needs GPT-4-level intelligence. I built a routing layer that classifies generation requests:

function routeModel(request) {
  const complexity = analyzeComplexity(request);

  if (complexity.requiresResearch) {
    return 'gpt-4o';        // Deep personalization
  }
  if (complexity.hasTemplate) {
    return 'gpt-4o-mini';   // Template variation
  }
  return 'gpt-4o-mini';     // Simple generation
}

Result: 70% of requests go to cheaper models. Average cost dropped from $0.02 to $0.004 per email.

Solution 2: Aggressive Caching with Semantic Matching

Here's what most people miss: cold emails to similar prospects in the same industry follow similar patterns. I built a semantic cache:

async function generateWithCache(prospect) {
  const embedding = await getEmbedding(prospect.context);
  const cached = await vectorDB.search(embedding, { threshold: 0.92 });

  if (cached) {
    // Modify cached result slightly instead of full generation
    return await cheapVariation(cached.result, prospect);
  }

  const result = await fullGeneration(prospect);
  await vectorDB.store(embedding, result);
  return result;
}

Cache hit rate after 2 weeks of operation: ~40%. Those hits cost almost nothing.

Solution 3: Batch Processing with Queue Management

Instead of processing emails one-by-one with individual API calls, I batch similar requests:

User Request -> Redis Queue -> Batch Aggregator (every 30s)
                                    |
                            Group by industry/template
                                    |
                            Single API call per batch
                                    |
                            Distribute results back

Batching similar prompts reduced my API calls by 60% while maintaining personalization quality.

Solution 4: The Infrastructure Stack

Here's what runs ColdMailAI in production:

Component	Choice	Monthly Cost
Hosting	Vercel (serverless)	$20
Database	Supabase (free tier + $25 pro)	$25
Vector DB	Pinecone (starter)	$0
Queue	Upstash Redis	$10
AI APIs	OpenAI (with routing)	~$400
Email verification	ZeroBounce	$50
Domain/DNS	Cloudflare	$0
Monitoring	Sentry (free tier)	$0
Total		~$505/month

At $9/user with 200+ users, the margins actually work. The key is that costs scale sub-linearly because of caching and batching.

Solution 5: Progressive Generation

This was the biggest unlock. Instead of generating a perfect email in one shot, I break it into stages:

Stage 1 (instant): Generate email structure + hook using cached patterns
Stage 2 (background): Enrich with prospect-specific research
Stage 3 (on-demand): Polish and personalize when user reviews

Users see Stage 1 results in under 2 seconds. Stages 2-3 run asynchronously, which spreads the computational load and lets me use cheaper batch processing.

The Numbers After 6 Months

Cost per email generated: $0.003 (down from $0.02)
Average response time: 1.8 seconds for first draft
Cache hit rate: 42%
API cost as % of revenue: 28% (healthy for SaaS)
Uptime: 99.7%

What I'd Do Differently

Start with caching from day one. I added it in month 3 and kicked myself for not doing it earlier.
Don't over-optimize early. I spent a week building a custom model fine-tune that saved $30/month. Not worth it at that scale.
Monitor cost per request religiously. I have a Grafana dashboard that alerts me if cost-per-email exceeds $0.005.

The Takeaway

You don't need massive infrastructure funding to run an AI product at scale. Smart routing, aggressive caching, and batch processing got me from "this will bankrupt me" to "this is a real business" in about 3 months.

If you're building something similar, I'm happy to answer questions in the comments. And if you want to see the end result, check out ColdMailAI - it's $9/month because I actually figured out how to make that price work.

Building in public. Follow me for more technical deep dives on running an AI SaaS on a shoestring budget.

Building a Cold Email SaaS: Lessons from 6 Months of Solo Development

Peter Park — Thu, 29 Oct 2026 01:06:50 +0000

Six months ago, I was manually writing cold emails for my consulting business. Every single one. Copy-pasting templates, swapping names, tweaking the opening line, hoping it didn't sound robotic.

It was painful. So I built something to fix it.

Today, ColdMailAI is live, serving real users, and generating revenue. Here's everything I learned building it solo.

The Problem That Started It All

I was sending 50+ cold emails a week. My process looked like this:

Find a prospect on LinkedIn
Open a Google Doc template
Manually personalize the first 2 lines
Pray it didn't land in spam
Forget to follow up

The personalization was the bottleneck. Generic templates got ignored. Truly personalized emails got replies — but took 10-15 minutes each.

I needed a tool that could write emails that sounded like me but didn't require me to write each one from scratch.

Tech Stack Decisions

Here's what I landed on and why:

Next.js + Vercel
I wanted to ship fast. Next.js gave me SSR for the landing page (SEO matters for SaaS), API routes for the backend, and Vercel made deployment a non-issue. Zero DevOps overhead.

// My project structure is dead simple
├── app/
│   ├── page.tsx          // Landing page
│   ├── dashboard/        // User dashboard
│   ├── api/
│   │   ├── generate/     // Email generation endpoint
│   │   ├── webhook/      // PayPal webhooks
│   │   └── auth/         // Auth routes
├── lib/
│   ├── openai.ts         // AI service layer
│   ├── prompts.ts        // Prompt templates
│   └── paypal.ts         // Payment logic

OpenAI API (GPT-4o-mini)
I started with GPT-4 but the cost per email was too high for a $9/month product. GPT-4o-mini gave me 95% of the quality at roughly 1/10th the cost. The key insight: the prompt engineering matters more than the model size.

PayPal for Payments
Stripe would have been my first choice, but I needed something that worked globally without a US business entity. PayPal subscriptions were straightforward to set up.

The Hardest Technical Challenge: Prompt Engineering

This is where I spent 60% of my development time. Getting an LLM to write cold emails that don't sound like they were written by AI is hard.

My first attempt:

// v1: Naive approach — terrible results
const prompt = \`Write a cold email to \${prospect.name} 
at \${prospect.company} about our product.\`;

The output was generic, salesy, and screamed "AI wrote this." Nobody would reply to it.

After weeks of iteration, I landed on a multi-step approach:

// v2: Context-enriched generation
async function generateEmail(prospect, userContext) {
  // Step 1: Analyze the prospect's context
  const analysis = await analyzeProspect({
    name: prospect.name,
    company: prospect.company,
    role: prospect.role,
    recentActivity: prospect.linkedinSummary,
  });

  // Step 2: Generate with structured context
  const email = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [
      {
        role: 'system',
        content: buildSystemPrompt(userContext.writingStyle),
      },
      {
        role: 'user',
        content: buildUserPrompt(analysis, userContext.product),
      },
    ],
    temperature: 0.7,
    max_tokens: 500,
  });

  return parseEmailResponse(email);
}

Key lessons on prompt engineering for cold emails:

Feeding context beats clever instructions. Instead of telling the AI "write a personalized email," I feed it the prospect's LinkedIn summary, recent posts, and company news. The AI naturally weaves in relevant details.
Temperature 0.7 is the sweet spot. Lower = too formulaic. Higher = too random and sometimes nonsensical.
Few-shot examples from the user's own sent emails dramatically improve tone matching. I let users paste 3-5 of their best emails during onboarding, and use them as style references.

Handling Rate Limits

When a user generates 50 emails in a batch, you hit OpenAI rate limits fast. My solution:

// Simple but effective rate limiter
class EmailQueue {
  constructor(maxConcurrent = 3, delayMs = 200) {
    this.queue = [];
    this.active = 0;
    this.maxConcurrent = maxConcurrent;
    this.delayMs = delayMs;
  }

  async add(task) {
    return new Promise((resolve, reject) => {
      this.queue.push({ task, resolve, reject });
      this.process();
    });
  }

  async process() {
    if (this.active >= this.maxConcurrent || !this.queue.length) return;

    this.active++;
    const { task, resolve, reject } = this.queue.shift();

    try {
      const result = await task();
      resolve(result);
    } catch (err) {
      if (err.status === 429) {
        // Rate limited — back off and retry
        await new Promise(r => setTimeout(r, 2000));
        this.queue.unshift({ task, resolve, reject });
      } else {
        reject(err);
      }
    } finally {
      this.active--;
      setTimeout(() => this.process(), this.delayMs);
    }
  }
}

Nothing fancy. A queue with exponential backoff on 429s. It handles 95% of cases.

Building the Email Preview System

Users want to see and edit emails before sending. This sounds simple, but the UX details matter:

Real-time preview as the AI generates (streaming SSE responses)
Inline editing without losing the AI-generated structure
Tone adjustment slider (formal ↔ casual) that regenerates specific sections
Subject line variants — I generate 3 options and let the user pick

The streaming preview was the most satisfying feature to build. Users see the email "writing itself" in real-time, which also builds trust in the AI output.

What I Learned About Solo SaaS

1. Ship ugly, iterate fast.
My v1 looked terrible. I used basic Tailwind components, no fancy animations. But it worked. The first paying user didn't care about the UI — they cared that the emails got replies.

2. Talk to users constantly.
I added Tawk.to live chat on day one. Every conversation taught me something. Users asked for features I never would have thought of (like the tone slider).

3. Pricing is emotional, not logical.
I agonized over pricing. $9/month for 100 AI-generated emails felt too cheap. But as a solo builder, I'd rather have 100 users at $9 than 10 at $49. Volume validates faster.

4. The marketing is harder than the code.
Building the product took 2 months. Getting the first 10 users took 3 months. SEO, content marketing, Reddit, Product Hunt — it's a different skill set entirely.

Current State

Live at getcoldmail.com
Pricing: $9/month (100 emails), $29/month (500 emails)
Stack: Next.js, Vercel, OpenAI, PayPal
Users: Growing steadily through organic search and word of mouth

What's Next

I'm working on:

Team collaboration — shared templates, team analytics
CRM integration — HubSpot and Pipedrive first
Email tracking — open rates, reply detection
A/B testing — automatically test different email variants

Final Thoughts

Building a SaaS solo is equal parts exhilarating and exhausting. There are days when everything breaks and you question why you didn't just keep using Gmail templates.

But then a user messages you: "I got 3 meetings from the emails your tool generated this week."

That makes it worth it.

If you're struggling with cold outreach, check it out at getcoldmail.com. And if you're building something solo — keep shipping. The hardest part isn't the code, it's staying consistent.

What's your biggest challenge with cold email? Drop a comment below.

I Replaced My Cold Email Templates with AI - Here's My 30-Day Data

Peter Park — Wed, 28 Oct 2026 02:05:25 +0000

As a developer who built a SaaS product, I needed to do my own outbound sales. Here's what happened when I stopped using templates and switched to AI-assisted cold emails.

The Problem

I was sending 15-20 cold emails per day using templates. My reply rate was stuck at 2-3%. That meant maybe 1 reply every 2 days. Not enough to sustain a bootstrapped SaaS.

The Experiment

I built ColdMailAI - an AI tool that generates personalized cold emails based on prospect data. Instead of filling in template blanks, the AI writes a fresh email for each prospect.

I tracked everything for 30 days:

Metric	Templates	AI-Assisted
Emails/day	15-20	25-30
Time per email	8-12 min	1-2 min
Open rate	45%	58%
Reply rate	2.3%	8.4%
Meetings booked	4	12

What Made the Difference

Speed: AI drafts took 10 seconds instead of 10 minutes. I spent that saved time on better prospect research.

Personalization at scale: Each email referenced something specific about the prospect's company. Not a generic "I love what you're doing at [Company]" but actual details about their recent product launch or blog post.

Consistency: Templates get stale. You start cutting corners by email #10. AI generates fresh copy every time.

The Tech Stack

For anyone curious, ColdMailAI is built with:

Next.js for the frontend and API routes
OpenAI API for email generation
Vercel for hosting
PayPal for payments ($9/month subscription)

Lessons for Developer-Founders

Your first marketing channel should be outbound. SEO takes months. Ads cost money. Cold email costs time, which you have more of than cash.
Build the tool you need. I built ColdMailAI because I needed it. The best SaaS products solve the founder's own problem.
Track everything. Without data, you're guessing. With data, you're iterating.
AI is a multiplier, not a replacement. The AI writes the draft, but I still review and personalize every email before sending.

Try It

If you're doing outbound and want to test AI-assisted cold emails, check out ColdMailAI. It's $9/month, and the free tier lets you generate 5 emails per day.

What's your cold email workflow? Drop a comment - I'd love to compare notes.

Why I Chose $9/month Pricing for My AI SaaS (And Would Do It Again)

Peter Park — Sat, 24 Oct 2026 07:28:40 +0000

Every SaaS founder faces the pricing question early. $29/month? $49? Maybe a free tier with upsells?

I went with $9/month for ColdMailAI, my AI-powered cold email writer. Here's why, and what I've learned since launch.

The Problem I Was Solving

Writing cold emails is painful. You stare at a blank screen, try to sound personal without being creepy, and end up sending the same template to 200 people. The result? 2% reply rates and a lot of wasted time.

I built ColdMailAI to fix this. You describe your offer, paste a prospect's details, and the AI writes a personalized cold email in seconds. Not a template with merge tags. An actually unique email.

Why Not $29/month?

Most AI SaaS tools price at $29-$49/month. The logic makes sense on paper: fewer customers needed to hit revenue targets, "premium" positioning, higher LTV.

But here's what I noticed:

1. The $29 price creates decision friction.
At $29/month, people want demos. They want to "evaluate" the tool. They compare you against 5 alternatives. The sales cycle goes from "impulse buy" to "committee decision."

2. My target users are individual SDRs and founders.
These aren't enterprise teams with software budgets. They're solo founders sending cold emails at 11pm, or junior SDRs trying to hit quota. $9/month is lunch money. $29/month requires justification.

3. The product is simple on purpose.
ColdMailAI does one thing: writes cold emails. It doesn't manage campaigns, track opens, or integrate with your CRM. One feature = simple pricing.

The $9 Math

Here's my actual cost structure:

Hosting: Vercel free tier (Next.js)
AI: OpenAI API, roughly $0.002 per email generated
Domain + misc: ~$15/year

At $9/month per user:

100 users = $900/month
500 users = $4,500/month
1,000 users = $9,000/month

Even at 100 users, it's profitable. The margins are excellent because the infrastructure cost is near zero.

What I'd Tell Other Founders

Price for adoption speed, not revenue optimization.

When you're at zero users, the most important thing isn't maximizing revenue per customer. It's getting people to actually use the product. Every user who signs up is:

A potential word-of-mouth referral
A source of feedback
Social proof
A future upsell candidate

A $9/month product with 500 users beats a $29/month product with 50 users. Not just in revenue, but in momentum.

The Technical Stack

For anyone curious about the build:

Framework: Next.js 14
AI: OpenAI GPT-4 API
Auth: None (simple, no signup needed)
Payments: PayPal subscriptions
Hosting: Vercel (free tier)
Total build time: 1 weekend

The entire app is one page. You fill in your offer details, add prospect info, and click generate. No onboarding flow, no dashboard, no settings page.

Would I Do It Again?

Yes. The $9 price point removed so much friction that users try the product without overthinking it. And once they see the output quality, they stick around.

If you're building a simple tool that solves one specific problem, consider pricing it low enough that the decision is instant. You can always add premium tiers later.

Try ColdMailAI free: getcoldmail.com

It writes personalized cold emails in seconds. No signup required to try it.

How I Built an AI Cold Email Generator with Next.js and OpenAI

Peter Park — Fri, 23 Oct 2026 01:09:27 +0000

Last weekend, I sat down with a simple idea: build an AI tool that writes personalized cold emails. By Sunday night, I had a working SaaS product deployed on Vercel. Here's the entire technical journey, what worked, what didn't, and what I'd do differently.

The Problem

I've been doing B2B outreach for a while now. The biggest pain point? Writing cold emails that don't sound like templates. You know the ones:

"Hi {firstName}, I noticed your company {companyName} is doing great things in {industry}..."

These emails get ignored. Everyone knows they're automated. But writing truly personalized emails takes forever. I was spending 3-4 hours a day just crafting outreach messages.

The Tech Stack

Here's what I chose and why:

Next.js 14 (App Router) - Server components for the AI processing, client components for the form UI
OpenAI API (GPT-4o-mini) - Good enough quality at a fraction of GPT-4 cost
Tailwind CSS - Fast styling without leaving the editor
Vercel - Deploy in seconds, zero DevOps
Stripe - Payment processing with webhook handling

Total monthly infrastructure cost: under $5 (OpenAI usage is the main variable).

The Architecture

The app is surprisingly simple. Here's the core flow:

User Input -> API Route -> OpenAI Completion -> Formatted Email -> Display

The API route handles the heavy lifting:

// app/api/generate/route.ts
export async function POST(req) {
  const { prospect, context, tone } = await req.json();

  const completion = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      {
        role: "system",
        content: "You are a cold email expert. Write a personalized cold email that is concise, relevant to the prospect, and has a clear CTA."
      },
      {
        role: "user", 
        content: "Write a cold email for: " + prospect + " Context: " + context + " Tone: " + tone
      }
    ],
    temperature: 0.7,
    max_tokens: 300
  });

  return Response.json({ 
    email: completion.choices[0].message.content 
  });
}

Key Technical Decisions

Why GPT-4o-mini over GPT-4?

Cost. GPT-4o-mini is roughly 15x cheaper than GPT-4 for input tokens. For cold emails (short input, short output), the quality difference is negligible. My users are generating hundreds of emails. At GPT-4 prices, the margins would be razor thin.

Why Server Components?

The generation form is a client component (needs interactivity), but everything else is server-rendered. This means:

Fast initial page load
SEO-friendly landing page
Less JavaScript shipped to the browser

Prompt Engineering Was 80% of the Work

This surprised me. The actual Next.js code took maybe 4 hours. Getting the prompts right took the entire rest of the weekend.

The key insight: constraints produce better emails. When I told the AI "write a cold email," I got generic garbage. When I said "write a 3-sentence email that references their latest blog post and asks one specific question," the output was dramatically better.

I ended up with a prompt template that includes:

Word count limits (under 75 words)
Structure requirements (hook, value prop, CTA)
Anti-patterns to avoid ("I hope this finds you well")
Tone matching based on industry

Stripe Integration in 30 Minutes

Stripe's Next.js integration is ridiculously smooth now. The checkout flow:

User clicks "Subscribe"
Redirect to Stripe Checkout
Webhook fires on successful payment
Update user status in the database

What I Shipped

The MVP has three features:

Single email generation - Paste prospect info, get an email
Batch generation - Upload a CSV, get emails for all prospects
Tone control - Professional, casual, or direct

That's it. No email sending. No CRM integration. No analytics dashboard. Just the core value: generate good cold emails fast.

I priced it at $9/month with unlimited generations. Low enough that any SDR or founder would try it without needing approval from their boss.

Lessons Learned

1. Deploy on day one. I pushed to Vercel after the first 2 hours, before the AI even worked. Having a live URL kept me motivated and let me test on mobile early.

2. Don't build auth from scratch. I initially tried rolling my own auth. Wasted 3 hours. Switched to a simple email magic link flow and saved my sanity.

3. Rate limiting is essential. Without it, one user could burn through your entire OpenAI budget in minutes. I added a simple token-bucket rate limiter in the API route.

4. Error handling for AI is different. Sometimes the AI returns garbage. Sometimes it times out. Sometimes it ignores your constraints. You need graceful fallbacks and retry logic.

Current Numbers

It's been a few weeks since launch:

Around 50 signups on the free tier
A handful of paid subscribers
Average generation time: 2-3 seconds

Not viral numbers, but the product works and people are using it. The focus now is distribution, not features.

What's Next

I'm working on:

Email sequence generation (not just single emails)
Better prospect research integration
A Chrome extension for LinkedIn prospecting

Try It

If you're doing any kind of cold outreach, give it a shot: ColdMailAI. The free tier lets you generate emails without signing up.

I'm building this in public, so I'll be sharing more updates here. Happy to answer any technical questions in the comments.

What's your experience with AI-generated emails? Have you found a sweet spot between automation and personalization? Let me know below.