Vibe Code Your Own Cold Email Sequencer with Winnr

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 and warming accounts to build reputation — are now available as a single API from winnr. 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 Is Solved: Warming Is Now Built In

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. Winnr now has built-in email warming — enable it on any mailbox with a single API call or one click in the dashboard. At $0.60/mailbox/month, you get automated warmup with health score tracking, inbox rate analytics, and configurable ramp-up speeds. No separate warmup vendor. No sharing SMTP credentials with a third party. No juggling multiple dashboards and bills. Infrastructure and warming, one API, one bill.

That means the last barrier to building your own sequencer is gone. Winnr handles infrastructure and warming. The sequencer logic is the easy part you vibe code in an afternoon.

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, enabling 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 + Your Code (That's It)

Your custom sequencer is built on one professional API that handles all the hard infrastructure work, plus whatever custom logic you write on top. No juggling multiple vendors.

Winnr — Mailbox Provisioning, Warming & Sending

Winnr's API handles everything about your email infrastructure and warming. 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.
• Built-in warming: Enable warming on any mailbox with one API call. Automated warmup emails build sender reputation with configurable volume (up to 20/day), smart ramp-up, and real-time health score tracking — all at $0.60/mailbox/month.
• 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.
• Warming analytics: Monitor health scores, inbox rates, spam rates, and activity feeds per mailbox via the API.

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 mailbox 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: Enable Warming with One API Call

Fresh mailboxes have zero sender reputation. Sending cold email from them immediately is a fast track to the spam folder. Winnr's built-in warming solves this — no third-party tool, no credential sharing, no separate bill.

After your mailboxes are provisioned, enable warming directly through the winnr API:

POST https://api.winnr.app/v1/warming/enable
Authorization: Bearer wnr_your_api_key

{
  "user_ids": ["user_id_1", "user_id_2", "user_id_3"],
  "settings": {
    "emails_per_day": 20,
    "rampup_speed": "normal"
  }
}

That's it. One API call enables warming on multiple mailboxes at once. Winnr automatically starts sending and receiving warmup emails, gradually ramping up volume to build sender reputation safely. Choose from three ramp-up speeds:

• Slow: Conservative ramp-up over 4+ weeks. Best for brand new domains.
• Normal: Standard 2-3 week ramp-up. Works for most use cases.
• Fast: Aggressive ramp-up over 1-2 weeks. Use for aged domains with some existing reputation.

Monitor warming health via the API:

GET https://api.winnr.app/v1/warming/overview
Authorization: Bearer wnr_your_api_key

// Response:
{
  "total_mailboxes": 6,
  "active": 6,
  "paused": 0,
  "problems": 0,
  "avg_health_score": 87.3,
  "avg_inbox_rate": 94.2,
  "total_sent_today": 98,
  "total_replies_today": 41,
  "monthly_cost": 3.60
}

Get per-mailbox metrics:

GET https://api.winnr.app/v1/warming/{user_id}/metrics?days=30
Authorization: Bearer wnr_your_api_key

// Response:
{
  "data": [
    { "date": "2026-03-01", "sent": 18, "inbox": 17, "spam": 1, "replies": 7, "inbox_rate": 94.4 },
    { "date": "2026-03-02", "sent": 19, "inbox": 18, "spam": 1, "replies": 8, "inbox_rate": 94.7 },
    ...
  ]
}

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)
- GET /v1/warming/overview (check warming health)

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 winnr warming health scores via the 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, plus warming health across all mailboxes.

Step 4: Automate the Full Pipeline

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

# Full pipeline pseudocode — everything through the winnr API

# 1. Provision new domains + mailboxes
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. Enable warming on all new mailboxes (one API call)
new_users = winnr.list_email_users(status="active", warming="disabled")
winnr.enable_warming(
    user_ids=[u.id for u in new_users],
    settings={"emails_per_day": 20, "rampup_speed": "normal"}
)

# 4. Check warming health before adding to send rotation
overview = winnr.get_warming_overview()
print(f"Warming: {overview.active} active, avg health: {overview.avg_health_score}")

warm_mailboxes = []
for user in winnr.list_warming_mailboxes():
    if user.warming_health_score > 85 and user.warming_inbox_rate > 90:
        warm_mailboxes.append(user)

# 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 through one API. 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.

Winnr Warming: The Complete Picture

Since warming is such a critical part of the cold email pipeline, here's everything you need to know about winnr's built-in warming feature:

How It Works

When you enable warming on a mailbox, winnr connects it to an automated warming network. Real email accounts exchange messages with your mailbox — opens, replies, and spam-to-inbox rescues that generate the positive engagement signals Gmail and Outlook use to determine sender trustworthiness. Volume ramps up gradually based on your chosen speed, and you get full visibility into health scores and inbox placement rates.

Warming API Reference

Warming Pricing

$0.60 per mailbox per month. That's it. No tiers, no hidden fees. Available on every winnr plan (Free, Startup, Enterprise). Prorated for the first month. Billed on your existing winnr subscription. Disable anytime with one click or API call.

For context: 50 mailboxes warming = $30/month. 200 mailboxes = $120/month. Standalone warmup tools like Mailivery charge $79/month for their Professional plan. You save money and get a simpler setup.

Why This Beats Instantly (and Similar Sequencers)

Let's be direct about why building your own sequencer with winnr 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.

Winnr eliminates the lock-in entirely. You get infrastructure and warming from one provider with one API, at a fraction of the cost, with none of the toxic warmup pool problems.

What You'll Need

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

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 stack gives you dedicated infrastructure, professional built-in warming, 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.
• Warming wait time: 2-4 weeks for new mailboxes to build reputation. Use this time to vibe code your sequencer so it's ready when your accounts are warmed.

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).
2. Enable warming on your new mailboxes with one API call or one click in the dashboard. Choose your ramp-up speed and let it run.
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. Monitor warming health via the API. When health scores hit 85+ and inbox rates are above 90%, start sending real campaigns at low volume (10–15 per mailbox per day).
5. Scale gradually. Add more domains and mailboxes via the winnr API, enable warming, 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. Infrastructure and warming are now one API call away. Build the tool that actually fits your workflow — and own it.