We’ve all seen them. The generic, low-effort B2B cold emails that clog our inboxes. They usually start with "Hi {{firstName}}," and proceed to pitch a solution to a problem we don't have, based on a job title they scraped from LinkedIn.
As developers and engineers, we know there's a better way. We build systems to solve complex problems, so why is B2B outreach still so... manual and ineffective? It's time to treat lead generation like an engineering problem.
This post breaks down a 3-part framework for building a scalable, API-driven email personalization engine. We'll go from raw data to automated, highly-relevant outreach that actually starts conversations.
Step 1: Architecting the Data Ingestion Pipeline
Personalization is only as good as the data that fuels it. Basic fields like firstName and companyName are table stakes. To create truly compelling messages, we need richer context. Think of this as building the data layer for our outreach application.
Our goal is to aggregate data points from various sources into a single, unified prospect object. Key data sources include:
- Firmographics: Company size, industry, location (APIs from Clearbit, ZoomInfo, Apollo).
- Technographics: The technologies a company uses (APIs from BuiltWith, Wappalyzer).
- Hiring Signals: Open roles that indicate needs or strategic shifts (Scraping job boards or using their APIs).
- Trigger Events: Recent funding rounds, news mentions, or product launches (APIs from Crunchbase, news APIs).
Pulling Data with a Simple API Call
Let's say we want to personalize an email based on a company's front-end framework. We can use a service like BuiltWith to get their tech stack. Here’s a simplified example of what that function might look like in a Node.js environment:
// A function to enrich a company profile with technographics
async function getTechStack(domain) {
const API_KEY = process.env.BUILTWITH_API_KEY;
const endpoint = `https://api.builtwith.com/v20/api.json?KEY=${API_KEY}&LOOKUP=${domain}`;
try {
const response = await fetch(endpoint);
if (!response.ok) {
throw new Error(`API call failed with status: ${response.status}`);
}
const data = await response.json();
// Let's assume the API response has a specific structure
// and we just want to extract a list of tech names.
const technologies = data.Results[0].Result.Paths[0].Technologies.map(tech => tech.Name);
return technologies;
} catch (error) {
console.error('Failed to fetch tech stack:', error);
return [];
}
}
// Usage:
const prospect = {
domain: 'dev.to',
// ... other data
};
prospect.techStack = await getTechStack(prospect.domain);
console.log(prospect.techStack);
// Output might include: ['Ruby on Rails', 'React', 'Varnish', ...]
Now our prospect object is enriched with valuable context we can use in the next step.
Step 2: Implementing the Personalization Logic
With rich data in hand, we can build the logic layer. This is where we translate raw data points into human-readable, relevant email copy. The core concept is a system of triggers and snippets.
- Trigger: A condition based on the prospect's data (e.g.,
prospect.techStack.includes('React')). - Snippet: A piece of pre-written text that corresponds to that trigger.
Building a Dynamic Snippet Generator
We can write a JavaScript function that takes our prospect object and constructs a personalized opening line or paragraph. This function acts as our personalization engine.
function generatePersonalizedIntro(prospect) {
// Default intro
let intro = `Saw that you're the ${prospect.title} at ${prospect.companyName} and thought I'd reach out.`;
// Rule 1: Tech Stack Trigger
if (prospect.techStack?.includes('React')) {
intro = `Noticed your team at ${prospect.companyName} is building with React. I was impressed by the smooth UI on your marketing site.`;
return intro;
}
// Rule 2: Hiring Trigger
if (prospect.hiringRoles?.includes('Senior DevOps Engineer')) {
intro = `Seeing that ${prospect.companyName} is scaling its infrastructure team with a new DevOps role, I figured you might be focused on improving deployment pipelines.`;
return intro;
}
// Rule 3: Funding Trigger
if (prospect.recentFunding > 1000000) {
const fundingAmount = (prospect.recentFunding / 1000000).toFixed(1);
intro = `Congrats on the recent $${fundingAmount}M funding round for ${prospect.companyName}! That's a huge milestone.`;
return intro;
}
return intro;
}
// Example prospect object
const aProspect = {
companyName: 'CodeCorp',
title: 'VP of Engineering',
techStack: ['Python', 'Django', 'AWS'],
hiringRoles: ['Senior DevOps Engineer', 'Frontend Developer'],
recentFunding: 0
};
const personalizedLine = generatePersonalizedIntro(aProspect);
console.log(personalizedLine);
// Output: Seeing that CodeCorp is scaling its infrastructure team with a new DevOps role, I figured you might be focused on improving deployment pipelines.
This function is a simple rules engine. It prioritizes the most specific signals first, ensuring the most relevant snippet is used.
Step 3: Building the Execution Engine with Marketing Automation
The final step is to connect our data and logic to an execution layer that can send emails at scale. This is where marketing automation workflows come in. Most modern platforms (Customer.io, HubSpot, SendGrid, etc.) have APIs that let us programmatically manage contacts and campaigns.
The workflow looks like this:
- A new lead is added to our system (e.g., from a CRM or a list).
- A webhook triggers a serverless function (e.g., AWS Lambda, Vercel Function).
- The function executes our data enrichment logic (Step 1).
- It then runs the personalization logic to generate custom fields (Step 2).
- Finally, it makes an API call to our email platform to add the contact with their personalized data and enroll them in a pre-defined email sequence.
Triggering a Workflow via API
Here’s a conceptual example of adding an enriched contact to a platform like Customer.io, which can then trigger an email campaign.
async function enrollProspectInSequence(prospect) {
const CIO_API_KEY = process.env.CUSTOMERIO_API_KEY;
const endpoint = 'https://track.customer.io/api/v1/customers';
const personalizedIntro = generatePersonalizedIntro(prospect);
const payload = {
// Unique ID for the prospect
id: prospect.email,
email: prospect.email,
// Custom attributes we can use in our email templates
first_name: prospect.firstName,
company_name: prospect.companyName,
custom_intro_line: personalizedIntro
// ... any other enriched data
};
try {
const response = await fetch(endpoint, {
method: 'PUT',
headers: {
'Authorization': `Bearer ${CIO_API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify(payload)
});
if (response.status === 200) {
console.log(`Successfully added/updated ${prospect.email} in Customer.io`);
// In Customer.io, you'd have a campaign that triggers when a user
// with the `custom_intro_line` attribute is created.
}
} catch (error) {
console.error('Failed to enroll prospect:', error);
}
}
Inside our email platform, the template would be simple: {{ customer.custom_intro_line }}. The complexity is handled by our code, not by the email tool.
From Cold Contact to Warm Conversation
By treating B2B outreach as a distributed system—with distinct data, logic, and execution layers—we transform it from a guessing game into a predictable engine for growth. This framework doesn't just increase reply rates; it shows respect for the recipient's time by sending a message that is thoughtful, relevant, and demonstrates genuine research.
This is the difference between being another email in the void and starting a valuable conversation.
How are you using code to improve your outreach? Share your stack or strategies in the comments below!
Originally published at https://getmichaelai.com/blog/from-cold-outreach-to-warm-leads-a-framework-for-b2b-email-p
Top comments (0)