What You'll Build

A pipeline that takes your ideal customer profile and produces a clean, verified, qualified cold email list that's ready to drop into a sequencer. The output is a CSV with names, titles, verified business emails, company context, and the AI-assisted fit score that tells you whether each person actually belongs in your campaign.

The difference between this and a scraped list off Fiverr is the same as the difference between a hand-tailored suit and a trash bag. Both technically cover you. One of them also gets you in the door.

This is the exact process we run at Clawdrop for our own outbound and for the Navreo methodology we teach clients. It's built around the tools we actually use in production: Clay, Apollo, Trigify, RB2B, MillionVerifier, Manyreach. You can swap any of them for an equivalent. The pipeline is the playbook, not the tools.

By the end of this guide, you'll know how to go from "I want to sell to funded fintech founders" to "here's 800 verified contacts, sorted by fit, ready to send." No scraping, no guessing, no bounces.

Why Most Cold Lists Break Your Domain

Here's what actually happens when someone buys a cheap list and uploads it to their sequencer.

About 30% of the emails bounce in the first send. Maybe 20% are catch-all addresses that technically accept mail but never route to a human. Another 15% are role accounts like info@ or sales@ that get filtered straight to spam folders by corporate filters. And the remaining 35% are real people, but half of them are at companies that don't match your ICP because the list was sold to 400 other people before you got it.

Every hard bounce tells inbox providers that you don't know who you're emailing. Your sender reputation drops. Your delivery rate goes from 95% to 40% overnight. Your warmup work is gone. Your domain is toast.

You fix this by building the list yourself. Not because you enjoy it, but because the alternative is paying $2,000 a month for a cold email service that delivers to 12 real inboxes.

The math is brutal but simple. A list of 800 clean contacts with a 2% bounce rate will out-perform a list of 4,000 scraped contacts with a 25% bounce rate every single time. The smaller list lands in more inboxes, gets more replies, and keeps your domain alive. The bigger list kills your infrastructure in 48 hours.

That's the whole pitch. Build fewer, cleaner lists. Send them to fewer, more qualified people. Watch your reply rate triple.

The Pattern

Every cold list we build goes through the same 7 stages, in the same order. Skipping any of them is what causes most "my outbound doesn't work" problems.

ICP DEFINITION
    |
    v
SOURCING (pick a lane)
    |
    v
COMPANY → CONTACT SPLIT
    |
    v
EMAIL DISCOVERY
    |
    v
EMAIL VERIFICATION
    |
    v
AI QUALIFICATION PASS
    |
    v
DEDUP, SUPPRESS, FORMAT
    |
    v
SEQUENCER-READY CSV

The top of the funnel is about filtering. The bottom is about verification. The middle is about enrichment. If you understand that, you understand the whole thing.

Step-by-Step Setup

Step 1: Define the ICP Before You Touch a Tool

This is the step everyone wants to skip. Don't.

Your ICP is a set of filters, not a vibe. Write down the hard constraints in plain English first, then translate them into filter language.

The 6 filters that matter:

Write a one-sentence ICP that combines all six. Example: "Funded YC companies with 10-50 employees in fintech that raised a seed round in the last 90 days, where the decision-maker is the CEO or a co-founder."

That's a filter stack you can actually execute against. "B2B SaaS founders" is not.

If you can't write the ICP sentence, the list you build will be random. Random lists don't convert.

Step 2: Pick a Sourcing Lane

There are four lanes we use depending on the ICP. Each one answers a different question.

Funding-based (Crunchbase, FundedList, PitchBook). Answers: "who just got money?" New funding means new budget, new hires, new problems to solve. Works for anything targeting early-stage startups, whether you're selling finance, HR, hiring, or tools.

Technographic (TheirStack, BuiltWith, Wappalyzer). Answers: "who's running the tool my product integrates with?" If you sell a Shopify app, you want a list of Shopify stores. If you sell a Salesforce integration, you want Salesforce accounts. This is the highest-signal source for integration plays.

Intent-based (RB2B, Trigify, Koala, Clearbit Reveal). Answers: "who just showed interest?" Website visitors who didn't fill out the form. People who liked a competitor's post. Companies that viewed your pricing page. These are already half-warm.

Directory-based (Apollo, ZoomInfo, Lusha, Clay). Answers: "who matches my filter stack?" The brute-force option. Lowest signal per contact but highest volume and most flexibility. Good when you're still learning what works.

