Delhi Servers and the Lie of Cheap AI

A few weeks ago I was on a call with a guy who wanted to talk about bringing on a closer for his mastermind. Sharp operator. He'd booked 87 meetings in two weeks off email list outreach, had a sales guy closing at around 6%, and was thinking about adding competition to push performance up. Normal agency scaling conversation.

But then he mentioned something almost in passing - something that turned the whole call into a masterclass in a problem most AI-powered outbound operators are sleepwalking into right now.

He told me about the lead generation infrastructure he'd built for his own business. He'd set up a system to process and personalize outreach for 140,000 contacts per month using AI. And he'd gotten the cost down to $0.003 per lead.

On a spreadsheet, that looks like nothing. It's fractions of a penny. It looks like the problem is solved.

It's not.

The Math Nobody Does Until They're Already Bleeding

Let's actually run the numbers, because this is where most growth operators get caught off guard.

At $0.003 per lead, here's what happens as you scale:

• 10,000 leads/month: $30
• 50,000 leads/month: $150
• 100,000 leads/month: $300
• 140,000 leads/month: $420

Four hundred and twenty dollars a month. That's practically free. You're running AI across 140,000 contacts and your variable cost is less than your cell phone bill. Why would you ever change anything?

Here's why: that $0.003 per lead isn't a fixed cost. It's a per-unit API cost. And the moment your volume starts moving, the math gets ugly fast.

He told me that when they started trying to hit real scale - real outbound volume for Galadon - the per-lead cost that looked like nothing was suddenly adding up to tens of thousands of dollars. His exact words: "It doesn't seem that high until you're trying to scale to 140,000 leads, and now you're paying tens of thousands of dollars for that."

That's the cliff. And almost nobody sees it coming until they're already over it.

Why $0.003 Is Actually an Expensive Number

The reason this happens is that most people who are building AI into their outbound stack are using managed API services. You call the API, you get a result, you pay per token or per call. It's frictionless. It's fast. And at low volume, it's cheap enough that you stop thinking about it as a cost at all.

But that pricing model doesn't scale linearly in your favor - it scales linearly against you. Every lead you add costs exactly the same amount. There's no volume discount that actually moves the needle when you're talking about 140,000 records a month. The number just multiplies.

Think about what's actually happening at that volume. Let's say you're doing AI personalization - pulling data, generating a custom line, scoring the lead, writing the first sentence of an email. Even a modest AI task might require several hundred tokens per lead. At 140,000 leads a month, that's tens of millions of tokens. And depending on which model and provider you're using, those tokens add up to real money, fast.

The guy on my call had already done this math - the hard way. He figured out that the only viable path to the volume he needed, at a cost that didn't torch his unit economics, was to stop paying per API call entirely. Get as close to zero marginal cost as possible.

The Self-Hosting Decision

Their solution: stand up their own server, run an open-source model locally, process everything on-premise. No per-token billing. No per-call fees. The compute costs are effectively fixed once the hardware is running.

Specifically, they went with Llama - Meta's open-source model - running on a dedicated server. The processing happens locally. The marginal cost of running one more lead through the system approaches zero.

That's the only math that works at 140,000 leads per month.

Now, is this easy? No. He was straight with me about that. Building your own AI infrastructure isn't a weekend project. He mentioned they had two full-time developers at Galadon working on it. They had to essentially build their own internal LLM pipeline. And it takes time - more time than you want when you're trying to scale fast.

But the economics forced the decision. That's the key point. This wasn't a philosophical choice about open source versus proprietary. It was pure math. Once you're trying to process hundreds of thousands of leads with AI, the API billing model becomes untenable. Full stop.

The Volume Threshold Nobody Talks About

So where's the line? When does the self-hosting conversation actually make sense versus just paying for the API?

The answer depends on what you're doing per lead and which model you're calling. But here's a rough way to think about it:

If your AI task touches 500-1,000 tokens per lead (a realistic number for enrichment and personalization), and you're running any volume worth talking about, your monthly token count climbs into the hundreds of millions. At any standard API pricing, you're looking at a real budget line item - not a rounding error.

The self-hosting route flips the cost structure from variable to fixed. You pay for the server. You pay for the developer time to maintain it. After that, it doesn't matter whether you process 10,000 leads or 10 million - the marginal cost is essentially zero. The infrastructure cost is the same either way.

