Vibe Code Your Own Cold Email Sequencer with Winnr & Mailivery

Why Build Your Own Sequencer?

Most cold email sequencers are a bundled deal: infrastructure, warmup, and sending logic all wrapped into one monthly subscription. That sounds convenient until you realize the bundle is a trap. The infrastructure is shared with thousands of other senders. The warmup pool is neglected or actively toxic. And the sending logic is a rigid UI that can't do anything your specific workflow needs.

Here's the thing: the hard parts of cold email — provisioning mailboxes with proper DNS, warming accounts to build reputation — are now available as standalone APIs. The "sequencer" part — deciding who gets what email and when — is actually the easy part. It's just logic. And in 2026, you can vibe code that logic in an afternoon with an AI coding assistant like Claude, Cursor, or Windsurf.

The Missing Piece: Warmup

Here's what most people don't realize: the sequencer itself is the easy part to build. Tons of people already want to vibe code their own sequencer — the sending logic is straightforward, AI assistants can generate it in minutes, and you'd finally have a tool that matches your exact workflow. So why doesn't everyone just do it?

Because a sequencer without a warmup pool is useless. Fresh mailboxes land in spam. And warmup pools are the one thing you can't just code yourself — you need a network of real accounts interacting with yours. That's why people stay trapped on platforms like Instantly even when the sequencer is mediocre and the warmup pool is toxic. They think the warmup is inseparable from the sequencer.

It's not. Mailivery is a standalone warmup service with a full API. Winnr is standalone mailbox infrastructure with a full API. Put them together and you have everything you need — except the sequencer. And that's the part you can vibe code in an afternoon. The warmup problem is solved. The infrastructure problem is solved. Now the sequencer is just logic, and it's yours to build however you want.

What Is "Vibe Coding"?

Vibe coding is a term coined by Andrej Karpathy to describe writing software by describing what you want to an AI and letting it generate the code. You focus on the intent — "send a follow-up email 3 days after no reply" — and your AI assistant writes the Python, TypeScript, or whatever you need to make it happen.

Cold email sequencing is a perfect candidate for vibe coding because:

• The logic is straightforward: Sequences are just timed actions based on conditions (replied, opened, bounced). No complex algorithms needed.
• The hard work is API calls: Provisioning mailboxes, connecting warmup, sending emails — these are all well-documented REST APIs that AI assistants handle easily.
• Your requirements are unique: Your ideal follow-up cadence, your lead scoring, your CRM integration — no off-the-shelf tool gets it exactly right. With vibe coding, you describe your workflow and get your tool.
• Iteration is instant: Want to change your sequence timing? Add a conditional step? Integrate with a new tool? Describe the change and it's done in minutes, not constrained by what some product team decided to put in a dropdown menu.

The Stack: Winnr + Mailivery + Your Code

Your custom sequencer is built on two professional APIs that handle the hard infrastructure work, plus whatever custom logic you write on top:

Winnr — Mailbox Provisioning & Sending

Winnr's API handles everything about your email infrastructure. You get programmatic access to:

• Domain purchase & DNS setup: Search available domains, buy them, and winnr automatically configures SPF, DKIM, DMARC, and MX records. No manual DNS editing.
• Bulk mailbox creation: Create dozens of mailboxes across your domains in a single API call. Each gets IMAP and SMTP credentials ready to use.
• Email sending: Send emails directly through your provisioned mailboxes via the API — no SMTP library configuration needed.
• Inbox monitoring: Read incoming replies programmatically to detect responses and trigger follow-up logic.

Mailivery — Automated Warmup

Mailivery is a dedicated email warmup service with its own API. Once winnr provisions your mailboxes, you connect them to Mailivery to build sender reputation:

• Peer-to-peer warmup network: Real email accounts interact with your mailboxes — opens, replies, and spam-to-inbox rescues that build genuine engagement signals.
• AI-generated content: Warmup emails use AI-personalized content so interactions look natural to inbox providers.
• Programmable via API: Connect mailboxes, start/pause warmup, set daily volumes, monitor health scores — all through REST endpoints.
• Blacklist monitoring: Continuous checks against 70+ blacklists with alerts if any issues arise.

Your Code — The Sequencer Logic

This is the part you vibe code. It's just the orchestration: which leads get which emails, when follow-ups fire, how replies are handled. A few hundred lines of code at most — and your AI assistant will write most of it for you.

Step 1: Provision Your Infrastructure

First, you need domains and mailboxes. Here's how the winnr API makes this trivial.

Search and buy domains:

POST https://api.winnr.app/v1/domains/purchase
Authorization: Bearer wnr_your_api_key

{
  "domains": [
    {
      "domain": "acmeleads.com",
      "register": true,
      "setup_dns": true,
      "setup_email": true,
      "users": [
        {"name": "Sarah Chen", "username": "sarah"},
        {"name": "James Park", "username": "james"},
        {"name": "Maria Lopez", "username": "maria"}
      ]
    },
    {
      "domain": "acmeoutreach.com",
      "register": true,
      "setup_dns": true,
      "setup_email": true,
      "users": [
        {"name": "Sarah Chen", "username": "sarah"},
        {"name": "James Park", "username": "james"},
        {"name": "Maria Lopez", "username": "maria"}
      ]
    }
  ]
}

