In Part 1, we talked about how to intelligently segment and enrich your leads using multiple data APIs. We pulled in signals like tech stack, funding stage, job activity, and behavioral triggers. Then in Part 2, we made sure that every contact in your pipeline was real—by validating emails, phone numbers, and domains with services like Hunter and Twilio Lookup.
This brings us to the most exciting (and most misused) part of any sales cadence: the messaging.
This isn’t about copywriting templates. It’s about building a system that generates context-aware, human-sounding, channel-specific outreach—backed by GPT models. Whether you’re sending your first-touch email, a soft LinkedIn DM, or a polite breakup message, your goal isn’t to sound clever. Your goal is to sound relevant.
The Premise: Don’t Write Every Message. Build the System That Can.
Good outreach is not about volume anymore. It’s about timing, context, and tone—and the only way to scale that is to feed your system with enriched inputs and structured logic. This is where GPT becomes incredibly useful. But only when you set it up right.
In this part, you’ll learn how to build a structured message generation pipeline that takes in lead context, applies tailored prompts, and produces well-crafted outreach—automatically. We’ll walk through this in five phases, showing both tool-based and custom-code options where relevant.
Phase 1: Prepare the Right Input
All generative quality starts with data. Your lead record should now have context fields like:
- Name, title, seniority
- Company, domain, size, industry
- Tech stack and tools used
- Funding status, hiring signals
- ICP segment (A, B, or C)
- Public signals (recent post, podcast, hiring page)
If you don’t have these yet, stop here and revisit Part 1. This is your source of truth—what GPT will use to decide what to say, how to say it, and why the lead might care.
This data can live in Airtable, Google Sheets, Notion, or even your CRM. What matters is that it’s structured and queryable.
Phase 2: Create Prompt Templates Per Outreach Step
Outreach isn’t one message. It’s a series of steps across channels, each with a different tone, objective, and level of familiarity.
Start by identifying your common sequence steps. At a minimum:
- First-touch email
- LinkedIn connect message
- Follow-up with proof (case study, social validation)
- WhatsApp or SMS (if applicable)
- Breakup message
Each of these requires a different kind of prompt.
For example, your first email might use a prompt like:
“Write a short, friendly, and helpful cold email to {{name}}, the {{title}} at {{company}}, who recently raised a {{funding_round}}. They use tools like {{tech_stack}} and are likely focused on {{business_problem}}. Keep it under 100 words. Offer a short intro call.”
Your LinkedIn message, on the other hand, shouldn’t sell at all. It’s about connection and tone. And your WhatsApp message needs to feel casual, not corporate.
If you’re using tools like Make.com or n8n, you can store these prompt templates as text blocks and dynamically inject fields. If you’re going custom, frameworks like LangChain allow you to chain these prompts, apply conditional rules (e.g., fallback if no LinkedIn data), and persist prompt versions for testing.
The point is: structure your prompts with intention. Don’t just ask GPT to “write a cold email.” Guide it with purpose.
Phase 3: Automate Message Generation
Now that you’ve got your data and prompts ready, it’s time to automate the actual message generation.
There are two ways to do this—depending on whether you’re moving fast or building for long-term control.
If you’re using tools like Make or n8n, your workflow looks like this:
- New or updated lead triggers the workflow
- Lead data is fetched and mapped into the prompt
- The prompt and data are sent to GPT via an OpenAI API module
- The output is saved back to Airtable, Notion, or CRM
- Optional: a Slack message is sent to the sales rep with the draft
This setup takes a few hours to configure and is perfect for teams who want quick iteration without engineering.
If you’re building custom workflows, especially with LangChain or Python scripts, you can go deeper:
- Chain multiple prompts (e.g., generate subject line → intro → CTA separately)
- Apply conditional logic (e.g., tone X for CTOs, tone Y for marketers)
- Score the outputs using GPT itself (“Is this message persuasive and relevant?”)
- Cache and store message versions for A/B testing
Custom flows also make it easier to add custom agents—like an evaluator that checks tone and relevance before final delivery. These agents can be trained to flag inconsistent tone or even rewrite based on response data.
Use tools for speed. Build custom flows for sophistication.
Phase 4: Review, Score, and Store the Output
Even the best GPT output benefits from oversight. Once messages are generated, they need to be reviewed—either by a human, or by another AI layer.
For Tier A leads or early campaigns, you might want your SDRs to approve every message. In that case, send drafts to Slack or a Notion board with an “Approve / Edit / Reject” flow.
For scale, you can train a second GPT prompt (a message evaluator agent) to assess whether the tone is helpful, the length is appropriate, and the CTA is clear. It can tag the message as “ready”, “needs edit”, or “unsafe”.
Whichever path you take, be sure to:
- Log the GPT prompt version used
- Track open/reply rates per message type
- Store final messages alongside lead records for sync with CRM or outbound tools
You now have a pipeline that not only writes personalized messages—it learns what works over time.
Phase 5: Generate Multi-Step Sequences (Not Just a Single Message)
One-off messages rarely convert. Great sales sequences work over time, through multiple nudges and channels.
Your system should generate 3–5 messages per lead, tied together with narrative coherence.
That might look like:
- Email 1: Quick intro with benefit
- LinkedIn: Friendly touchpoint mentioning shared space
- Email 2: Value story with customer example
- WhatsApp (optional): “Hey {{first_name}}, just nudging you here.”
- Breakup: Polite sign-off with open-ended CTA
You can either generate these all at once and store them as a “sequence bundle” per lead—or generate them step by step based on previous engagement.
With LangChain, you can persist conversation context across steps, so GPT knows what’s already been said. With Make or n8n, you can schedule each step to fire after X days or Y triggers (e.g., “Email 2 only if Email 1 not replied”).
This is where your outreach starts to feel like a real human following up—because structurally, it is.
When Should You Build a Custom GPT Agent?
Most teams don’t need an agent right away. But as you grow, these needs start to emerge:
- You want GPT to rewrite a message based on open rate patterns
- You want GPT to choose which message style (short vs detailed) to use per lead
- You want to use feedback loops (“this got a reply, train future prompts accordingly”)
- You want consistent voice, fallback handling, and response scoring baked into the process
That’s when it makes sense to build a custom GPT agent using LangChain or a Node/Python API layer.
This agent doesn’t just generate—it thinks through the context, evaluates performance, and evolves with your funnel.
If you’re sending 5000+ messages a month, or running multi-product cadences, the ROI from a custom agent can be massive.
Recap: You’ve Built a Messaging Engine That Thinks Like a Sales Rep
You’ve taken clean, validated, context-rich lead data. You’ve written structured prompts based on role, segment, and outreach channel. You’ve built a generation flow using tools or code. And now, your system outputs personalized sequences that SDRs used to write one by one.
But unlike traditional automation, this system doesn’t feel robotic—because it’s trained on context, tone, and relevance.
It’s built like a team of mini SDRs who never get tired.
Coming Next: Part 4 – Multi-Channel Delivery and Sequencing
So now you’ve got personalized messaging per lead. But how do you deliver it, track responses, and manage timing across channels?
In Part 4, we’ll cover:
- Sending messages across Email, LinkedIn, WhatsApp, and SMS
- Tools like Lemlist, Twilio, and PhantomBuster
- Multi-step sequencing logic (e.g., email after LinkedIn connect)
- CRM sync and message log storage
- Trigger-based next steps (“if no reply in 3 days, run next message”)
Want This Messaging System Built for Your Stack?
We’ve helped SaaS and service teams implement GPT-powered outreach engines using both Make.com and LangChain. Whether you’re running your GTM on Airtable, Notion, or Salesforce—we can help plug this in.
Reach out to us here if you’d like help designing it.
Or subscribe to the newsletter to get the next part in your inbox.