Personalized Video Outbound at Scale: The Apollo + Claude + Golpo System

Cold outbound has a generic problem. The fix isn't a cleverer prompt, a slicker template, or one more A/B test on subject lines. The fix is to stop thinking about outbound as content and start thinking about it as a pipeline — where every prospect moves through the same set of states, and each tool in the stack has exactly one job.

Liam ParkEngineer turned developer-relations writer on AI workflows for technical teams.Published June 12, 2026

This guide breaks down a working system that sends thousands of outbound emails that feel one-to-one, each with a custom whiteboard-style video generated for that specific prospect. Apollo finds and enriches the person. Claude (or Codex) writes the personalization brief, then the script and the email. Golpo renders the video. Email tooling sends it. State machines and queues handle the volume.

The short version is in the walkthrough below — the architecture, the failure modes, and why "video personalization" is the wrong mental model. The right mental model is: a personalization engine that happens to output video.

The Mental Model: A Pipeline, Not a Prompt

Traditional outbound fails because it's generic. First-name personalization and "I saw your post" openers help a little, but the prospect can still feel a template under the hood. Video changes the dynamic — there's a face, a voice, and a reason. It buys attention, and attention buys reply rate.

But you can only make video work at scale if you stop trying to write a single magic prompt that does everything. Each tool in the system does one thing well:

• Apollo — finds and enriches the prospect (verified email, firmographic context, role data).
• Claude / Codex — produces a structured personalization brief, then derives the script and email copy from it.
• Golpo — renders the whiteboard video from the script via API. Not the brain. The renderer.
• Your email sender — Apollo sequences, Smartlead, Instantly, or your own provider — throttles delivery and logs sends.
• Your database — tracks every prospect's state so the pipeline is restartable and idempotent.

If you understand this as a personalization engine that outputs video — not a video tool that sends emails — you understand the system.

Walking Through One Prospect, End to End

Suppose you're selling a B2B SaaS product to VPs of Sales at 200–1,000-person companies. Here is what happens to one prospect, from raw lead to sent email, in the order it actually has to happen.

Step 1 — Apollo Finds and Enriches the Person

You filter Apollo by title, company size, industry, and region. Apollo returns verified contact data plus firmographic context — funding stage, tech stack, headcount growth, recent hires. Store the enriched record in your own database keyed by Apollo's person ID. Two reasons: you never want to re-enrich the same person and burn credits, and you want a stable record you can re-process if Claude or Golpo fails downstream.

At the end of Step 1, the prospect's state is enriched.

Step 2 — Claude Writes the Personalization Brief

This is the step almost every "AI outbound" tool gets wrong. They feed the enriched data straight into a "write me a video script" prompt. Claude (or Codex) is far better when you split that into two stages.

First, Claude produces a personalization brief — a structured JSON object, not prose. The brief contains:

• Hook — the specific reason you're reaching out, grounded in a fact from the enriched record (e.g., "they just raised a Series B and are doubling their AE team").
• Pain point — the likely problem this person has given their role and the company's context.
• Feature mapping — which one or two product features map to that pain. Not all of them. Just the relevant ones.
• Tone — direct, warm, technical, etc. Inferred from role and company.
• Target length — 30 or 60 seconds, depending on seniority.
• Risk flags — things not to claim (e.g., "do not claim X integration; not yet shipped").

The brief is the source of truth. Every downstream artifact — script, email, subject line — must be derivable from this object. If the brief is wrong, you fix the brief. You do not patch the script.

Step 3 — Script and Email From the Same Brief

Now Claude produces two artifacts from the brief in a second pass:

• A 30–60 second video script with a consistent shape: specific opening reason → one pain → one solution → single call to action. No rambling, no generic claims.
• An email body and subject line that frames the video, not replaces it. The email's job is to get the prospect to click the thumbnail.

Constrain Claude with approved and banned claims — a list of statements your legal or product team has signed off on, and a list of things to never say. If required data is missing, Claude must output "unknown" rather than guess. That single rule eliminates most of the hallucination risk in outbound copy.

Step 4 — Golpo Renders the Video (Async)

The script is sent to the Golpo API along with your brand settings: voice style, visual template (Canvas for technical audiences, Sketch for warmer ones), duration, and optional logo. Golpo returns a job ID immediately and renders in the background. Video generation is not instant — it takes anywhere from 30 seconds to a few minutes — and it can occasionally fail, so:

• Store the job ID against the prospect's record.
• Poll or webhook for completion.
• On failure, retry once with the same script. If it fails twice, escalate to a human queue.
• On success, save the MP4 URL, thumbnail URL, and duration.

