What 44,000 Leads Actually Gets You

The Spreadsheet That Looked Like 44,000 Opportunities

He opened his screen share on a coaching call and showed me a spreadsheet. "44,000 leads," he said. You could hear the optimism in it. He'd spent weeks building this pipeline - pulling tech stack data from BuiltWith, writing Clay workflows to enrich it, testing email finders. He had a system. He had a plan. He had 44,000 rows.

And then we started running the actual math.

What followed was one of those conversations that reframes how you think about outbound lead generation entirely. Not because anything was broken. Not because the tools were bad. But because nobody had stress-tested the funnel math before building the pipeline - and when we finally ran the numbers together, the picture looked nothing like what the raw file suggested.

This is a breakdown of exactly what happened, what the numbers actually looked like at each step, and what the architecture problem really was. If you're building outbound campaigns sourced from tech stack data, intent signals, or any multi-step enrichment chain - run your own version of this math before you commit.

Step 1: 44,000 Leads Become 8,800

The leads came from BuiltWith - a tech stack intelligence platform that lets you find companies using specific software. The targeting logic was sound: identify companies that had used a particular type of tool, reach out to the decision makers, and pitch a solution. Real buyer intent. Not cold targeting by job title and hope.

The raw file: 44,000 companies.

The first enrichment step was finding the actual decision makers at those companies - not just anyone there, but the specific person in the role they were targeting. Running that through a Clay workflow gave a hit rate of roughly 20%.

44,000 companies → 8,800 decision makers found.

That's a painful drop-off, but not unusual. Tech stack data gives you the company. Finding the specific decision maker inside that company is a separate operation. A 20% hit rate for a specific job function is actually on the higher end for this kind of targeting. Some lists come back at 10% or lower.

Still: 8,800 people is a lot of people. If you could email all 8,800, you'd have a campaign. Except they didn't have email addresses yet. They had names and company domains. Which brings us to step two.

Step 2: 8,800 Decision Makers Become 361 Emails

Finding an email address requires two inputs: a full name and a domain. They now had both. So they ran those 8,800 records through an email finder.

On the first test file, the email find rate came back at 40%. That's 3,500 emails from 8,800 decision maker records. Painful but workable - 3,500 targeted contacts with verified emails is a real campaign.

Then they ran the second test file. Same size. Same process. Different result.

The email find rate came back at 3%.

On a file where they'd found 12,000 decision makers, they got 361 emails.

Three percent.

That's what 44,000 leads actually gets you. Not 44,000 shots. Not even 8,800. On a bad day: 361 people you can actually send an email to. On a good day, maybe 3,500 - but that swing from 3% to 40% on essentially similar data tells you the email find rate is wildly inconsistent. You cannot plan a campaign around the optimistic number.

The Cost That Killed It Before It Started

Here's where it got really messy. Because those numbers above are just what you get from the pipeline. We haven't talked about what it costs to get there.

The BuiltWith list of 44,000 was just one slice of a much larger universe. To build a real campaign at scale, he estimated they'd need to process around 600,000 leads through the decision-maker-finding step - because at a 20-30% hit rate, you need a large input to get a workable output.

He showed me the calculation. At a 20% decision maker hit rate, you need 600,000 Clay runs to get 120,000 decision maker records. At 30%, you need 400,000 runs. The estimated cost for that step alone - just for finding the decision maker names, not the emails - was $1,500 to $2,200.

And that's before you pay for email enrichment on top of it.

So the fully-loaded cost of this pipeline, just to arrive at a list of contactable people, was running into multiple thousands of dollars. For a few hundred verified email addresses.

"I stopped all the Clay agents," he told me. "The math is messed up."

It was. But the problem wasn't Clay. It wasn't BuiltWith. It wasn't the email finders. The problem was the pipeline architecture itself.

The Architecture Problem Nobody Maps Out First

Look at what this pipeline actually required:

• Pull raw domains from BuiltWith (the tech stack signal)
• For each domain, identify the relevant decision maker name via Clay enrichment
• For each decision maker name and domain pair, find the email address via email finder
• Verify that the emails are live and deliverable
• Send

