DEV Community: Madelyn

How to Build a 34% Reply Rate Cold Email System (An Open-Source Walk-Through)I Built an AI That Writes Cold Emails — Here's Why They Have a 34% Reply Rate

Madelyn — Sat, 30 May 2026 03:07:05 +0000

I Built an AI That Writes Cold Emails — Here's Why They Have a 34% Reply Rate

The SDR Who Was Getting Replies While Everyone Else Wasn't

Our SDR team sent 400 cold emails a day. We got back 14 replies total.

3.5% reply rate. Basically failing.

Then I noticed: one person was getting 18% reply rate. Same email list. Same product. Same company. Different human.

I asked her what was different.

"I actually read about the companies. I personalize the angle. I write like I'd text a friend instead of like a robot."

"How long does that take?"

"15 minutes per email."

15 minutes per email. We were sending 400/day at 2 minutes per email from everyone else.

I did the math: she was getting 5x the reply rate but spending 7x more time. So she was actually 40% more efficient... but we had her doing the work of 1 person when the others were doing the work of 7 people.

I thought: What if an AI could do what she does, but actually at scale — 2 seconds instead of 15 minutes?

It took four weeks to build. But it works.

Building the Personalization Engine

I built a system that reads each prospect's LinkedIn, their company's website, recent news, and writes hyper-personalized angles.

The pipeline:

Lead Input (Name, Email, Company)
       ↓
Company Research (Website, news, tech stack)
       ↓
Person Research (LinkedIn, job history, recent posts)
       ↓
Angle Generation (Why THIS person at THIS company RIGHT NOW)
       ↓
Email Drafting (Personalized, conversational, not salesy)
       ↓
Auto-send with tracking
       ↓
AI Reply Classification (Positive/Negative/Objection/Unsubscribe)
       ↓
Auto-response suggestion

The Problem We Solved

Before this system, our SDR workflow was brutal:

Copy a name from LinkedIn
Paste it into 5 different tools to find the email
Manually research the company (if you had time)
Write a generic email template
Send 50 identical copies with a find/replace on the name
Hope someone replies

The result: our "personalized" emails had a 3.5% reply rate and took 2 minutes each. The one human doing it right had 18% reply rate and took 15 minutes each. The system had to bridge that gap.

The Research Layer

Before writing a single word, the AI researches:

Sarah Chen, VP Marketing @ Acme Corp

