Vibe Code Your Own Cold Email Sequencer with Winnr

Why Build Your Own Sequencer?

Commercial sequencers bundle sending logic, a campaign UI, a unified inbox, analytics and often warmup and mailboxes into one subscription. For most teams that bundle is the right call. Building your own makes sense when the workflow you need doesn't fit a product's settings: unusual follow-up logic, your own lead scoring, a tight CRM integration, or outbound email embedded in a product you are building.

The parts of cold email that are genuinely hard are provisioning mailboxes with correct DNS and building their sending reputation. Those are available as an API. The "sequencer" part (who gets which email, and when) is mostly logic. In 2026 you can write that logic with an AI coding assistant like Claude, Cursor or Windsurf.

Warming Is Built In

A sequencer is not much use without warmed mailboxes: fresh mailboxes on new domains land in spam. Warming needs a network of real mailboxes to exchange mail with, which is not something you can code yourself. That is a common reason people keep a sequencer's bundled warmup even when they want a different sending tool.

Winnr has built-in email warming. Enable it on any mailbox with one API call or one click in the dashboard. It costs $0.60 per mailbox per month and gives each mailbox a health score, inbox rate and configurable ramp-up speed. Infrastructure and warming come from one API and one bill, so your sequencer only has to handle sending.

What Is "Vibe Coding"?

Vibe coding is a term coined by Andrej Karpathy for 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.

Cold email sequencing suits it well because:

• The logic is straightforward: Sequences are timed actions based on conditions (replied, bounced, no reply). No complex algorithms needed.
• The hard work is API calls: Provisioning mailboxes, enabling warming and sending email are documented REST endpoints that AI assistants handle easily.
• Your requirements are specific: Your follow-up cadence, your lead scoring, your CRM. With your own code, you describe your workflow and get your tool.
• Iteration is fast: Change sequence timing, add a conditional step or a new integration by describing the change.

The Stack: Winnr + Your Code

Your custom sequencer sits on one API that handles the infrastructure, plus the logic you write on top.

Winnr: Mailbox Provisioning, Warming and Sending

Winnr's API covers your email infrastructure and warming:

• Domain purchase and DNS setup: Search available domains, buy them (a one-time purchase, about $13 for a .com), and Winnr configures SPF, DKIM, DMARC and MX records. No manual DNS editing.
• Bulk mailbox creation: Create up to 500 mailboxes on a domain in one call. Each gets IMAP and SMTP credentials.
• Built-in warming: Enable warming on any mailbox with one API call, with configurable volume (up to 20 warmup emails a day) and ramp-up speed, at $0.60 per mailbox per month.
• Email sending: Send through your mailboxes via the API, or over SMTP if you prefer.
• Inbox monitoring: Read incoming replies programmatically to detect responses and trigger follow-up logic.
• Warming analytics: Health scores, inbox rates, spam rates and warming event logs per mailbox.

Your Code: The Sequencer Logic

This is the part you vibe code: which leads get which emails, when follow-ups fire, how replies are handled. A few hundred lines of code, most of which your AI assistant will write.

Step 1: Provision Your Infrastructure

First, you need domains and mailboxes.

Buy domains and create mailboxes in one call:

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

{
  "async": true,
  "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 call charges the account's card for the two domains, registers them, sets up all DNS records (SPF, DKIM, DMARC, MX) and creates six mailboxes. With "async": true it returns a job_id straight away and does the work in the background, which is the recommended mode for more than two or three domains.

Check provisioning status:

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

// Response:
{
  "data": {
    "job_id": "job_abc123",
    "status": "completed",
    "result": { ... },
    "error": null
  },
  "meta": { ... }
}

Step 2: Enable Warming with One API Call

Fresh mailboxes have no sender reputation, and sending cold email from them straight away is a fast track to the spam folder. After your mailboxes are provisioned, enable warming through the 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"
  }
}

One call enables warming on several mailboxes at once. The first month for those mailboxes is charged when you enable, and warming starts once that payment succeeds. Volume starts low and climbs to the daily target at the ramp speed you choose:

• Slow: the most gradual ramp. Best for brand-new domains.
• Normal: the default. Fine for most setups.
• Fast: the quickest ramp, for established domains with a clean history.

Monitor warming health via the API:

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

// Response:
{
  "data": {
    "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
  },
  "meta": { ... }
}