The prospect's state is now video_ready.

Step 5 — Embed a Thumbnail, Not the Video

Email clients block embedded video. Every time. Do not fight this. Instead, embed a clickable thumbnail image (the one Golpo returns) that links to a lightweight landing page where the video autoplays. The landing page should have exactly one action — usually "reply to this email" or "book a 15-minute call" — and nothing else. No nav, no other CTAs, no upsell. One page, one video, one action.

Step 6 — Throttled, Logged Sending

Send through Apollo sequences or your own provider, but throttle aggressively. Each inbox should send no more than 30–50 cold emails per day to protect deliverability. Log every send: timestamp, message ID, prospect ID, video URL. Capture replies, bounces, opt-outs, and clicks on the thumbnail. These logs feed the optimization loop later.

The prospect's state is now sent.

How This Scales to 10,000 Prospects

The architecture above scales linearly because every step is state-driven. Each prospect carries a single status field — new → enriched → brief_created → video_ready → sent — and workers pull whichever prospects are due for the next step. Nothing relies on a long-running script holding state in memory. Nothing depends on manual coordination.

• Queues handle throughput. Enrichment, brief generation, video render, and sending each run as independent workers. If Golpo's API gets slow, that queue backs up; the others keep moving.
• The database prevents duplicates. A prospect already in video_ready won't get re-enriched if you accidentally re-import a CSV.
• Failures don't cascade. If one prospect's brief generation fails, only that record moves to a brief_failed queue. The rest of the pipeline keeps moving.
• You can rerun any step. Re-derive the script from a fixed brief. Re-render the video with a new template. Re-send to a stale segment. The state machine makes every step idempotent.

Ten thousand prospects through this system is the same code as ten prospects, just with more workers.

Quality Control Is Built In

Volume creates risk. The bigger the campaign, the worse a single hallucinated claim looks. Build QA into the pipeline, not on top of it:

• Constrained claims. Claude works from an explicit list of approved and banned claims. New claims require a one-line addition to the list, not a prompt rewrite.
• "Unknown" is a valid output. If the enriched record is missing a fact Claude wants to cite, the brief field is unknown and the script avoids that angle entirely. Better to be vaguer than wrong.
• Tier-based sampling. Top-tier accounts (your top 100 by ACV potential) get human review of every video before send. Mid-tier accounts get a sample reviewed. Volume tier gets automated checks only: script length within target ± 20%, brand terms spelled correctly, no banned phrases.
• Reply review. Every reply gets read by a human before any follow-up — both for sales judgment and to catch quality issues the automation missed.

Measuring What Actually Matters

The vanity metrics in outbound are open rate and click-through rate. They're directional at best — opens are inflated by image proxies and clicks include accidents. The metrics that actually decide whether the system works:

• Video watch time on the landing page. If the first 10 seconds don't hold, the hook is wrong. Tune the brief.
• Reply rate, segmented by ICP filter. Different filter slices produce wildly different reply rates. Cut the ones that don't perform.
• Meetings booked per 1,000 sends. The only metric that ties the entire pipeline to revenue.
• Pipeline created and revenue per campaign. Eventually, the only thing that justifies the whole stack.

Feed these numbers back into three places: the prompts that generate the brief, the ICP filters in Apollo, and the target video length. The system gets better the longer it runs — not because the AI gets smarter, but because the constraints get tighter.

The Mindset Shift

The biggest mistake teams make when they try to copy this is treating it as a "video tool with AI on top." They obsess over the visual style, the music, the avatar. None of that is the bottleneck. The bottleneck is the brief — the structured object that tells the system what this prospect actually cares about and how your product solves it.

Treat the brief as the product. The script is a function of the brief. The video is a render of the script. The email is a wrapper around the video. Every quality problem in the pipeline traces back to a thin or wrong brief. Every reply-rate jump traces back to a sharper one.

That is what makes ten thousand emails feel like ten thousand individual conversations.

Building It With Golpo

Golpo's role in this system is deliberate: high-quality whiteboard-style video, generated from a script via API, async, with consistent branding. You don't need a video editor, an animator, or a creative team in the loop. The script goes in; the MP4 and thumbnail come out. The rest of the pipeline — Apollo, Claude, the queues, the landing page — is plumbing you can build in a weekend on top of whatever stack you already use.

Start with one ICP slice, one product, and 50 prospects. Hand-review every brief, every script, and every video before you send. Once the quality bar is repeatable, swap in the queues and the automated sampling and turn the volume up. The pipeline scales; your taste sets the ceiling.

Start at video.golpoai.com to render your first script as a video, or book a demo if you want to walk through the API integration before you build.