Devtool: ditched the SDR team and went founder-led on outbound

The situation

The client was a Series A devtools company — CI/CD observability for engineering teams. ~18 employees, two SDRs + one sales manager inherited from a previous go-to-market motion their lead investor had pushed them to hire.

The SDR motion wasn’t working. Numbers at the start of engagement:

• Combined SDR send volume: ~3,400 outbound emails per week
• Positive reply rate: 0.7%
• Meetings booked per month: ~14
• Cost: $34k/month all-in (salaries + tooling + management time)
• Cost per booked meeting: ~$2,400
• Meeting-to-opportunity conversion: ~30%
• Meeting-to-closed-won: ~9%

The founder (a technical founder, former staff engineer) had genuine domain credibility in the space. He’d built the product. He could speak to any customer’s problem in five minutes and usually solve it. But he didn’t do any outbound — the SDR team did, and they were 9 months in with diminishing returns.

The trigger for the engagement: the lead investor had told the founder “double down or shut it down” on outbound. The founder’s instinct was to shut it down. My pitch was narrower: shut down the current motion, which was misconfigured, and test whether a founder-led variant would work before giving up on outbound entirely.

Why the SDR motion wasn’t working

Two weeks of audit surfaced the same failure pattern I’ve seen in 10+ devtools companies:

1. The emails were generic because the SDRs couldn’t be specific

Each SDR was sending ~850 emails/week against a list of engineering leaders. The opener referenced “your engineering team’s CI/CD workflows” in various paraphrases. The value prop mentioned “reduce pipeline debugging time.”

The problem: every CI/CD observability product says this. Every single one. The SDRs weren’t bad — they literally couldn’t say anything more specific, because they didn’t have the depth to know what makes this product different for this prospect. The founder did. But he wasn’t writing the emails.

2. The CTA was a demo, which is too big an ask

“Book a 30-minute demo to see how we help engineering teams like yours” is the standard CTA. It assumes the prospect has a problem they’ve already identified, is actively shopping, and wants to see vendor pitches. Most prospects don’t.

A founder can offer something the SDR can’t: “I’ll send you a 4-minute loom walking through [specific thing], because I think you’ll find [specific observation] worth 4 minutes.” That’s not a demo ask. It’s a value-first touch. Prospects respond to it 3–5x more often.

3. The segment was too broad

SDRs were sending into any company with 50+ engineers. The founder’s best customers (from manual inspection of the first 14 closed-won deals) were engineering orgs with 80–400 engineers running microservices on Kubernetes with Jenkins or CircleCI in the critical path. That’s a meaningful narrowing.

Why hadn’t the SDR team narrowed? Because they couldn’t reliably identify Kubernetes-using Jenkins/CircleCI shops from an Apollo search. It required scraping BuiltWith + GitHub signals + LinkedIn keyword searches. Nobody had built that list.

The restructure

Week 1 conversation with the founder + investor resulted in the following decisions:

• SDR team laid off (with severance) within 3 weeks. Not a pleasant conversation.
• Sales manager shifted to AE role covering the existing pipeline.
• Founder committed to 6 hours/week on outbound — specifically, writing and personally sending emails, not just reviewing SDR work.
• I took over list building, infrastructure, sequencing, and reply ops for the engagement duration.

The financial math: $34k/month → $9k/month (my engagement + tooling + the founder’s opportunity cost of 6 hours/week, conservatively valued at $350/hour).

That was the test. If we could produce equal-or-better meeting volume at $9k/month, the devtools outbound motion wasn’t dead — it was just misconfigured.

Month 1 — Infrastructure and list

Infrastructure setup, basically the standard stack:

• Two sending domains (one primary, one lookalike), warmed over 3 weeks.
• DMARC at p=reject on both.
• Instantly for orchestration.
• Clay + Apollo + BuiltWith + GitHub API for the ICP-specific list build.

List build was the hardest part. Built an enrichment pipeline that:

1. Pulled companies with 80–400 engineers (via Apollo’s engineering-team-size field + LinkedIn employee count cross-reference).
2. Filtered for companies using Kubernetes (via BuiltWith + scraped job postings mentioning K8s).
3. Filtered for CI systems in {Jenkins, CircleCI, GitLab CI} (via job-posting scrape for tool names + public GitHub repo inspection).
4. Identified engineering leadership (VP Eng, Director of Engineering, Head of Platform, Staff Engineer with platform focus).
5. Scored by recency signals: recent engineering hires, recent deployment/incident blog posts, recent Kubernetes config commits.

Final list: 480 target companies. Small. Focused. Every row had a specific reason to be on the list.

Month 2 — Founder-led email design

This is where the founder’s time investment actually mattered. We set up a weekly rhythm:

• Monday 9–10am: founder reviews the week’s list (40–60 companies max).
• Monday 10–11am: founder writes 4 opener/bridge variants per 10 companies, riffing on specific details of each company’s stack or recent activity.
• Tuesday–Friday: I handle sending cadence, follow-ups, reply routing.
• Friday 2–3pm: founder reviews the week’s replies, handles the substantive ones personally.

The emails themselves were much shorter than the previous SDR emails and dramatically more specific:

