The 1.5% Bounce Blueprint

(the data-validation waterfall behind 250,000+ managed inboxes: how to wash any raw list down to the ~75% that's safe to send, keep bounces under 1.5%, and stop torching domains you paid to warm up)

Before You Rewrite That Cold Email Again

you've rewritten the same cold email five times.

you gave it a sharper hook and a completely different offer, and the reply rate still hasn't moved.

so you assume the copy isn't good enough yet, and you sit down to write version six.

mate, i've watched this exact scene play out on hundreds of audit calls. 9 times out of 10 the person is convinced it's a copy problem. it almost NEVER is.

your reply rate is buried under a dirty list. invalid addresses that bounce on contact, and spam traps you never knew you'd bought. every bounce chips away at your domain reputation, and once that reputation drops, even a perfect email lands in spam.

i've set up cold email infrastructure over 2,000 times in the last 12 months, and we manage roughly 250,000 mailboxes. the single biggest killer i see is the data going into the top of the system.

so this is the exact list-cleaning system i run on audit calls before i'll let anyone scale a campaign.

here's what you'll walk away with:

  1. a 60-second check that tells you whether your problem is the data or the copy (most people get this wrong)
  2. the validation waterfall i run on every raw list, tool by tool
  3. the 75% wash-rate rule that tells you when your verifier is lying to you
  4. a routing map that sends verified, catch-all and risky contacts to the right place
  5. a clean-before-you-send pre-flight checklist you run before every campaign

this is NOT a 40-page course. it's a system you can run on your next list in under 10 minutes.

read it, then go wash a list.

The 60-Second Wash-Rate Check

here's a 60-second gut-check before you touch the copy again.

pull up your last campaign and tick every statement that's true. give yourself one point each:

  • ☐ you ran your list through a dedicated verifier before sending (not the sequencer's built-in "validation")
  • ☐ your bounce rate is under 1.5%
  • ☐ you pulled the data less than a week before you sent to it
  • ☐ you separated catch-all addresses into their own campaign
  • ☐ you already know your list's clean rate as a hard number

now add up your ticks. score 0 or 1 and the data is almost certainly your problem, so run the validation waterfall next and don't rewrite another email until the list is washed. land on 2 or 3 and the basics are there but wastage is dragging your average down, which the 75% rule will find. hit 4 or 5 and your hygiene is solid, so lock it in with the pre-flight checklist and then go look at your offer.

one thing i say on every call: a rising bounce rate is only the first sign, and the real damage lands on your domain reputation, which you don't see until your sends stop arriving. Apollo's raw data runs anywhere from 50% to 65% valid, so if you send to it unwashed, half your emails are torching the reputation that decides whether the other half even arrive.

so get your clean rate healthy, then send.

Why Your Spam Problem Is a Data Problem

here's what the last six weeks looked like for most people reading this.

reply rate started at 3-4%, slowly slid to 1%, then went sub-1%. so you rewrote the copy, changed the angle, swapped the sender name, and still nothing moved. somewhere in there a chunk of your domains started landing in spam, and you had ZERO idea why.

i'll tell you why, because i diagnose this every single day. you were sending to a list full of dead addresses. every invalid contact bounces, and every bounce tells Google and Microsoft you don't know who you're emailing. do that at volume and they stop trusting your domain, so they start binning your sends. that is what non-validation of data does to you.

the line i use on every audit call: "wastage is the biggest killer for any bucket. the holes are often leaking faster than the taps going in."

it doesn't matter how many leads you pour in the top if most of them leak straight back out as bounces. one customer i looked at recently had 94% of their list sitting there unverified. they were convinced deliverability was broken, but it was fine. the list was the problem.

so the answer is boring. you wash the list before it ever touches your inboxes, because no clever copy trick fixes dirty data.

by the end of this system you'll have a repeatable wash you run on every list, a wash-rate number you can actually trust, and a routing map that keeps the risky contacts away from your good domains.

what's inside:

  • the validation waterfall: pull every source, then enrich and verify it across multiple tools
  • the 75% wash-rate rule, and why 95% clean is a red flag rather than a green one
  • the verified / catch-all / risky routing map
  • a pre-flight checklist so no unwashed list ever gets sent again

Run the Validation Waterfall

every clean list gets washed before it earns a send. that wash is the whole waterfall.

the point is to control the one variable that kills more campaigns than anything else: does the address on the other end actually exist? here's the flow i run, source by source.

the validation waterfall (filled example):

1) PULL. export your raw contacts from wherever they live. Apollo for general contact data, Sales Navigator for job-change and hiring signals. if your contacts are LinkedIn profiles with no email attached, push them through Find Email first (50,000 credits is around $500).

2) ENRICH. running Apollo? you can export it cheaply through Boomerang.co, roughly $50 to pull 40,000 people, while keeping your base Apollo sub. this is where you fill in the missing work emails.

