How I'd Build a B2B Demand Engine on a Startup Budget

I have spent the better part of a decade in B2B growth, and for most of it I was running demand gen inside big companies with the budgets to match. You work differently there. You reach for the most powerful tool on the market, or whatever the whole industry has standardized on, almost on reflex, because the software bill is a rounding error next to ad spend and salaries. When a tool could not do something, nobody in the room flinched at the answer: we need another tool.

That reflex falls apart the moment the budget is small. Since I moved into fractional work I have spent far more time with bootstrapped startups and lean scale-ups, and they choose a stack completely differently: every tool has to justify its price, and value beats brand name every single time. Then I built the demand system for my own company, Smartify Marketing, and the lesson landed even harder, because now it was my money on the line. So I started keeping a shortlist of tools that genuinely punch above their price, the ones I would actually build a demand engine on when money is tight. That is what this is. The philosophy underneath it never changes: spend where it counts, save where it doesn't, and never pay to look impressive before you have proven the thing even works.

Here is what moving between those two worlds taught me: the logic of a demand engine does not change with the budget. The enterprise version I used to run and the lean version below pick the same accounts, engage them by priority, convert them, and keep a loop running so each round gets smarter. Only the parts cost different money. So here is how I assemble each one when cash is tight but I still don't want to rip the whole thing out in a year.

Step 1: Pick the accounts worth chasing

At a big company you can afford to be a little unfocused; the budget papers over it. On a lean one, focus is the whole game, because you genuinely cannot afford to spray and pray. So before any tool, the discipline: I score a target list on two questions, and I keep it to two on purpose. Every time I have watched someone build a 14-variable scoring model, it optimized the appearance of the deck while booked meetings stayed exactly where they were.

First, do they even have the problem I solve? For most B2B products that is a fit question you can answer from a company's tech stack. Wappalyzer is free and tells you what a company runs under the hood; BuiltWith goes deeper. If my product only matters to companies on Shopify, I can detect that at scale instead of guessing, which is exactly the kind of free leverage a small team should grab with both hands.

Second, how big is the problem for them? Company size is a crude but honest proxy for what they'd pay. Apollo.io's free tier gives you enough B2B data to band accounts by headcount and industry without signing anything, and when you need the actual email, both Apollo and Hunter.io have free allowances.

Now, a confession about the shiny option. Clay is gorgeous, and I genuinely love it. But its paid plans climb fast, and I have watched a bootstrapped team burn most of a month's runway on credits chasing a list they honestly could have built by hand. Use Clay's free tier to learn the workflow. Build the foundation after the team has proved it needs the scale. The output of this step is a short, ranked list of the few hundred accounts that genuinely fit. Thousands of loosely matched names only create more outreach to ignore.

Step 2: Read the signals that say "now"

A good list tells you who to talk to. Signals tell you when. And this is the exact spot where I see small teams either freeze, or overspend, when the cheap move is sitting right in front of them.

Start with the signals you already own. Behavior on your own site and product is free, and it is the most reliable thing you will ever get. Someone camped on your pricing page, back for a third visit this week, or starting a trial is telling you more than any feed you could buy. The strongest signals are the ones closest to a buying decision: a pricing-page visit beats a blog read, a repeat visit beats a first-timer, a signup beats them all.

There is a whole industry that will happily sell you intent data, and the temptation, the same reflex I had at bigger companies, is to buy your way to confidence. Resist it at the start. I have never once regretted leaning on first-party signals first, and I have definitely regretted a couple of intent-data contracts I signed before I'd earned them. Apollo.io adds a light layer of third-party intent on its free tier, which is plenty to begin with. Paid website-visitor identification (tools like Dealfront sit around $99 a month) is a perfectly good thing to add later, once you actually have the volume to act on it. The rule I live by: signal quality beats signal volume, every time.

Step 3: Spend your effort where the intent is

Now engage in tiers. Equal treatment is the most expensive mistake I see bootstrapped teams make: a whole week disappears into accounts that were never going to buy this quarter.