Get per-mailbox daily metrics:

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

// Response:
{
  "data": {
    "metrics": [
      { "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 },
      ...
    ]
  },
  "meta": { ... }
}

Step 3: Vibe Code Your Sequencer

Your mailboxes are provisioned and warming. While they build reputation over the next 2 to 4 weeks, write the sequencer logic.

The Core Loop

At its simplest, a cold email sequencer is a loop that runs on a schedule (for example 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 limit of 15 cold 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. Responses wrap results in a "data" field.
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 (warming status and health per mailbox)

An AI assistant will generate a working first version from this prompt: a main script, email templates, a database schema and a config file. From there you iterate: "integrate with my HubSpot CRM", "add A/B testing for subject lines", and so on.

Features to Add Next

• "Add send-time optimization": Track when replies come in and bias sending toward those hours and days.
• "Add automatic bounce handling": Parse bounce notifications and stop sending to invalid addresses immediately.
• "Add mailbox health rotation": Pull warming health scores via the API and take mailboxes with falling scores out of rotation.
• "Add Slack notifications": Post to Slack when a lead replies so your 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 and bounced counts per campaign, plus warming health across all mailboxes.

Step 4: Automate the Full Pipeline

Because everything is programmable through one API, a single script can handle the whole lifecycle:

# Full pipeline pseudocode, everything through the Winnr API

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

# 2. Wait for provisioning to complete
winnr.wait_for_job(order.job_id)

# 3. Enable warming on the new mailboxes (one API call)
new_users = winnr.list_email_users(domain="newdomain1.com") + \
            winnr.list_email_users(domain="newdomain2.com")
winnr.enable_warming(
    user_ids=[u.id for u in new_users],
    settings={"emails_per_day": 20, "rampup_speed": "normal"}
)

# 4. Only send from mailboxes that have finished warming
warm_mailboxes = [
    m for m in winnr.list_warming_mailboxes()
    if m.warming_health_score >= 80 and m.warming_inbox_rate >= 90
    and m.warming_started_at < days_ago(14)
]

# 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 process is automated through one API. New mailboxes warm in the background and join the send rotation once they meet your thresholds, and mailboxes whose health falls get rotated out.

Warming API Reference

Warming works by exchanging realistic emails, with replies, between your mailbox and a shared warming network of real mailboxes, so the mailbox builds a steady sending history. These are the endpoints you will use:

Warming is $0.60 per mailbox per month, an add-on to the Startup or Enterprise plan: 50 mailboxes warming is $30 a month, 200 is $120. Many teams disable it after 2 to 4 weeks once real campaigns are running; others keep it on at lower volume.

Build or Keep Your Sequencer?

Either way the infrastructure can be the same: Winnr mailboxes export to Instantly, Smartlead, EmailBison, PlusVibe and other sequencers, or you send through the API from your own code.

What You'll Need

Smaller start: the Startup plan is $69/mo for 50 mailboxes. Domains are a one-time purchase on top (about $13 for a .com), and connecting domains you already own is free. Full plan details are on the pricing page.

Technical requirements

• Programming ability: Little required, which is the point of vibe coding. Basic comfort with running scripts from a terminal helps.
• Hosting: A cron job on a small VPS, a scheduled GitHub Action, or a serverless function. The sequencer only needs to run every 15 to 30 minutes.
• Warming wait time: At least 2 weeks for new mailboxes, 4 on a brand-new domain. Use the time to build and test your sequencer.

Getting Started Today

1. Create a Winnr account and generate an API key from the dashboard. Pick a plan, then provision your first domains and mailboxes via the API (or the UI).
2. Enable warming on the new mailboxes with one API call or one click in the dashboard.
3. While mailboxes warm, vibe code your sequencer. Paste the prompt from Step 3 into your AI assistant and iterate until it matches your workflow. Test with a few internal addresses first.
4. Check warming health via the API. After at least 2 weeks (4 on a new domain), with health scores at 80 or higher and inbox rates at 90% or higher, run a seed placement test and start real campaigns at 10 to 15 cold emails per mailbox per day.
5. Scale by adding mailboxes. Add domains and mailboxes via the API, enable warming, and bring them into rotation once warmed.

Because you own the code, every tweak and integration you add stays with you.

Related: how to embed email infrastructure in your app with the Winnr API and built-in warming vs sequencer warmup pools vs standalone warmup tools.