3) VERIFY. every single address goes through a dedicated verifier before it goes anywhere near an inbox. i trust Million Verifier or Reoon for this. never lean on your sequencer's built-in "validation" as the source of truth.

4) CROSS-CHECK. almost nobody runs this step. if your verifier hands back 90-95% clean, it's lying to you, so run the same list through a second tool. good data comes back around 75% clean.

5) SORT THE OUTPUT. your verifier grades every contact by risk into three buckets, and those buckets never get treated the same. chapter 3 covers exactly where each one goes.

your turn (10 minutes):

take your next raw list and walk it through the waterfall. write down the number that survives each stage:

  • ☐ raw contacts pulled: ___
  • ☐ enriched with missing emails: ___
  • ☐ run through verifier #1: ___ clean
  • ☐ cross-checked on verifier #2 (only if #1 said 90%+): ___ clean
  • ☐ sorted into verified / catch-all / risky: ___ / ___ / ___

if you can't fill in the "run through verifier" line, that's your answer. your list has never been washed, and that's exactly where your reply rate went.

Apply the 75% Wash-Rate Rule

once you've run a list through a verifier, you get a number back.

that number is the percentage that came back clean, and it tells you more than any placement test ever will. it's your wash rate, and the rule is simple. across every database i've ever audited, a healthy raw list washes down to around 75% clean. Apollo's raw data comes in lower, 50% to 65% valid, because it's broad. a well-maintained source that revalidates every few days (AIArc revalidates every 3 days) sits nearer the top of that band.

here's the counter-intuitive part. if a verifier tells you your list is 90-95% clean, that is NOT good news, because it means the tool isn't catching what it should. a properly verified raw list doesn't come back at 95%. when you see that number, run the list through a different verifier, and one of the other tools will hand you the truth.

the wash-rate worksheet (filled example):

say you pull 10,000 raw contacts and run them through your verifier. a healthy result looks like this:

  • raw list: 10,000
  • verified (safe to send): 7,500
  • catch-all (send, but isolate): 1,500
  • risky / invalid (bin these): 1,000
  • wash rate: 7,500 ÷ 10,000 = 75% clean

75% sits right in the healthy band. if that same list had come back showing 9,500 verified, i wouldn't celebrate, i'd re-run it, because a 95% wash rate on a raw pull is a broken verifier doing a lazy job.

your turn (5 minutes):

fill in your own numbers and do the division:

  • ☐ raw list size: ___
  • ☐ verified count: ___
  • ☐ catch-all count: ___
  • ☐ risky / invalid count: ___
  • ☐ wash rate (verified ÷ raw × 100): ___%

now read your number. under 60% means your source is poor, so change where you're buying data. 60-80% is healthy, so proceed. over 90% means your verifier is wrong, so re-run it on a second tool before you send a single email.

Route Every Contact Before You Send

washing the list gives you three piles.

the fastest way to undo all that work is to dump them back into one campaign and hit send. every pile behaves differently, so every pile gets sent differently.