For the whole list, keep it cheap and light: useful content and a bit of retargeting, almost no time per account. For the accounts showing signals, run real sequences. Waalaxy is where I'd start testing LinkedIn as a channel. I pay for outreach automation once the manual work begins consuming the week, because that is a clear exchange of money for time. The email side can start on the free allowances from Brevo, Sender, or Snov.io. Check the current limits before building the workflow around one of them; free-plan allowances change much faster than the demand strategy does.

Then there's the handful of high-intent accounts, the ones genuinely raising a hand. This is where you stop being frugal with your time. Personal outreach, and a landing page built for them. Carrd spins up a clean one-page site for free; it has no native forms, but drop a Tally form into it and you've got a tailored, tracked landing page for nothing. Here's the part I want you to sit with: a custom page plus a real human reaching out is the same "personalized experience" that enterprise teams pay platforms five figures to orchestrate. You're doing it by hand, for free, for the ten accounts where it actually decides the deal. There is nothing cheap about that move; you are spending scarce time exactly where it pays back.

Step 4: Capture and nurture

Every play above has to point at something that catches the interest and follows up, or your effort just leaks out the bottom. Tally takes the signup, Brevo runs the nurture. A complete capture-to-nurture loop on free plans, and it works the same whether the lead came from a cold LinkedIn note or a retargeting ad. Nothing fancy. It just has to exist, because the leak here is the most expensive one and nobody notices it until the quarter is over.

Step 5: One view, and a clean handoff to sales

This is the step where I'll tell you to actually spend, eventually, and mean it. Because the thing that turns a pile of tools into an engine is that everything lands in one place. Enterprise teams call it a single source of truth. Done right it makes the whole machine work; done wrong it quietly rots back into a graveyard of spreadsheets, and I have watched that kill more "demand engines" than any budget ever did.

For a startup I would reach for Attio, which might not be the name you expect. The main reason is its flexible data model: you can make "account" a first-class object and hang every signal, contact, and touch off it. That is precisely what a signal-based engine needs.

Its free plan is enough to test the model with a small team. When the team and signal volume grow, this is one of the first places I would consider paying, because a clean account view saves more time and confusion than another campaign tool. Check Attio's current limits and per-user price when you compare it; those details can change while the data-model decision stays the same.

The all-in-one alternative is HubSpot's free CRM, if you'd rather have marketing and sales under one roof. New accounts now face a much lower free contact ceiling than they once did, and marketing contacts are priced separately as the program grows. If your pipeline is LinkedIn-led and relationship-driven, Folk is a third option worth testing. Whatever you pick, please don't try to run account management out of Notion docs. I know the scrappy instinct, but it does not hold up once several people and signals need the same record.

One more honest note, this time about saving. To get signals into that single view without copy-pasting your life away, Activepieces is open-source and free to self-host, and I love it for that. Self-hosting still carries a time cost. If nobody on your team wants to babysit a server, use a hosted option before a broken deployment takes your Saturday. Compare the total cost, including maintenance time.

Step 6: Close the loop

The last step is the one that turns a campaign into an engine, and it's the one no budget can buy for you. Every play throws off signals; every signal that becomes a meeting is quietly telling you who to chase next. So look closely: which accounts converted, which signals predicted it, which plays did the work. Then feed it straight back into Step 1. Tighten the list, drop the signals that predicted nothing, lean into the ones that did.

The expensive stacks skip this constantly, and it's the cheapest improvement you'll ever make. A real feedback loop is the difference between an engine that compounds and a string of one-off campaigns that just tire your team out.

Build the cheap version first

None of this needs a platform demo or an annual contract to get going. The expensive ABM machines you read about, the ones doubling deal sizes and tripling revenue, are running this exact logic with pricier parts. The logic is free. The discipline is what makes it work: focus on the right accounts, trust your first-party signals, keep one clean view, and close the loop.

So build the cheap version first. Prove the engine runs with your own hands. Then spend deliberately on the few parts where money buys speed or sanity. Bootstrapping well means knowing exactly what each dollar is buying.