That's why the decision isn't really about AI. It's about volume thresholds and unit economics. At low volume, APIs win - no setup, no maintenance, instant access. At high volume, the API model destroys your margins and self-hosting becomes the only viable path.

Most growth operators build their AI stack at low volume, where APIs feel free. Then they scale the volume without adjusting the infrastructure. That's the trap.

What This Means for Your Outbound Stack

If you're building AI into your lead generation process - personalization, enrichment, scoring, copy generation - you need to do this math before you need to do this math.

Not after you've already committed to a volume target. Not after your AI bill suddenly looks like a full-time salary. Before.

Here's the actual question to ask: What is my target monthly lead volume, what's my token count per lead, and at what point does self-hosting beat per-API-call pricing?

Run those numbers now. Not when you're already processing 80,000 leads a month and your API bill is threatening your margins.

For most agencies and outbound operators doing serious volume, the answer is going to point toward open-source models on dedicated infrastructure faster than you'd expect. Especially since Meta's Llama models have gotten good enough that the quality gap versus commercial APIs is minimal for most outbound tasks - enrichment, personalization, first-line generation. You're not asking the model to write a novel. You're asking it to turn a job title and company name into a relevant first sentence. Llama can do that.

The Broader Lesson About "Cheap" AI

There's a pattern I see constantly with operators who are building AI into their growth infrastructure: they evaluate cost at proof-of-concept volume and then never revisit the math as they scale.

At 1,000 leads a month, everything looks cheap. At 10,000, it still looks fine. At 50,000, there's a small line item on the bill. At 140,000, you're suddenly writing a check that doesn't make sense for what you're getting.

This isn't unique to AI, by the way. I've seen the same thing happen with lead databases - people start with a per-contact provider, it feels affordable at small scale, and then they want to test five different verticals with 2,000 contacts each and suddenly they're spending $10,000 just to find a campaign that works. That's why for lead sourcing I always point people toward unlimited-download models like ScraperCity's B2B database - same principle: fixed cost, unlimited volume, don't ration your tests.

The variable-cost model that looks friendly at low volume becomes the thing that prevents you from scaling. Whether it's per-contact lead pricing or per-token AI pricing, the math eventually turns on you.

The guy on this call figured it out. He built the infrastructure to fix it. He's got a server in Delhi running Llama locally, two developers maintaining the pipeline, and an SDR working the Clay optimizations to feed the machine. It's not elegant. It took real engineering work. But now the marginal cost of processing another 10,000 leads through their AI system is approximately zero.

That's the only number that actually scales.

Before You Build, Do the Math

If you're running or planning to run serious outbound - we're talking tens of thousands of contacts a month - here's what I'd actually do:

Step one: Calculate your target monthly volume. Not "it would be nice to send to" - the actual number you need to hit your pipeline goals.

Step two: Estimate your per-lead token consumption. Map out every AI task in your workflow and add up the tokens. Be honest about prompt length, response length, and how many times per lead you're hitting the API.

Step three: Price it out at current API rates. Then double the volume. Then triple it. See where the cost curve goes.

Step four: Compare that against the all-in cost of self-hosting - server, developer time, maintenance overhead. Find the crossover point.

If your crossover is at 30,000 leads a month, you should probably be building toward self-hosting right now, while your volume is still low and you have time to do it right. If it's at 500,000 leads a month, you've got runway before you need to worry.

But know the number. Don't run into the cliff in the dark.

The whole point of AI in outbound is to make personalization and targeting scalable without scaling the cost proportionally. If you're running a per-unit billing model at high volume, you've negated that entire advantage. You've built a machine that gets more expensive exactly as it gets more useful.

That's not a technology problem. That's a math problem. And unlike most problems in sales and growth, this one has a clean answer - if you do the arithmetic before you need to.

If you want to go deeper on building an outbound system that actually scales - the lead sourcing, the infrastructure decisions, the sequencing - the Best Lead Strategy Guide covers the full framework. And if you're building a lead database that can actually feed a system at this volume without per-contact fees eating your margins, that's the place to start.

Scale the machine. Just know what it costs to run it first.