Pick one lane per campaign. Don't mix. A campaign built on "funded fintech" looks different from a campaign built on "Shopify stores using Klaviyo" even if the end product is the same.

For most solopreneurs and small teams, the funding-based lane is the right place to start. It has the cleanest signal, the best reply rates, and the most predictable cadence. Something gets funded every week.

Step 3: Split Companies Into Contacts

You now have a list of companies. You need a list of humans.

This is the step where we burn the most time if we're not careful. One company with 10 employees might have 3 relevant contacts (CEO, Head of Sales, Head of Marketing). A company with 200 employees might have 8. A company of 5 probably just has the founder.

The rule we follow is titles first, then headcount. Pull every contact that matches your target role titles, then cap at 3 contacts per company. More than 3 and you look like a spammer to the inbox providers at each company.

Tools for this step:

Your output is a table with: company name, domain, person name, person title, LinkedIn URL. No emails yet. We don't touch emails until step 4.

Step 4: Find the Email

This is the step where most DIY lists fail. You cannot just guess firstname@company.com and call it a list. You'll hit bounces on 40% of your sends.

We use a 3-tier discovery cascade:

Tier 1: Pattern inference. Most companies use 2-3 email patterns across their whole org. first.last@, firstinitial+last@, first@. Once you know the pattern for one employee, you know it for all of them. Tools like Clay, Findymail, and Apollo handle this automatically.

Tier 2: Enrichment API fallback. If the pattern inference fails or comes back empty, fall back to a direct enrichment API. Hunter, Dropcontact, and Apollo all have APIs that will hand you a verified email for a contact if they have one in their database.

Tier 3: Manual spot-check for high-value targets. For the top 20-50 contacts in any list, manually verify the email exists by checking the company's website, LinkedIn post history, or a tool like RocketReach. These are your best prospects. Spend 2 minutes each confirming they're real.

The output of step 4 is the same table as step 3, but now with a "raw_email" column. Every row has a candidate email. Some of them are wrong. That's what step 5 is for.

Step 5: Verify Before You Load Anything

A "raw" email is a guess. A "verified" email is a promise. The sequencer only gets verified.

Verification has 3 levels:

Syntax check. Does the email string actually look like an email? j@@doe.com fails. This is free and instant.

MX record lookup. Does the domain actually accept mail? Dead domains fail here. This is free and takes milliseconds.

SMTP RCPT verification. Does the mail server confirm the inbox exists when you ask it? This is the real test. Some mail servers answer yes/no. Some refuse to answer (catch-alls). Some rate-limit you if you ask too many times.

For the SMTP step, we use MillionVerifier as our primary and Bouncer as a fallback for anything marked "risky" or "catch-all." The two services disagree on about 8% of addresses. When they disagree, we throw the address out. The lost volume is worth the gained deliverability.

Our internal rule: anything not marked "valid" by both verifiers gets killed. No exceptions. A "risky" email is a hard bounce waiting to happen.

Your output after step 5 is the same table as before, but with about 30-50% of the rows gone. That's fine. Fewer clean rows is always better than more mixed rows.

Step 6: AI Qualification Pass

You now have a list of verified contacts. Not all of them actually belong in your campaign.

This is where most people stop. Don't. The next step is what separates a "list" from a "targeting shortlist."

Feed each contact (with their company context) to an AI agent with a prompt that looks like this:

You are qualifying leads for a cold outbound campaign.

ICP: [your one-sentence ICP from step 1]

Company: [name]
Industry: [industry]
Size: [headcount]
Description: [company description, 2-3 sentences]
Contact title: [title]

Score this lead 1-10 on fit with the ICP. Output:
- score: (1-10)
- reason: (one sentence)
- kill: (true if score < 6)

The agent reads each row, scores it, and flags the ones that don't actually match. In our experience this kills 30-50% of what survived step 5. Companies that looked like a match on the filter stack but are actually running a different business model. Contacts whose titles technically match but whose functional role is wrong. Companies that closed, pivoted, or got acquired.

This is the step that takes a "list" and turns it into a "campaign." Everyone who's skipped it has regretted it.

Budget: this runs on Claude Haiku or GPT-4o-mini at roughly $0.50 per 1,000 contacts. It's the cheapest and most impactful step in the whole pipeline.

Step 7: Dedup, Suppress, Format

Last step. This is where you make sure you're not about to do something dumb.

Dedup against every other list you've sent to. The same person showing up in 4 different campaigns in a month is a fast way to get blocked.