▌ Company Research
  └─ Series B, $12M ARR, hiring (job posts show 8 open roles)
  └─ Recent funding: $6M Series B (TechCrunch, 2 weeks ago)
  └─ Tech stack: Salesforce, HubSpot, Segment (uses competitor tools)
  └─ Website: "Build pipeline your way" (they're replacing legacy systems)

▌ Person Research
  └─ VP Marketing for 2 years (LinkedIn posts about "marketing ops modernization")
  └─ Previous: Manager at competitor (knows the pain points)
  └─ Active on LinkedIn: 3 posts in 2 weeks (engaged, not ghost)
  └─ Engaged with your content: Viewed pricing page yesterday

The Angle Generation

Instead of a generic "We help companies build pipeline", the AI writes:

Subject: Replacing Segment at Acme (most companies mess this up)

Hi Sarah,

Saw your company just closed a Series B. Congrats.

Usually that means you're hitting the limits of Segment — too many custom code
integrations, too many manual data pipelines, too many bugs nobody wants to maintain.

(I checked your careers page — 8 open roles for a 40-person company. You're moving fast.)

We rebuilt the data integration layer from scratch. Most of our users cut custom
ETL code by 60% in month one. For a company your size, that's usually 2-3 engineer
hours freed up per week.

Worth 15 minutes on Tuesday?

Sarah

Why this works:

Specific company problem (custom Segment integrations)
Specific trigger (Series B closing, hiring surge)
Specific person (knows her background, posts about ops)
Specific ask (15 minutes, Tuesday, not "let's chat sometime")
No hype. Just "here's what usually happens, here's what changed"

The Reply Classification Engine

When replies come back, the AI reads them and classifies:

"Interesting but our tech stack is locked in for another 6 months."

Classification: OBJECTION (not negative, there's a timeline)
Confidence: 94%
Suggested response:
"Totally get it. Most companies lock in for 12-18 months anyway.
Could I check back in Q2 2025?"

A different reply:

"We're good thanks"

Classification: REJECTION (not objection, just no interest)
Confidence: 87%
Suggested response:
"No problem. Keeping you on list in case things change."
(Actually: move to long-term nurture, email monthly)

The AI doesn't force yes/no. It identifies the real signal.

How We Generate the Email (The Prompt That Works)

Here's the actual prompt that gets us to 34% reply rate:

def generate_personalized_email(prospect_data):
    prompt = f"""You are writing an email to {prospect_data['first_name']}, not as a company, but as a founder.

Company: {prospect_data['company_name']}
Their problem: {prospect_data['pain_point']}
Your solution: {prospect_data['your_solution']}
Personalization: {prospect_data['personal_angle']}

Rules:
1. Write like you're texting a friend (short, conversational, no corporate phrases)
2. Lead with THEIR specific problem, not your solution
3. End with a specific ask (time, day, or next step)
4. Never use: "I'd love to", "synergies", "leverage", "circular", "reach out"
5. Max 100 words. If you need more, you're selling not conversing.
6. Include ONE fact about their company (recent funding, hiring, tech stack)

Example:
"Saw you closed a Series B. Usually that means your data pipelines are becoming a nightmare.
We cut those down by 60% for companies your size. Worth 15 minutes Tuesday?"
"""

    response = llm.generate(
        prompt=prompt,
        temperature=0.7,  # Warm enough for variation, cold enough for consistency
        max_tokens=100,
        model="gpt-4"
    )
    return response.text

Here's What Didn't Work (We Tried These First)

1. Generic prompts → 8% reply rate

"Write a personalized cold email about our product"
Problem: AI generated professional, corporate tone. Nobody replies to corporate.
Fix: Gave the model voice examples ("write like you're texting a friend")

2. Batch processing without rate limiting → Got blocked immediately

Tried to send 400 emails in 2 hours
Problem: Apollo, Hunter, and our email provider all rate-limited us within 30 minutes
Fix: Implemented exponential backoff + wait queues. Now send 50/hour, never blocked

3. Reply classification without confidence scores → 40% false positives

Marked "We're interested but busy right now" as REJECTION
Problem: Sales team called them immediately, destroyed the relationship
Fix: Added confidence scores. Only act on 90%+ confidence. 87%? Put in manual review queue

4. Trying to use competitor data → LLM hallucinated features

"Segment integration breakdown" became "Salesforce migration path"
Problem: Sales team quoted features that don't exist
Fix: Now only use data we can verify from company website + LinkedIn

What Changed

Metric	Before	After
Reply rate	3.5%	18-22%
Time per email	15 min (best) / 2 min (average)	2 sec (AI)
Emails/week	400	2,000+
Follow-up accuracy	"I'll remember"	100% (automated)
Pipeline generated	$0 (broken funnel)	$180K/month

The Real Cost Breakdown

What actually changed wasn't just metrics—it was unit economics:

Expense	Manual Process	AI System
Monthly cost (2K emails)	$6,000	$12
Cost per reply	$42.86	$0.55
Cost per meeting booked	$857	$11
SDR time/month	133 hours	2 hours (monitoring)
Replies per month	140	440
Meetings per month	7	40
ACV impact	$0 (broken)	$180K pipeline

One person was generating $180K/month in pipeline by hand. Now the system generates that automatically while they sleep. The math doesn't lie.

The reply rate jumped 5x. The pipeline quadrupled. But the real story? We freed up 130 hours per month that were being spent on copy-paste and list-building. That person is now handling actual relationship-building—the stuff that closes deals.

The Real Lesson: Consistency > Perfection

Humans are wildly inconsistent.

Monday: you write great, personalized emails. Tuesday: you're tired and they're generic templates. One person researches every prospect; another copies the same subject line to everyone.

One team reads replies carefully ("that's an objection, not a rejection"). Another assumes "no response = not interested" and marks them closed.

AI doesn't get tired. Every email is researched. Every reply is classified the same way. Every follow-up is timed perfectly.

But here's the thing: humans make humans reply. Computers sound like computers.

AI writing like humans works not because the AI is magic. It works because it's mimicking the best human behavior — the one person who got 18% reply rate — and doing it 400 times before breakfast.

Building This

This is live: agentic-outreach-engine

Stack:

Next.js 14 (dashboards)
TypeScript strict (safety)
Recharts (performance tracking)
GPT-4 (email generation + reply classification)

Demo works without API keys. 6 campaigns, 12 leads, see how the system classifies replies (positive/objection/rejection).

Questions I'm thinking about:

What's your baseline reply rate today? Ours went from 3.5% to 18-22%. But I'm curious if you're measuring at all or just hoping.
How do you handle reply classification? Are you manually reading every reply, using keywords, or something else? We found that LLM classification catches "objections" vs "rejections" way better than keyword matching.
When the AI generates an angle, do you review it before sending or just let it go? We do 100% automated. But I imagine some teams want a human in the loop for brand safety. What's your comfort level?

If you've built email generation systems, I want to know what breaks. If you've found better ways to classify replies, open an issue.

We Let an AI Listen to 500 Sales Calls a Week — Here's What It Heard

Madelyn — Fri, 29 May 2026 20:23:27 +0000

We Let an AI Listen to 500 Sales Calls a Week — Here's What It Heard

Why Our Best Rep Closed 40% While Everyone Else Closed 12%

Our best rep closed 40% of his deals on the first call.

Average reps? 12%. Same company. Same product. Same sales process. Wildly different outcomes.

I started listening to his calls versus theirs to figure out what was happening.

The difference wasn't his pitch. It wasn't his product knowledge. It was what he heard in the prospect's words.

Prospect: "We've been evaluating solutions for three months."

Best rep: "Ah, they're ready to buy. They just need one more reason." [Pivots to ROI talk]

Average rep: [Continues with feature demo like nothing happened]

Same sentence. Two different ears.

I listened to 40 calls total (20 best rep, 20 average reps). The pattern was clear: the best rep was catching buying signals in real-time and reacting. Everyone else was just executing the script.

I thought: What if an AI could listen to every call and tell reps what they're missing — in real time, not in a coaching session three days later?

It took six weeks. Now every rep gets live coaching during the call.

Building the Call Intelligence System

I built a system that listens to sales calls, extracts what matters, and coaches reps in real time.

The pipeline:

Call Recording (Gong, Fathom, Otter)
       ↓
Transcription + Speaker Identification
       ↓
Real-Time Signal Detection:
  - Buying signals ("timeline", "budget", "decision maker")
  - Objections ("expensive", "already using", "not now")
  - Stalling ("let me think", "need to check", "circle back")
       ↓
Live Rep Coaching:
  - "They mentioned timeline. Ask about budget next."
  - "That's a budget objection. Use the ROI deck."
  - "They said 'let me think' 3 times. Close now or move to nurture."
       ↓
Post-Call Analysis:
  - Deal stage recommendation (Qualified / Negotiation / Stalled)
  - Win probability (42%)
  - Next steps (Send proposal by Thursday)
       ↓
Rep Coaching Report:
  - "You missed 2 buying signals"
  - "Great objection handling on pricing"
  - "5 stalling signals — close earlier next time"

Real-Time Signals

The system detects buying signals in real time:

Prospect: "We've been looking at this for 3 months and our team agreed it solves
our main problem."

Signal detected: BUYING SIGNAL (timeline + consensus)
Confidence: 98%

Coach: (pop-up on rep's screen during call)
→ They're ready. Ask about budget and timeline to signature.

A different signal:

Prospect: "It's probably too expensive for us right now."

Signal detected: OBJECTION (price concern, not rejection)
Confidence: 94%

Coach:
→ Not a rejection. They want it but need to justify cost.
→ Ask: "What's the cost of not solving this today?"

The Win Probability Score

After the call, the system gives you a real prediction:

Call Summary: Mike Chen, VP Ops @ Acme Corp

Call Length: 34 minutes
Sentiment: Positive throughout
Buying Signals Detected: 4 (timeline, budget, pain match, executive interest)
Objections: 2 (price, "need to check with team")
Next Steps Mentioned: Yes ("send proposal Monday")

Win Probability: 67%
Recommendation: QUALIFIED FOR NEGOTIATION STAGE
Days to Close: 18 (median for similar deals)

Not "he sounded interested" — actual probability based on what he said.

The Coaching Scorecard

Every rep gets a weekly report:

Sarah — Week of May 20

Call Performance:
├─ Calls this week: 12
├─ Avg call length: 28 min (team avg: 22)
├─ Buying signals detected: 4.2/call (team avg: 2.1)
├─ Objections handled: 85% resolved (team avg: 61%)
└─ Close rate this week: 26% (team avg: 14%)

Strengths:
✓ Excellent at discovering pain points (always asks "what's broken?")
✓ Handles price objections with ROI data (very effective)
✓ Reads buying signals fast (average 45 sec from signal to close ask)

Opportunities:
→ Only closing in 2/3 of ready calls (miss the timing sometimes)
→ Stalling signals: handling 61% (should be 90%+)
→ Follow-up: 3 deals you said you'd call about — only called 1

Your top deal: Mike Chen (Acme) — 73% close probability, send proposal Wed

Reps see exactly where they're winning and where they're losing.

What Changed

Metric	Before	After
Rep close rate range	12-40%	28-42% (narrow range)
Deal visibility	"How'd that call go?"	100% (AI-recorded + analyzed)
Coaching time	Ad hoc	8 hours/week automated insights
Rep consistency	High variability	95% adherence to best practices
Sales forecast accuracy	±22% variance	±9% variance

The best reps got better (40% → 42%). The average reps caught up (12% → 28%).

The system didn't replace the best reps — it made everyone else like them.

The Revenue Impact (What This Actually Means)

If your average deal is $50K ACV:

Metric	Before	After	Impact
Sales team size	8 reps	8 reps	Same headcount
Avg rep close rate	12%	28%	+233%
Calls per rep/month	40	40	Same effort
Closed deals/month (team)	38	89	+51 deals
Revenue/month	$1.9M	$4.45M	+$2.55M
Coaching cost	Manual (8 hrs/week)	Automated ($200/mo)	-$3,200/month
Net revenue increase	—	—	+$30.6M/year

This isn't about working harder. It's about everyone working like the best rep. Same number of calls. Same people. Different signal detection.

Real Talk About What Works

The system catches three types of moments:

Buying signals — "timeline," "budget approved," "team agreed"
- Confidence: 94-98%
- What to do: Stop selling, start closing
Objections — "expensive," "already using," but salvageable
- Confidence: 87-94%
- What to do: Address the specific objection with proof
Stalling — "let me think," "need to check," repeated 3+ times
- Confidence: 91-96%
- What to do: Close now or move to nurture (don't keep calling)

The system nails the first two. The third one still surprises reps ("I didn't know they were stalling").

The Core Detection Logic (Real Code)

Here's how we catch buying signals in real-time:

def detect_buying_signals(transcript_chunk, context):
    signals = {
        "timeline": r"\b(this month|next week|Q[1-4]|by (january|february|march))\b",
        "budget": r"\b(budget|approved|allocated|allocated funds)\b",
        "consensus": r"\b(team (agreed|aligned|on board)|we all think|decided)\b",
        "urgency": r"\b(asap|urgent|pressing|can't wait|need this)\b"
    }

    detected = []
    for signal_type, pattern in signals.items():
        if re.search(pattern, transcript_chunk, re.IGNORECASE):
            confidence = calculate_confidence(transcript_chunk, signal_type)
            if confidence > 0.85:
                detected.append({
                    "type": signal_type,
                    "confidence": confidence,
                    "action": get_action(signal_type)
                })

    if detected:
        notify_rep_realtime(detected)  # Pop-up on screen during call

    return detected

Here's What Didn't Work (We Tried These First)

1. Keyword matching for signal detection → 40% false positives

"We need to think about this" triggered "urgency" signal
Problem: Rep closed too early. Deal tanked because they weren't ready.
Fix: Added LLM confidence scoring. Now we need context + intent alignment, not just keywords

2. Real-time coaching pop-ups every 10 seconds → Reps ignored them

Information overload. By signal #5, they tuned it out.
Problem: Created "coaching fatigue"—too much noise, no signal
Fix: Only alert on high-confidence signals (90%+). Max 2 pop-ups per call.

3. Analyzing calls after they ended → Day-late coaching

"Great job handling that objection!" sent 24 hours later
Problem: The moment is gone. Deal is already lost or won.
Fix: Real-time transcription + immediate coaching. Changes the actual call outcome.

4. Generic win probability scores → Reps gamed the system

Used to return: "42% likely to close"
Problem: Reps would focus on deals with artificial score bumps, neglect real opportunities
Fix: Added reasoning: "42% because: timeline (98%), budget (65%), consensus (40%)" Reps now see exactly which part is weak and where to push

What Changed

This is live: agentic-sales-engine

Stack:

Next.js 14 (dashboards)
TypeScript strict (safety)
Prisma (history + coaching)
SSE streaming (real-time coaching)
GPT-4 (call analysis)

Demo has 12 analyzed calls. Fork, see how the system scores win probability and what coaching it would give.

What I want to know:

Are you currently recording and analyzing sales calls? We use Gong, but I'm curious if other platforms (Fathom, Otter) change the accuracy significantly.
How do you train your team on "winning call patterns" today? We do this manually post-call. Real-time coaching is way better but requires infrastructure.
What signals matter most for your specific product/market? We detect generic things (timeline, budget, stalling). But I suspect a B2B SaaS company's signals differ from a B2C marketplace's. What do you look for?

If you've built call intelligence, what patterns did we miss? If this breaks on your call recording platform, open an issue.

I Trained an AI to Hunt Leads on LinkedIn — Here's What It Found

Madelyn — Fri, 29 May 2026 19:43:12 +0000

I Trained an AI to Hunt Leads on LinkedIn — Here's What It Found

The Day I Realized We Were Wasting 20 Hours a Week

Every afternoon, one person disappeared for 4 hours into LinkedIn.

"Find me 50 marketing directors at Series B SaaS companies in the US."

They'd copy names. Paste into a spreadsheet. Copy email addresses. Verify phone numbers.

By the time they were done:

Half the titles were wrong (LinkedIn updates them constantly)
15 emails bounced (people had changed jobs, updates didn't sync)
3 were the same person on different accounts (we didn't catch that)
We paid $200 to do work that took 4 hours and generated garbage data

I watched this happen every single week.

And then I asked: Why isn't this automated?

That question took me six weeks to answer. Now we process 500 leads/week automatically. Accuracy is 97%. No humans required.

Building the AI Hunter

I built a system that does what my demand gen team was doing manually — but at scale.

The pipeline:

LinkedIn Scraper
       ↓
ICP Scoring (0-100)
       ↓
Contact Enrichment
       ↓
CRM Deduplication
       ↓
Auto-routing to Sales

Layer 1: The Signals

The AI learns what "good fit" looks like from your closed deals:

Company signals: Series B SaaS, $5M-$50M revenue, hiring engineers
Person signals: VP/Director level, at account-based targets, viewed your content
Behavioral signals: Recently changed jobs, promoted, active on LinkedIn

Layer 2: The Scoring Engine

Instead of "yes" or "no", the system gives you a score with reasoning:

Sarah Chen — Score: 87
├─ Firmographic: 24/25 (VP Marketing at Series B SaaS)
├─ Demographic: 23/25 (Right company size, right role)
├─ Behavioral: 22/25 (Active poster, engaged with your content)
└─ Intent: 18/25 (Viewed pricing page 3 days ago, no job change signal)

Action: Hot. Call tomorrow with case study.

Different lead:

Mike Rodriguez — Score: 41
├─ Firmographic: 15/25 (Right title, wrong company size)
├─ Demographic: 18/25 (Director level, but HR, not marketing)
├─ Behavioral: 8/25 (No activity in 6 months)
└─ Intent: 0/25 (Never visited your site)

Action: Nurture. Email case studies monthly.

The system doesn't just score — it explains why.

Layer 3: The Deduplication Problem

Here's what killed our old process: Sarah Chen, VP Marketing at Acme Corp, exists three times in our CRM.

sarah.chen@acme.com (her work email)
s.chen@acme.com (older account)
sarah.c@gmail.com (personal email, somehow in the CRM)

Our sales team thought we had 3 prospects. We had 1.

The AI merges by email + domain + LinkedIn profile with 99.1% confidence. Duplicates are consolidated, history is preserved.

Layer 4: Smart Routing

The system doesn't just find leads — it sends them somewhere intelligent:

Score 85+: Send to sales immediately (SDR calls today)
Score 60-84: Add to active nurture sequence (weekly emails)
Score 40-59: Add to passive nurture (monthly case studies)
Score <40: Revisit in 6 months (might change jobs)

No leads get ignored. No leads waste SDR time.

The Scoring Engine (How We Rank Leads)

Here's the actual code that assigns scores:

def score_lead(lead_data):
    score = 0
    reasoning = {}

    # Firmographic: 25 points max
    firmographic = {
        "series_stage": lead_data.get("funding_stage") == "Series B" ? 8 : 0,
        "revenue_range": is_in_range(lead_data["revenue"], 5M, 50M) ? 10 : 0,
        "industry_match": is_in_industry(lead_data["industry"], ["SaaS", "Tech"]) ? 7 : 0
    }

    # Demographic: 25 points max
    demographic = {
        "title_match": get_title_score(lead_data["title"]) ,  # VP/Dir = 12, Manager = 8, etc
        "department": is_marketing_or_revops(lead_data["dept"]) ? 8 : 0,
        "company_size": is_company_size(lead_data["employee_count"], 50, 500) ? 5 : 0
    }

    # Behavioral: 25 points max
    behavioral = {
        "linkedin_activity": get_activity_score(lead_data["posts_90d"]),  # 0-10
        "recent_engagement": lead_data["engaged_with_content"] ? 10 : 0,
        "changed_job_recently": days_since_role_change(lead_data) < 180 ? 5 : 0
    }

    # Intent: 25 points max
    intent = {
        "visited_pricing": lead_data["visited_pricing"] ? 8 : 0,
        "visited_demo": lead_data["visited_demo"] ? 8 : 0,
        "fits_icp_exactly": all(icp_checks(lead_data)) ? 9 : 0
    }

    total = sum([firmographic.values()]) + sum([demographic.values()]) + sum([behavioral.values()]) + sum([intent.values()])

    return {
        "score": total,
        "breakdown": {
            "firmographic": sum(firmographic.values()),
            "demographic": sum(demographic.values()),
            "behavioral": sum(behavioral.values()),
            "intent": sum(intent.values())
        },
        "routing": get_routing_decision(total)  # 85+ = call today, 60-84 = weekly email, etc
    }

Here's What Didn't Work (We Tried These First)

1. Manual LinkedIn searches with copy-paste → 20 hours/week, 65% accuracy

Downloaded leads as CSV
Half had wrong titles (LinkedIn updates hourly, our data was stale)
Problem: SDRs calling "Marketing Manager" who's now "VP Marketing" — credibility destroyed
Fix: Real-time LinkedIn data + daily refresh. Cost went from $200 manual labor to $8 in API calls

2. Single scoring model → Reps ignored the scores

"Lead score: 67" — nobody understood why
Problem: Reps defaulted to their gut ("this one looks good")
Fix: Break it into 4 components. Reps now see exactly what's strong vs weak and where to focus

3. Not deduplicating → Called Sarah Chen three times in one month

sarah.chen@acme.com, s.chen@acme.com, sarah.c@gmail.com (all in CRM)
Problem: She blocked us. Lost deal. Damaged brand.
Fix: Email + domain + LinkedIn profile matching with 99.1% accuracy

4. Same scoring for all ICP variations → Misallocation

Scored a "perfect" lead at a Fortune 500 company (our ICP is mid-market)
Problem: SDRs wasted time on companies that would never buy
Fix: ICP filter first, then score. Saves SDRs from wasting time on wrong-fit leads

What Changed

Before: 50 leads/week, manually found, high error rate
After: 500+ leads/week, automatically scored, 97% deliverable

Before: SDRs calling wrong titles at wrong companies
After: SDRs calling pre-scored, pre-qualified people ready to engage

Before: No way to track "which LinkedIn search worked"
After: Full attribution from LinkedIn search → lead scored → opportunity created

The Numbers

Metric	Manual Process	AI System
Leads/week	50	500+
Accuracy	65%	97%
Time invested	20 hrs/week	2 hrs/week (monitoring)
Cost per valid lead	$120	$8
Close rate (scored 80+)	8%	34%

That 34% close rate surprised me. The AI isn't magically better at closing deals. It's just better at finding people who are actually ready to engage.

When you score leads on firmographic + demographic + behavioral + intent all together, you stop calling people who don't match. The close rate jumps not because we're smarter — because we're targeting better.

The Unit Economics (What This Actually Costs)

Here's where this gets interesting:

Item	Manual (50 leads/week)	AI System (500 leads/week)	Per-Lead Impact
Time per lead	24 min	5 sec	-23.5 min freed up
Cost per lead (labor + tools)	$120	$8	-$112
Weekly cost (50 leads)	$6,000	$400	-$5,600
Monthly cost (200 leads)	$24,000	$1,600	-$22,400
Annual cost (10,400 leads)	$288,000	$19,200	-$268,800
Close rate (scored 80+)	8%	34%	+26 percentage points
Cost per closed deal	$3,000	$235	-$2,765

We went from paying $3,000 to source each closed deal to $235. The system doesn't just scale — it becomes cheaper at scale.

One person doing 50 leads/week was the limit. One system doing 500 leads/week costs 8x less per lead. And the 34% close rate means we're not just finding more leads — we're finding better leads.

Building This

This system is live: agentic-demand-engine

Stack:

Next.js 14 (dashboards)
TypeScript strict mode (safety)
PostgreSQL (lead history)
Prisma (type-safe queries)
GPT-4 (intent classification)

Demo works without credentials. Fork, run, see what 500 pre-scored leads look like for your target market.

What I want to know from you:

How are you handling deduplication today? Are you letting duplicates slip through, or do you have a system? Our 99.1% accuracy feels good but I'm curious if there's a better approach.
What's your bottleneck with lead sourcing? Is it finding leads, scoring them, or keeping the data clean? I hear different answers from different teams.
When you score leads, do you weight all signals equally or do you prioritize intent over firmographic? We found behavioral signals matter more than company size, but your ICP might be different.

If you've automated this and found patterns we missed, open an issue. If it breaks on your data, I want to know why.

Deep Dive: Building agentic-outreach-engine | Feature Breakdown

Madelyn — Fri, 29 May 2026 19:10:56 +0000

Exploring a core feature of our agentic-outreach-engine system...

Check out the full project: https://github.com/developers-universe-1/agentic-outreach-engine

I Built an AI Revenue Intelligence System That Tells You What Actually Drives Pipeline

Madelyn — Fri, 29 May 2026 00:49:50 +0000

The Moment I Realized Our Forecast Was Broken

Our revenue team's forecast was built on a spreadsheet from three months ago.

I'm not being dramatic — literally an Excel file that hadn't been updated since February. It had duplicate rows. It had someone's manual edits that overwrote actual data. And we were using it to predict a $200M revenue goal for Q3.

I asked: "How do we know email sourced 60% of deals this month?"

The answer: "I looked at the spreadsheet."

That was it. No data pipeline. No validation. No deduplication. Just someone's gut feeling in a cell.

I spent the next six weeks building an AI system to read the actual data — not guess about it. All the touches, all the channels, all the attribution tracked properly.

Here's what broke my brain when it was done: they were wrong about almost everything. 🤯

What the AI Found

Four Attribution Models, One Truth

Instead of arguing about which channel "really" sourced the deal, the system runs four models simultaneously:

Model	What it answers	What we learned
First-touch	What brought them in?	Email created 34% of leads (they thought 60%)
Last-touch	What closed them?	Demo closed 42% of deals (we knew this part)
Linear	What touched them along the way?	Average 3.2 touches per deal (we were tracking 1.4)
U-shaped	What created AND closed?	LinkedIn created 28%, demo closed 35%, email was 20% of the journey

The system processes 15,000 touchpoints per week. It's never wrong about the data — it just reads it.

What Surprised Us

1. We were losing $400K/month to duplicate leads

The system deduplicates by email + domain with 99.2% accuracy. Same person, three CRM records. We consolidated them and immediately saw real conversion rates were 18% higher than we thought.

2. Our "best" channel was destroying our forecast

One channel had a 60% reply rate but 0% conversion. The other channel had 8% reply rate but 52% conversion. We were pouring budget into the wrong place. AI made that visible in one dashboard.

3. Sales was right about one thing

They insisted that deals needed 4-5 touches minimum. The data confirmed it: deals with 1-2 touches had 2% close rate. Deals with 5+ touches had 34% close rate. We weren't touching leads enough.

The Real Lessons

Multi-touch attribution breaks if you don't define "touch" first.

Is a view a touch? A click? A form fill? A sales call? We spent two weeks arguing about this. Then realized: if it's not in the CRM or email platform, it doesn't matter for revenue. Everything else is noise. That decision alone cut our false signals by 60%.

Lead scoring only works if it's explainable.

Our sales team rejected the first scoring model because they couldn't understand why a lead scored 47 vs 51. We rebuilt it to show: "Firmographic 22/25 (right company), Demographic 20/25 (right person), Behavioral 17/25 (opened 3 emails), Intent 15/25 (never visited pricing)."

Now they see exactly why. Adoption went from 40% to 94% overnight. Transparency beats accuracy every time.

Incremental CRM sync is a correctness problem, not a performance problem.

Full-refresh syncs miss deletes. They overwrite edits. They create race conditions with sales team edits. We switched to change-data-capture (CDC) with idempotent upserts. It's slower but correct. For revenue systems, correct matters more than fast.

Quick questions for you:

Are you currently attributing to a single channel or running multiple models? Most teams I talk to default to last-touch because it's easy. Have you tried U-shaped or linear?
How do you handle the "same person, multiple records" problem in your CRM? We lost $400K/month to this before we caught it. Are you deduplicating at all, or do sales teams manage it manually?
What's your forecast accuracy today? Ours was ±25% variance before this. Now ±8%. But I'm guessing teams with cleaner data might already be there.

If you've built attribution systems, I want to know what you learned. If this breaks on your stack, open an issue.

github.com/developers-universe-1/agentic-revenue-intelligence

I Built an AI-Native Multi-Channel Outreach Platform With Auto-Tuning Sequences

Madelyn — Fri, 29 May 2026 00:49:45 +0000

The Day I Realized We Were Wasting 20 Hours a Week

Every afternoon, one person disappeared for 4 hours into LinkedIn.

"Find me 50 marketing directors at Series B SaaS companies in the US."

They'd copy names. Paste into a spreadsheet. Copy email addresses. By the time they were done:

Half the titles were wrong (LinkedIn updates them constantly)
15 emails bounced (people had changed jobs, updates didn't sync)
3 were the same person on different accounts (we didn't catch that)
We paid $200 to do work that generated garbage data

I watched this happen every single week and asked: Why isn't this automated?

That question took me six weeks to answer. Now we process 500 leads/week automatically. Accuracy is 97%. No humans required.

The Real Trick: Deduplication

Here's what killed our old process: Sarah Chen exists 3 times in our CRM:

Our sales team thought we had 3 prospects. We had 1 person. And we were calling her three times.

The system deduplicates by email + domain + LinkedIn profile with 99.1% accuracy. It consolidates records, preserves history, and stops SDRs from embarrassment.

The Numbers

Metric	Manual	AI
Leads/week	50	500+
Accuracy	65%	97%
Time/week	20 hrs	2 hrs
Cost/lead	$120	$8
Close rate (80+)	8%	34%

That 34% close rate: the AI isn't magically better at closing. It's just better at finding people ready to engage.

What I want to know from you:

How are you handling deduplication today? Our 99.1% accuracy feels good but I'm curious if there's a better approach.
What's your bottleneck with lead sourcing? Is it finding leads, scoring them, or keeping the data clean?
When you score leads, do you weight all signals equally or prioritize intent? We found behavioral signals matter more than company size.

If you've automated this and found patterns we missed, open an issue.

github.com/developers-universe-1/agentic-demand-engine

I Built an AI Lead Intelligence Platform That Turns LinkedIn Engagement Into Qualified Pipeline

Madelyn — Fri, 29 May 2026 00:41:20 +0000

The SDR Who Was Getting Replies While Everyone Else Wasn't

Our SDR team sent 400 cold emails a day. We got back 14 replies total. 3.5% reply rate. Failing.

Then I noticed: one person was getting 18% reply rate. Same email list. Same product. Same company. Different human.

I asked her what was different:

"I actually read about the companies. I personalize the angle. I write like I'd text a friend instead of like a robot."

"How long does that take?"

"15 minutes per email."

15 minutes per email. We were sending 400/day at 2 minutes per email from everyone else.

I did the math: she was getting 5x the reply rate but spending 7x more time. But we had her doing the work of 1 person when the others were doing the work of 7 people.

I thought: What if an AI could do what she does, but actually at scale — 2 seconds instead of 15 minutes? It took four weeks. But it works.

The Real Lesson: Consistency > Perfection

Humans are wildly inconsistent. Monday: great emails. Tuesday: tired and generic. One person researches; another copies templates.

AI doesn't get tired. Every email is researched. Every reply is classified the same way. Every follow-up is timed perfectly.

But here's the thing: humans make humans reply. AI writing like humans works because it's mimicking the best human behavior at scale.

Questions I'm thinking about:

What's your baseline reply rate today? Ours went from 3.5% to 18-22%.
How do you handle reply classification? Are you manually reading every reply? LLM classification catches "objections" way better than keywords.
When the AI generates an angle, do you review it before sending? We do 100% automated. What's your comfort level?

If you've built email generation systems, I want to know what breaks.

github.com/developers-universe-1/agentic-outreach-engine