That's four conversion events before a single email goes out. And each one has a significant drop-off rate. When you chain a 20% hit rate at step one, then a 3-40% email find rate at step two, then a deliverability filter at step three - the compounding math is unforgiving. You end up with a fraction of a fraction of a fraction.

The fix isn't a better email finder. It's not a cheaper Clay workflow. It's a different starting point.

What this pipeline really needed was a source that already has the decision maker AND the verified email in the same record - so instead of building a contact from scratch across four steps, you're filtering an existing database down to your ICP. That's a completely different operation, and the math looks completely different.

For tech stack targeting specifically, the architecture that actually works is:

1. Get your target domain list from BuiltWith (for the tech signal you care about)
2. Take that domain list and cross-reference it against a B2B database that already has contacts
3. Pull only the records where you get decision maker plus verified email together
4. Verify and send

You're still using BuiltWith's specificity. But you're avoiding the from-scratch enrichment chain. The domain list becomes a filter, not a starting point for a multi-step build. The difference in cost and output is significant.

Tools like the ScraperCity B2B database or Apollo let you import a domain list and pull contacts that already exist - filtering instead of enriching from scratch. The email finder works best when you're running it against a short, pre-filtered list, not as the last step in a 600,000-row enrichment chain.

A Question He Didn't Want to Hear

Even if this pipeline worked perfectly - even if the email find rate was consistently 40% instead of 3%, even if the Clay costs came down - I needed to push on something else.

Were these leads actually going to buy?

The targeting logic was: companies that had used a specific live chat software had already demonstrated they buy in that category. That's real buyer intent. Good signal.

Except BuiltWith's data tells you what technology a company has used. Not necessarily what they're running right now.

I pulled up one of the companies from his list during the call - a large, well-known business. He'd included them because they'd been recorded as a live chat software user. I checked their website live. No live chat anywhere on the site.

The data was stale.

So you're potentially spending thousands of dollars on enrichment, grinding through a 3% email find rate, to reach people at companies that no longer have the problem you're solving. That's not a knock on BuiltWith - every data source has stale records. But it means lead freshness needs to be a filter you apply early in the pipeline, not something you discover after you've already done all the enrichment work.

A simple check: pull a sample of 100 companies from your BuiltWith list and manually verify that the technology is still active on their site. If you're seeing more than 20-30% stale records in your sample, the list needs a validation step before you invest in enrichment at scale.

Why Big Lists Create False Confidence

44,000 leads feels like a lot. It's not. It's a number that could represent a lot - or could represent 361 actual contacts, depending on how the enrichment math plays out.

The psychological trap is that the big raw number creates confidence before you've earned it. You feel like you have inventory. You start planning campaign messages before you've validated what the list actually becomes after enrichment.

This connects to something I've talked about before in the context of testing. The reason cost-per-contact matters so much is that you need volume to find winners. If you're spending $2,200 just to enrich a list before you've sent a single email, you're locked into one hypothesis. One message. One target segment. If it doesn't work, you've burned your budget and you have no useful data on why.

The alternative is to test with enough volume that you actually get signal. If you can pull contacts for five different ICPs without worrying about per-contact enrichment costs, you'll find a winning campaign in a few weeks. If every test requires a major upfront enrichment spend, you'll never get enough reps to know what's actually working.

That's why I keep coming back to the same point about lead sourcing: the best lead strategy isn't always the most sophisticated one. Sometimes it's the one that gets you to enough testable volume, fast enough and cheap enough, to find the message that converts. The 7-Figure Agency Blueprint covers this from the ground up - how to think about list building and ICP selection before you ever open a tool.

The Pre-Flight Checklist Before You Build a Pipeline

What I walked him through at the end of this call was essentially a stress test for outbound pipeline math. Five questions you need to answer before you commit to an enrichment architecture:

1. What's my realistic hit rate at each enrichment step?
Not the vendor pitch number. Not the best-case scenario from the tool's marketing page. The actual rate you'll get on your specific target, with your specific data source. For tech stack data and niche job function targeting, 20% decision maker hit rate is a reasonable baseline. For broader targeting with a purpose-built B2B database, you might see 60-70%. Know your real number before you build.