the routing map:

verified contacts are your clean, confirmed addresses. they go into your primary campaign on your best-warmed domains. this is where your volume lives.

catch-all contacts got accepted by the server, but the mailbox was never confirmed. they're usable, but risky in bulk, because catch-alls can spike your bounce rate and pause a whole campaign. isolate them in their own campaign, on separate domains, so a misbehaving batch can't drag down your verified sends.

risky and invalid contacts get binned, and never sent to, because these are the addresses that bounce, and bounces are exactly what torches your domain reputation. one poor lead source with a high bounce rate is a lead-level problem, and it follows you into every future campaign if you let it through.

on top of that, split your sends by the recipient's provider. run Google-to-Google separately from Google-to-Microsoft. a dead segment hiding inside a blended campaign will drag a 4% reply rate down to 2%, and you'll wrongly decide 2% is just the ceiling.

the clean-before-you-send pre-flight (run this before every send):

  • ☐ list run through a dedicated verifier before it hits the sequencer
  • ☐ cross-checked on a second tool if the first said 90%+ clean
  • ☐ wash rate calculated and sitting in the 60-80% band
  • ☐ catch-alls pulled into a separate, isolated campaign
  • ☐ risky and invalid contacts deleted, not "kept just in case"
  • ☐ verified contacts split by recipient provider (Google vs Microsoft)
  • ☐ projected bounce rate under 1.5%

if every box is ticked, send. if one isn't, you already know where your next spam problem is coming from.

The List Wash Cheat Sheet

screenshot this page and keep it next to your sequencer. you run it top to bottom before every campaign:

  1. pull your raw data (Apollo, Sales Navigator, Find Email for LinkedIn-only contacts)
  2. enrich the missing emails (a Boomerang.co export keeps Apollo cheap)
  3. verify every address on a dedicated tool (Million Verifier / Reoon / OmniVerifier)
  4. cross-check on a second tool if the first says 90%+ clean
  5. calculate your wash rate (verified ÷ raw)
  6. route verified contacts to your primary campaign, catch-alls to an isolated one
  7. delete every risky and invalid address, then split your verified sends by recipient provider

then keep these numbers pinned in your head as you go:

  • wash rate: a healthy raw list lands around 75% clean, and anything over 90% means a broken verifier.
  • Apollo raw data: it runs 50-65% valid, so sending to it unwashed is the leak you keep paying for.
  • bounce rate: your ceiling is one and a half percent. the moment it climbs past 2%, you pause and re-verify.
  • data freshness: verify within 3 days of sending, because weeks-old data drifts and starts bouncing.
  • catch-alls: they ride in their own isolated campaign, never mixed into your verified sends.

the one rule to remember is this: if a verifier says your raw list is 95% clean, it's wrong, and good data washes down to about 75%. skipping the wash gets expensive fast. list cleaning runs about $200, but a flagged domain takes 3-6 months of ESP trust to rebuild. one founder i know delayed his cleaning to save budget and lost a $50,000 deal to a competitor whose email actually arrived.

so wash the list before you write a single line.

Want This Done For You?

at this point you've got the full wash.

the validation waterfall, the 75% rule, the routing map, and a pre-flight you run before every send. run it, and your bounce rate drops and your domains last a lot longer.

here's what this system can't do for you.

it can't pull and verify a fresh list for you every week. it can't monitor 250,000 inboxes and rebuild the ones that start slipping before your reply rate ever shows it. and it can't sit on a live audit with you when the data looks clean but something is still off.

we handle that part at Premium Inboxes. client-owned, fully compliant Google and Microsoft infrastructure, set up properly, with same-day support and a real human on the other end when something breaks.

so if your list is washed but your inboxes still aren't landing, then you've got an infrastructure problem, and it's the one i solve every day.

want me to look at yours? reply and i'll book you in.

Home

Why Us

Pricing

Contact

Testimonials

Affiliates

Resources

API

Sign In

Get Started