[First name] —

Saw your team is running Jenkins + K8s at [company] scale. The pain I'd
expect at your stage is [specific observation about the stack].
We fixed exactly that for [named customer with similar stack]. 3-line
version of how, if useful: [link to 4-min loom].

Not asking for a meeting. Happy to answer questions by reply if any.

— [founder name]
[founder title]

Three things worked about this:

1. Founder credibility. Signed by the founder, titled “CEO, ex-staff engineer at [well-known company],” links to a loom the founder actually recorded. Prospects could tell.
2. Value-first CTA. “Not asking for a meeting” is counter-intuitive. It raised reply rates because it removed the pressure.
3. Specificity. Every email named the prospect’s actual stack. The SDR emails never had.

Month 3 — Steady state

By week 10, the numbers:

• Sends per week: ~210 (way down from 3,400)
• Positive reply rate: 7.8%
• Meetings booked per month: ~31 (vs. 14 before)
• Meeting-to-opportunity conversion: 48% (vs. 30%)
• Meeting-to-closed-won: 22% (vs. 9%)

The closed-won lift was the unexpected number. Why it happened:

• Meetings started warmer. Prospects had already watched a 4-minute loom from the founder before the call. They arrived at the meeting already half-qualified.
• Founder was still in the first meeting. Prospects who engaged founder-to-founder moved faster than prospects who had to be “handed off” from SDR to AE.
• Self-disqualification. The specific ICP filter at the list stage meant we weren’t wasting meetings on companies outside the sweet spot.

Month 4 — Handoff and sustainability

My engagement was 4 months. The sustainability question: could this run without me?

We spent month 4 training the sales manager (now acting AE) to take over list building and reply ops. Founder stayed on writing. Documented the entire workflow — list criteria, opener templates, reply routing rules, the weekly rhythm — into a ~40 page internal playbook.

Six months post-engagement, the program was still running at similar numbers. Founder still spends ~6 hours/week on it. Sales manager took over list work. No SDRs were rehired.

What this saved, quantified

Over the first 12 months post-restructure:

• Direct cost savings: ~$300k/year ($34k → $9k monthly, 12 months).
• Meeting volume: up ~2.1x.
• Pipeline generated: up ~3.4x (larger because of higher conversion rates too).
• Closed ACV attributable to outbound: up ~4x vs. the SDR year.

The investor was satisfied. The founder was unexpectedly happy about the weekly outbound rhythm — he said it kept him closer to the market than any other internal function.

What was specific to this engagement

Things that made founder-led work for this client but won’t for everyone:

• Founder was technically credible and comfortable writing. Not all founders are. A CEO who doesn’t have domain depth or doesn’t enjoy writing would break this motion inside a month.
• Product was narrow enough that 480 companies were a sufficient TAM. A horizontal product selling to “any company” would need volume beyond what a founder can personally attend to.
• The investor accepted the lower absolute volume. A growth-stage investor pushing for 10x outbound volume would have forced back into an SDR motion. This one was willing to accept “less volume, better economics.”

What was generalizable

For technical-founder-led companies selling to technical buyers:

1. SDRs aren’t a law of nature. They’re a choice. When the founder has depth the SDRs can’t match, the economics often favor founder-led outbound at small volumes.
2. Narrower list, better email, higher close rate. The three move together. You can’t optimize one without the other two.
3. Value-first CTAs outperform demo CTAs for devtools. Technical buyers punish pitch-y CTAs disproportionately. Founder-sent looms on specific topics outperform “book a demo.”
4. 6 hours/week is the right time investment. Less and the quality drops. More and it crowds out actual founder work. Find the cadence.
5. Plan the handoff before you start. Founder-led is valuable for the first 6–12 months. At scale, hand reply ops and list work to someone else. Keep the founder on writing.

The honest caveats

• This won’t scale past roughly $3–5M ARR of founder-led sales without breaking something. At that point, hire an AE, keep founder on early-stage pipeline.
• Laying off SDRs is hard, and the severance/transition cost was real. The $300k/year savings doesn’t factor those in.
• We were lucky on one detail: the founder was not the bottleneck for product. If he’d been heads-down shipping critical features, the 6 hours/week wouldn’t have been available.
• The program depends on the founder personally. If the founder gets sick, or resigns, or takes 6 weeks of parental leave, outbound pauses or degrades. That’s a structural risk we named but didn’t solve.

When to not do this

Founder-led outbound is wrong if:

• Founder doesn’t have domain depth beyond what an SDR can replicate.
• Target volume demands >1,000 sends/week.
• Founder is the product’s sole developer or has other full-time commitments.
• The sales cycle is short enough that the founder is the bottleneck on closing, not generating.

Everywhere else — and especially in devtools, where technical credibility in the first email is worth more than a 20-person SDR team — this motion deserves consideration before a team gets built around it.

The uncomfortable operator lesson from this engagement: the SDRs weren’t incompetent. The motion was misconfigured. A well-intentioned SDR team running a misconfigured motion will waste a year of runway while everyone debates whether “the market just isn’t ready.” Sometimes the market is ready and the motion is wrong. Worth checking before hiring the third SDR.