Suppress against your existing CRM, your current active sequences, your past customers, and your competitors. The suppression list grows forever. Feed it with every contact you've ever touched.

Format for the sequencer. Manyreach expects a CSV with specific columns. Map your output table to match exactly. The merge tags you plan to use in your copy need to come from real columns in the CSV.

Typical Manyreach column set:

The custom columns are the difference between a generic blast and a personal-feeling email. Fill them with something specific. "I saw you just raised a Series A from Benchmark" beats "Hope you're well" every single time.

Your final output is a sequencer-ready CSV. Load it, hit send, and move on to the next list.

Lanes That Work

This pipeline fits anyone running outbound at a small to medium scale.

B2B SaaS founders selling to funded startups. Funding-based sourcing, 3 contacts per target account, technical decision-maker titles. Classic motion.

Agency owners selling to local service businesses. Directory-based sourcing (Apollo), role title targeting (owner, president, marketing manager), geographic filter, small contact-per-account cap.

Recruiters and talent agencies sourcing candidate pools. Intent-based (people who updated their LinkedIn headline recently) or directory-based with a strong title filter.

Integration-play founders selling apps, plugins, or add-ons. Technographic sourcing (everyone using tool X), role title targeting, high volume since integration plays are numbers games.

Consultants and fractional operators selling into specific verticals. Mix of funding-based and directory-based, tight ICP, small volume, high fit score.

What doesn't work: trying to use this pipeline for top-of-funnel demand gen at massive scale. If you need 100k contacts a week, this isn't your pipeline. For that you need a dedicated data team and a real budget. But if you need 500-2,000 verified contacts a week for a small outbound team, this is the right shape.

What Changes After Setup

Once the pipeline is running, your weekly outbound cycle looks like this:

Monday. Run sourcing query for the week's ICP. Pull raw company list. Split to contacts.

Tuesday. Email discovery and verification. Usually takes 3-6 hours depending on list size. Most of this runs in the background.

Wednesday. AI qualification pass. Review the kill list manually for any false negatives. Adjust the scoring prompt if needed.

Thursday. Dedup, suppress, format, upload to Manyreach. Start the sequence.

Friday. Monitor bounce rate and reply rate from the previous week's send. Adjust next week's sourcing based on what performed.

Your bounce rate after doing this properly should live under 2%. Your reply rate should be 3-5x what you got from scraped lists. Your domain reputation should stay green. Your CRM fills with real conversations instead of "unsubscribe" requests and bounce notifications.

The time investment after the first list drops a lot. Weeks 2 and beyond look more like 2-3 hours total instead of a full weekend, because the tooling is already wired up, the suppression list is already growing, and you're just feeding the machine a new ICP.

Gotchas and Tips

Verify the day you send, not the day you build. Email validity decays about 5% per month. A list that was clean 30 days ago isn't clean today. If you build a list and sit on it, re-verify before you send.

Kill catch-alls ruthlessly. Catch-all domains (where the mail server accepts every email) look "valid" to most verifiers but route most of your sends to a black hole. If MillionVerifier flags a domain as catch-all, kill every contact at that domain. The deliverability hit isn't worth it.

Stay under 200 sends per day per mailbox. Inbox providers start flagging you above 200. If you need more volume, add mailboxes, not volume per mailbox. InboxKit is good for managing this at scale.

Expire lists after 60 days. Job changes, company pivots, email changes. A 2-month-old list is a 2-month-old list. Rebuild it.

Rotate your verification providers. MillionVerifier and Bouncer disagree surprisingly often (we see about 8% disagreement in our internal tests). Running both and killing anything one of them flags is stricter but saves domain reputation.

Suppress your competitors. If you're selling to early-stage founders, you don't want to accidentally email the CEO of a competing tool. They'll screenshot it and post it on X. Add competitor domains to your suppression list on day one.

Don't skip the AI qualification pass. This is the single most skipped step and the single most valuable one. Spending 5 cents per contact to avoid emailing the wrong person is the best ROI in the entire pipeline.

Track per-list metrics, not per-campaign. Bounce rate, reply rate, and positive reply rate should be tracked for every individual list you build. This tells you which sourcing lanes are working and which ICPs are actually real.

Start with the smallest ICP you can stand. A tight ICP produces better reply rates than a wide ICP. If you're not sure, go tighter. You can always expand later. You can't un-send a blast to 5,000 wrong people.

Keep Reading