That single API call purchases two domains, sets up all DNS records (SPF, DKIM, DMARC, MX), and creates six mailboxes across them. Winnr handles domain registration, DNS zone creation, and Mailcow provisioning asynchronously — you can track progress via the jobs endpoint.

Check provisioning status:

GET https://api.winnr.app/v1/jobs/{job_id}
Authorization: Bearer wnr_your_api_key

// Response:
{
  "id": "job_abc123",
  "status": "completed",
  "progress": 100,
  "result": { "domains_created": 2, "users_created": 6 }
}

Step 2: Connect Warmup with Mailivery

Fresh mailboxes have zero sender reputation. Sending cold email from them immediately is a fast track to the spam folder. Mailivery solves this by running automated warmup interactions through a peer-to-peer network of real accounts.

After your winnr mailboxes are provisioned, connect them to Mailivery via their API:

POST https://app.mailivery.io/api/v1/mailboxes
Authorization: Bearer your_mailivery_api_key

{
  "email": "sarah@acmeleads.com",
  "smtp_host": "smtp.winnr.email",
  "smtp_port": 587,
  "smtp_username": "sarah@acmeleads.com",
  "smtp_password": "your_mailbox_password",
  "imap_host": "imap.winnr.email",
  "imap_port": 993,
  "imap_username": "sarah@acmeleads.com",
  "imap_password": "your_mailbox_password",
  "daily_limit": 30,
  "ramp_up": true
}

Mailivery will start with a low volume and gradually ramp up over 2–4 weeks. During this period, real accounts in Mailivery's network will exchange emails with your mailbox, open them, reply to them, and rescue any that land in spam — all the signals inbox providers like Gmail and Outlook use to determine if your account is trustworthy.

Monitor warmup health:

GET https://app.mailivery.io/api/v1/mailboxes/{mailbox_id}/metrics
Authorization: Bearer your_mailivery_api_key

// Response:
{
  "health_score": 92,
  "inbox_rate": 0.94,
  "spam_rate": 0.04,
  "warmup_emails_sent_today": 28,
  "warmup_emails_received_today": 25,
  "blacklists_clean": true
}

Step 3: Vibe Code Your Sequencer

Now for the fun part. Your mailboxes are provisioned and warming. While they build reputation over the next 2–4 weeks, you vibe code the sequencer logic. Here's what to tell your AI assistant to build:

The Core Loop

At its simplest, a cold email sequencer is a loop that runs on a schedule (e.g., every 15 minutes) and does three things:

1. Check for replies: Use the winnr inbox API to scan for new messages. Mark leads as "replied" and remove them from the sequence.
2. Process the send queue: For each lead whose next email is due, pick a mailbox, render the email template (with personalization), and send via the winnr API.
3. Advance sequences: Move leads to their next step and calculate when the next email should fire.

Here's a prompt you might give your AI assistant to get started:

Build me a cold email sequencer in Python that:

1. Reads leads from a CSV (columns: email, first_name,
   company, custom_line)
2. Runs a 3-step sequence:
   - Day 1: Initial outreach email
   - Day 3: Follow-up if no reply
   - Day 7: Breakup email if still no reply
3. Rotates sending across multiple winnr mailboxes
4. Checks for replies via the winnr inbox API and stops
   the sequence for anyone who replies
5. Respects a per-mailbox daily send limit of 30 emails
6. Logs everything to a SQLite database
7. Uses Jinja2 templates for email content with
   personalization variables

Use the winnr API (api.winnr.app/v1) for sending and
inbox checks. Here are the endpoints I need:
- POST /v1/email-users/{id}/inbox/send (send an email)
- GET /v1/email-users/{id}/inbox (check for replies)
- GET /v1/email-users (list all my mailboxes)

An AI assistant will generate a working sequencer from this prompt in a single conversation. You'll get a main script, email templates, a database schema, and a config file. From there, you iterate: "add open tracking," "integrate with my HubSpot CRM," "add A/B testing for subject lines" — each request takes minutes, not weeks of waiting for a feature request on someone else's product roadmap.

Advanced Features to Add

Once your basic sequencer is working, here are prompts for features that would cost you $200+/month on a commercial sequencer:

• "Add send-time optimization": Track when replies come in and bias sending toward those hours/days.
• "Add automatic bounce handling": Parse bounce notifications and pause sending to invalid addresses immediately.
• "Add mailbox health rotation": Pull Mailivery health scores via their API and deprioritize mailboxes with declining scores.
• "Add Slack notifications": Send a Slack message when a lead replies so your sales team can respond fast.
• "Add lead scoring": Weight leads by company size, industry, or engagement and prioritize high-value prospects.
• "Build a simple dashboard": A Flask or Streamlit app showing sent/replied/bounced counts per campaign.

Step 4: Automate the Full Pipeline

The real power of this approach is that everything is programmable. You can write a single script that handles the entire lifecycle:

# Full pipeline pseudocode