2. What's my email find rate given those decision maker records?
This is where most pipelines collapse. Email find rates vary enormously depending on industry, company size, seniority level, and data source quality. His range was 3% to 40% on essentially similar data. Before you commit to a pipeline architecture, run a sample test on 500-1,000 records and measure the actual rate. Do not scale until you have this number from a real test.

3. What's the fully-loaded enrichment cost at my target volume?
Run the math before you build. If you need 600,000 Clay runs to get enough records in the funnel, calculate the actual cost. If that number exceeds what you'd pay for a filtered list from a B2B database that already has the emails, you have your answer. This is a math problem, not a tool preference question.

4. Is the data fresh enough to act on?
Tech stack data, intent signals, job title data - it all goes stale. Sample 100 records before you enrich at scale. If more than 20-30% of the sample companies no longer show the signal you're targeting, the list needs a freshness filter before you spend on enrichment.

5. What's my cost per contactable lead?
Total enrichment cost divided by the number of verified, deliverable email addresses. That is your real cost per lead. Not the per-record cost from the data vendor. Not the credits-per-run in Clay. The end-to-end cost to get one person into your inbox. If you can't answer this question before you build, you don't yet know whether the pipeline makes economic sense.

What Good Tech Stack Targeting Actually Looks Like

I'm not saying don't use tech stack targeting. It's one of the strongest signals in outbound - knowing a company uses your competitor's product, or recently adopted a tool in your category, is real buyer intent data. Use it.

But use it in an architecture that doesn't require a four-step enrichment chain to reach an email address.

Use a B2B database with tech filtering built in. Apollo lets you filter by technology stack and export decision maker contacts directly - name and email in one query, without a separate enrichment step. The tech coverage isn't as deep as BuiltWith for obscure or niche software, but for most common B2B tools it's sufficient to get started without building a custom pipeline from scratch.

Use BuiltWith as a filter layer, not a source layer. Export your BuiltWith domain list, then upload it to a B2B database that lets you filter against its existing contacts. You're leveraging BuiltWith's specificity for the tech signal but getting contacts from a source that already has verified emails. The enrichment chain collapses from four steps to one.

Run the email find rate test on 500 records before scaling. This is the step he skipped - and it would have surfaced the 3% problem before he built the entire workflow. A sample test on 500 records costs almost nothing. It will tell you whether the full pipeline is worth building.

Verify late, not throughout. Don't run email verification on every record as you enrich. Filter your list down first, then verify only the records you're actually going to send to. Running Findymail on 600,000 records you'll ultimately cut to 50,000 is pure wasted spend. Verify the final list, not the work-in-progress.

The Math Always Wins

44,000 leads. 8,800 decision makers. 361 emails. That's the funnel. That's the actual output of weeks of work and a sophisticated multi-tool pipeline.

The tools weren't the problem. The strategy wasn't wrong in concept. The problem was that nobody ran this math at the start. Nobody asked: if our decision maker hit rate is 20% and our email find rate is 3%, how many contactable people do we end up with, and what does it cost to get there?

I've generated over $100 million with cold email. The core logic has been consistent throughout: find people who have the problem you solve, get to their inbox by the shortest path available, send something that isn't generic. Everything else is implementation detail. But the implementation details matter - and when the math on a pipeline says you're spending $2,200 to get 361 emails, you don't optimize the pipeline. You redesign the architecture.

If your outbound model has never been stress-tested against a 3% email find rate, it hasn't been stress-tested. Build that test into your process before you scale. Know your cost per contactable lead before you commit to a source. And if the math doesn't work on paper at your expected conversion rates, no amount of clever tooling will fix it in the field.

If you want to work through this kind of funnel math on your specific setup - what sources make sense for your ICP, what architecture gets you to a contactable list most efficiently, what the campaign structure should look like - that's what we do in Galadon Gold. Real calls, real numbers, real feedback on what you're building before you spend money finding out the hard way.

And if you need a starting point for lead sources that skip the enrichment chain, the ScraperCity B2B database is worth checking against your ICP first. Then grab the Top 5 Cold Email Scripts - because when you do get those 361 emails, you want to be sending something worth opening.

The math always wins. Build pipelines that respect it.