# 1. Provision new domains + mailboxes via winnr
new_domains = winnr.purchase_domains(["newdomain1.com", "newdomain2.com"],
                                      users_per_domain=3)

# 2. Wait for provisioning to complete
winnr.wait_for_jobs(new_domains.job_ids)

# 3. Connect all new mailboxes to Mailivery for warmup
for mailbox in winnr.list_email_users():
    if mailbox.status == "active" and not mailivery.is_connected(mailbox):
        mailivery.connect_mailbox(mailbox.smtp_credentials)
        mailivery.start_warmup(mailbox.email, daily_limit=30, ramp_up=True)

# 4. Check warmup health before adding to send rotation
warm_mailboxes = []
for mailbox in mailivery.list_mailboxes():
    metrics = mailivery.get_metrics(mailbox.id)
    if metrics.health_score > 85 and metrics.inbox_rate > 0.90:
        warm_mailboxes.append(mailbox)

# 5. Run your sequencer with only warmed mailboxes
sequencer.run(mailboxes=warm_mailboxes, leads=load_leads("leads.csv"))

From domain purchase to first cold email, the entire process is automated. New mailboxes warm up in the background. When they hit your health thresholds, they automatically enter the send rotation. Burned-out accounts get rotated out. You never touch a dashboard — the code handles it.

Why This Beats Instantly (and Similar Sequencers)

Let's be direct about why building your own sequencer is superior to using a platform like Instantly.

Instantly's business model is a classic lock-in play. They offer a sequencer bundled with a warmup pool, and then they sell you "DIY mailboxes" at a massive markup — often $4 per mailbox per month. That's nearly 3x what high-quality SMTP infrastructure actually costs. They get away with this because people think they need Instantly's warmup pool and therefore have to buy Instantly's mailboxes too. It's the razor-and-blades model: the sequencer is the razor, and those overpriced mailboxes are the blades.

The problem is the blades are also terrible. Their warmup pool — the whole reason you're locked in — is actively toxic for SMTP accounts. Over 50% of the addresses in their SMTP warmup pool are completely invalid — dead domains, non-existent mailboxes that hard bounce immediately. Every bounce sends a powerful negative signal to inbox providers. You're paying a premium for infrastructure that's actively destroying your sender reputation.

Once you realize that Mailivery provides a standalone, high-quality warmup pool via API, and winnr provides high-quality infrastructure at a fraction of Instantly's mailbox prices, the lock-in disappears. You no longer need Instantly for warmup, which means you no longer need their overpriced mailboxes, which means you no longer need their sequencer. And their sequencer was the least valuable part of the bundle anyway — it's just logic you can vibe code in an afternoon.

By separating infrastructure (winnr) from warmup (Mailivery) from sequencing logic (your code), you use the best tool for each job instead of accepting a mediocre, overpriced bundle. Each component is best-in-class at what it does, and none of them lock you into the others.

What You'll Need

Here's a realistic breakdown of what this stack costs and requires:

Now compare that to Instantly. Their Growth plan is $97/mo for the sequencer — but then you need mailboxes. At ~$4/mailbox, 200 mailboxes through Instantly's "DIY" offering would cost you $800/mo just for infrastructure, plus the $97 for the sequencer, plus their broken warmup pool that's included but actively harmful. That's nearly $900/mo for shared infrastructure, a toxic warmup pool, and a rigid sequencer. The winnr + Mailivery stack gives you dedicated infrastructure, professional warmup, and a sequencer that does exactly what you need — for a third of the price.

Technical requirements

• Programming ability: None required — that's the whole point of vibe coding. You describe what you want, and the AI writes it. Basic comfort with running scripts from a terminal is helpful.
• Hosting: A cron job on a $5/mo VPS, a scheduled GitHub Action, or a serverless function. Your sequencer doesn't need to be running 24/7 — it just needs to check in every 15–30 minutes.
• Time investment: An afternoon to get the basic sequencer running. A few hours per month to iterate and add features as your needs evolve.

Getting Started Today

Here's your action plan:

1. Sign up for winnr and generate an API key from the dashboard. Provision your first batch of domains and mailboxes via the API (or the UI if you prefer — the API is there when you're ready).
2. Sign up for Mailivery and connect your new mailboxes. Start warmup with ramp-up enabled. This takes 2–4 weeks, and it's fully hands-off.
3. While mailboxes warm, vibe code your sequencer. Open your AI assistant of choice, paste the prompt from Step 3 above, and iterate until it matches your workflow. Test with a few internal email addresses first.
4. When warmup health scores hit 85+, start sending real campaigns at low volume (10–15 per mailbox per day). Monitor reply rates and adjust.
5. Scale gradually. Add more domains and mailboxes via the winnr API, connect them to Mailivery, and they'll automatically enter your send rotation once warmed.

The sequencer you build in an afternoon will be more customizable than any $300/month platform. And because you own the code, it gets better every time you use it — every tweak, every new integration, every optimization compounds into a tool that's perfectly shaped to how you do outreach.

Stop renting someone else's broken sequencer. The infrastructure APIs exist. The AI coding tools exist. Build the tool that actually fits your workflow — and own it.