Portfolio: the system behind a campaign

01 / Data engineering

Lead qualification pipeline

Turns a raw company list into a short list the companies' own websites confirm, spending money only on what survives the free steps.

Python, headless Claude Haiku scoring, SQLite cache, 11 unit tests on the grounding step

The problem

A bought or scraped list is mostly the wrong companies. A database export of "marketing agencies" holds holding-company subsidiaries, associations, dead sites and firms that do something else entirely. Every enrichment credit and every email spent on those is wasted, and the sending reputation takes the hit.

This pipeline keeps only companies whose own website matches a written buyer definition. Each paid step sees only what survived the cheaper step before it.

One real run

4,138 rows of independent agencies, scored against a one-sentence buyer definition.

Model cost for the scoring step on that run was $1.54 for 1,368 sites, about $1.13 per 1,000. A 100-row pilot on a different niche cost $0.10 and kept 12, which shows a niche is thin before any more rows get pulled.

How it works

A model can write a detail that sounds right and is missing from the page, so step 5 checks every fact against the site. On a test set, 17 of 18 real facts passed and all 10 deliberately wrong ones were caught. A spelled-out count ("six advisors") always fails, because code cannot count names on a page.

What broke, and what changed

• Dropping every free-mail and role address in the first stage also dropped good companies on lists built from map data, where the only email is the firm's own. In one early run that removed 16 of 33 good firms. Company-first lists now get their own flag.
• Scoring a vague buyer definition with no sample run first produced confident, wrong scores. A --sample 100 mode now scores a random 100, prints the 10 best and 10 worst with reasons, and stops so a person reads them before the full run.
• Models approve marginal companies to be helpful unless told what the buyer is not. The definition now takes an explicit exclude list.

Use it yourself

Start with a CSV that has a domain column, then apply the same four rules:

1. Write the buyer as one sentence, plus a separate list of what they are not.
2. Sample 100 first. Read the 10 best and 10 worst reasons before running the rest.
3. Require a written reason on every verdict, and tell the model to answer "none" when the page does not say.
4. Run a cheap model on everything, then a stronger one only on the survivors.

You are screening companies for a cold outreach list.
BUYER: <one sentence: who they are, what they sell, who they sell to>
NOT THE BUYER: <comma list: associations, resellers, subsidiaries, ...>
You will get the text of a company's homepage.
Score 0 = not the buyer, 1 = unclear, 2 = clearly the buyer.
Return JSON: {"score": 0|1|2, "reason": "one sentence quoting the page"}.
If the text is empty or unrelated, score 0 and say so. Never guess.

02 / Revenue operations

Reply triage system

Classifies every prospect reply, picks the one correct next move, drafts it, and leaves the send to a person.

Playbook skill, eleven reply codes with answer-time targets, send guards with 21 tests

The problem

Cold email produces a trickle of replies, and most of the value sits in a few of them. A reply that waits a day books a fraction of what the same reply books in fifteen minutes. A wrong reply costs more than a late one: the wrong price, the wrong offer for that campaign, a calendar link nobody asked for, or a second email to someone who asked to be removed.

This system classifies every reply, decides the next move, drafts it, and stops. A person sends it.

The eleven reply types

Every reply gets exactly one code. If a reply mixes types, the highest-value intent wins.

A reply that only says "send me info" counts as neutral. A reply that asks a question counts as positive.

The rules that stop mistakes

Offer first. Before any reply, look up which offer that campaign sold. Campaigns carry different terms, and a reply with the wrong structure contradicts the email the prospect answered.

No dollar figure in any reply. Price comes up on a call.

No calendar links. Offer two specific times as text.

Nothing sends itself. Replies, reminders and follow-ups are drafts. Automatic replies are off in production.

An unsubscribe suppresses the whole domain, everywhere, before anything else happens.

Reply rates use contacts sent as the denominator, with machine replies removed first.

Speed is a rule because of a third-party benchmark from a lead-gen firm's client data: an answer under 15 minutes books about 73% of positive replies, four hours about 31%, a day or more about 12%. The answer-within column above comes from it. The same source puts a healthy ratio of booked calls to positive replies at 45 to 60%, and anything under 35% points to broken reply handling.

Four numbers decide whether reply handling works: positive replies per 1,000 contacts, booked calls per positive reply, calls that show, and minutes from reply to answer. The next addition is a pre-call reminder sequence, because cold-sourced meetings no-show more often than inbound ones.

Try the sorting

Use it yourself

Paste this into any assistant with a reply in hand. It returns the code and a draft.

Classify this reply from a cold email prospect with exactly one code:
A yes/book, B price ask, C wants it in writing, D objection, E send info,
F wrong person/referral, G not now, H not interested, I unsubscribe/angry,
J out of office, K quiet after yes.
If several apply, pick the highest-value intent.
Then draft the reply: under 60 words, no dollar figure, no links,
two specific times as plain text if a call is the next step.
If code is I, do not draft. Say: suppress the domain.
Thread:
<paste>

03 / Buying signals

Signal radar

Watches public sources for the moment a buyer needs you, and checks one real, dated signal per lead before any email mentions it.

Python, scheduled weekly Slack scoreboard, 17 unit tests

The problem

Some services only sell when the buyer has a need right now: they just raised money, they are hiring for the role your service replaces, or a public event affects them. A static list cannot show when that happens. A signal detector watches public sources and reports who changed this week.

There are two pieces. One measures how often a market announces demand before any money goes into it. The other checks one real, dated signal per lead before any email mentions it.

Piece one: the radar

It subscribes to public feeds for each candidate market, counts qualifying events per week, and posts a ranked scoreboard to Slack every Monday at 08:00 from a scheduled job.

A dead feed still parses and still returns entries, all of them old. One trade feed parsed fine with a newest item 757 days old, and another was 532. Read at face value, a dead feed looks like a quiet market and gets a good market rejected. Every run now starts with a liveness check, every digest prints a staleness warning, and a missing feed is reported as missing, never as zero.

The radar ranks markets already on the list. New markets come from what is already known and from neighbors of a market already running. 17 unit tests cover the counting and the staleness logic.

Piece two: the signal check

For every lead, it looks for exactly one verifiable signal and records its type, text, date and link.

Cost is about $0.0005 per lead. Filters exclude look-alike headlines such as charity fundraisers and community drives. A companion tool pulls one row per hiring company, collapses repeat postings, keeps the newest, and refuses to run if it would drain the data pool below a reserve.

What broke, and what changed

• Dead feeds, described above.
• A funding "year" from one data source is a year with no date. Claims in copy now require a real posting or news date.
• A model asked to find a signal will invent one. The check returns "none" when nothing verifiable exists.

Use it yourself

The method works with free tools and a spreadsheet: Use a model that can search the web, because it has to find a dated source for each company.

1. Pick the one trigger that comes before a purchase of your service.
2. Find a public feed or search that shows it, and check that the newest item is under a week old.
3. Log the date, company and source link. Count per week.
4. Only email a company whose signal is dated and linkable. If there is none, send the plain offer.

For each company below, search for ONE signal: raised funding in the last 240 days,
or an open <role> posting in the last 30 days.
Return: type (funding|hiring|none), the exact headline or posting title,
its date, and its URL.
If you cannot find a dated, linkable source, return type none.
Do not infer, estimate or fill in a date.
Companies:
<list>

04 / Messaging systems

Messaging generation and copy gate

Writes cold email variants from one offer and one fact per lead, then blocks any variant that breaks a written rule before it can reach a sending tool.

Python gate scripts shared by build and send time, a failing-build voice test, browser demo below

The problem

A model asked for cold email copy writes the same email every time, in the same cadence, with the same openers. Prospects read that cadence in one line. The rules for avoiding it also tend to live in prose, and prose does not stop anything: the same tics came back after being banned in writing several times.

This system generates variants from a fixed structure, then runs every variant through checks that fail loudly. Nothing reaches a sequencer until the checks pass.

How it works

The same voice and repeated-word checks run again when the campaign is started, so copy edited by hand after the build still gets checked. Outward-facing page copy is covered by a unit test that fails the site build on the same tics.

What broke, and what changed

• A rule written as a sentence in a doc did not stop the tics. The same cadence was banned in writing repeatedly and kept coming back until the rule became a test that fails the build. Fix the copy, never the test.
• A line like "cafes opening, cafes still dialing in" passed review and went into a live preview. The repeated-word check came from that miss.
• A closing line that promised to stop emailing on silence was false, because the system does follow up. It is now a hard fail.
• Hype words from a generic spam list would have rejected every email, so single words are not enforced from it and only phrases are.

Try the checks

A browser-only version of the length, question, filler, link and ask checks. The text never leaves this page.

Use it yourself

Try the checks on your own email below, then use the prompt to generate variants that hold the same rules.

1. Pick one fact about the company that is on their own site, and one offer.
2. Write the email as: that fact, what you do about it, one question.
3. Run it through the checks. Fix the copy, not the rule.
4. Change one thing between variants: the angle or the subject, never both.

Write 3 cold email variants, 30 to 75 words each.
Fact about the company (from their own site): <fact>
What I offer: <one sentence>
Structure: the fact, what I do about it, then exactly one question.
Rules: no em dashes, no exclamation marks, no links, no "quick question",
no "robust" or "unlock", no "it's not X, it's Y", no tee-up opener
like "I hope this finds you". Do not repeat a content word inside one sentence.
Every variant must end on the same question. Vary only the angle.

05 / Market selection

Market screening test

Decides whether a market is worth a campaign before a list is bought, by scoring a sample of 40 companies against one sentence and a bar that was set in advance.

A Python test that pulls company rows, a small model that reads each company's own website, a fixed pass rule

The problem

A market looks large on a registry or a directory and shrinks once the wrong companies come out. One registry listed about 4,000 repair stations, and the independent ones left after filtering came to between 40 and 65. A campaign built on the registry figure would have spent on a list that was never the buyer.

This test decides before any money is spent on a list. It samples companies, reads each company's own site, and scores it against one written sentence about the buyer. The pass rule is fixed first, so the result cannot be argued into a yes.

One real run

One market, start to finish: independent forklift and lift truck dealers.

The rule needed at least half the sample to be the buyer and at least 40 firms in the market. It passed. A hand check of the 25 then cut 7 more on ownership, because they belonged to a parent group or had been sold, so the independent pool is smaller than the raw estimate.

How it works

Two limits are written into the rule. A company that lists the buyer's industry as one of several is not counted as the buyer unless it is its primary market. And a market that passes the sample still needs a hand check on ownership before a list is built.

Try the pass rule

Use it yourself

Write the buyer as one sentence, set the bar before you look, then score a sample of 40 with the prompt below.

1. Write one sentence: who the buyer is, and who it is not.
2. Set the bar first: what share of the sample must be the buyer, and how many firms the market must hold.
3. Pull one row per company, not one per person, so a large firm does not fill the sample.
4. Read each company's own site, score it, and count.

You are testing whether a market is worth a campaign.
The buyer is: <one sentence, including who it is NOT>
For each company below, read its description and homepage text and answer with one word:
BUYER, UNCLEAR or NOT. A company that lists this industry as one of several
is NOT unless it is clearly its primary market. A company owned by a parent group is NOT.
Return the list, then the counts of BUYER, UNCLEAR and NOT.
The market passes only if BUYER is at least half the sample and the market holds at least <N> firms.

06 / Messaging systems

Per-lead fact check

Checks that the one personal line in an email appears on the company's own website, and blanks the line before upload if it does not.

A Python check with no model and no cost, wired into the pre-launch checks and the upload step

The problem

An email that opens with a detail about the recipient lands only if the detail is true. A model can write a detail that sounds right and is wrong: a wrong year, a wrong city, a customer they do not have. A prospect who spots one stops reading.

This check reads the same pages the line was written from and compares them to the line. A line it cannot find is blanked, so the email goes out without it and not with a wrong one.

One real run

A test on 20 real leads in one niche.

Every wrong fact was caught and none passed. The one real fact it rejected was a spelling variant, which is the direction it should err.

How it works

Checking only the home page failed 9 of the 18 real facts on the first run, so the check reads the same three pages the writer read. It has not been tuned outside manufacturing.

Try the check

Use it yourself

Use the prompt to make a model give you a line plus the sentence it came from, then check the line yourself against the page.

1. Ask for one fact and the exact sentence on the page that supports it.
2. Check numbers, years and names against the page text.
3. Drop the line if it cannot be found. Send the email without it.

From the company website text below, write ONE factual line about the company
that you could open a cold email with, and quote the exact sentence from the text that supports it.
Rules: use only what is in the text. Do not infer a year, a city or a customer.
If nothing in the text supports a line, answer NONE.
Return: LINE: <the line>   SOURCE: "<the exact sentence>"

07 / List quality

Two-verifier email gate

Runs every address through a second, independent verifier and blocks the campaign if any lead has an invalid result, a server error or no result at all.

A Python filter around a verification API, the same check run again inside the pre-launch checks

The problem

One verifier is the only check between a bad address and the sending domain, and a bounce hurts the domain's reputation. The data source's own 'verified' flag is one opinion, and nothing in our pre-launch checks read it.

This gate adds an independent second opinion and makes a missing result a failure, so an unverified lead cannot slip through because nobody ran the check.

One real run

The first list through the gate.

The 13 unknown leads were paused before any send. Valid and accept-all leads go in, and accept-all leads go out at lower volume.

How it works

The pre-launch check runs the second verifier itself on any active lead that lacks a stamp, and writes the stamp back once it has a result. The verifier is rate limited, so a large list runs slowly and the check is built to resume.

Try the sorting

Use it yourself

Use the prompt to have an assistant write the filter for your own list, then run every list through it before an upload.

1. Verify with a second tool, not the one that supplied the list.
2. Split the results into valid, accept-all, unknown and invalid.
3. Load valid and accept-all only, and send accept-all at lower volume.
4. Make a missing result a failure, not a pass.

Write a Python script that takes a CSV with an email column, checks each address with
<verifier API>, and writes four files: valid.csv, accept_all.csv, unknown.csv, invalid.csv.
Respect the API's rate limit, resume from where it stopped if it is interrupted,
and print the count in each file. Never put unknown or invalid addresses in a file that is uploaded.

08 / Approval

The 10-lead preview

Shows ten real leads, the line and the source behind each, and exactly what each prospect would receive, so the list and the copy are approved before anything is sent.

Research on public sources, a render script that fills the email as the sender will send it

The problem

A list can pass every automatic check and still contain a lead that looks wrong the moment a person reads it. A preview puts ten real leads in front of the buyer, with the evidence for each, before a campaign exists.

The render script prints each email with the spintax chosen and the variables filled. A missing variable prints as a visible marker, so an empty name cannot reach a prospect unseen.

What each lead in the preview carries

On the forklift dealer market, of the 25 companies in the pull, 9 passed clean and 7 were cut because ownership failed on the evidence. A preview that shows only the survivors would hide that, so the cut companies and the reason are kept with it.

Why it comes before the list

The preview is the approval step. The buyer sees the people, the lines and the emails, and corrects them while changing them costs nothing. After approval the campaign is built from what they saw.

Try the render

Hi Chad,

Fairfield has sold lift trucks since 1982. We email the plants in <<MISSING territory>> that run lift trucks.

Shall I show you what that looks like for Fairfield Lift?

Use it yourself

Ask for the preview in this shape for your own market before you commit to a list. Use a model that can search the web, because it has to find people, sources and ownership. A model without search will tell you it cannot.

1. Ask for ten leads, not a count.
2. For each, ask for the person, the title, the line, the link that proves it, and the ownership evidence.
3. Read the emails as the recipient will, with every variable filled.

Build a 10-lead preview for this market: <one sentence describing the buyer>.
For each lead give: person and title, company and city, one checkable fact, the URL that proves it,
and the evidence the company is independent (not owned by a manufacturer, a private equity firm or a parent group).
Then write the email exactly as it would be sent, with every variable filled in.
Use web search. If you cannot source a line, write NONE for it. If you cannot search the web, say so and list what to look up instead. Do not guess.

09 / Send safety

Preflight and launch gate

A set of checks a campaign must pass, a fingerprint that voids the pass if anything changes afterwards, and a hook that refuses to start a campaign without a fresh pass.

Python checks, a command hook on the sending tool, a monitor that runs after start, a weekly sweep of every draft

The problem

Most sending mistakes are things that were checked once and changed later: a lead added to a live campaign, copy edited by hand, a setting flipped. A check that runs only once does not stop them.

This system makes the check a condition of starting. The start command is refused unless a pass from the last 12 hours exists, and the pass is voided if the copy, leads, inboxes or settings change after it.

How it works

The gate blocks and acts. None of it is a reminder to be careful. It does not judge whether a campaign is a good idea, only whether it is safe to send.

Try the gate

Use it yourself

Use the prompt to have an assistant design the same gate around your own sending tool.

1. List the checks a campaign must pass and make each one fail loudly.
2. Store a fingerprint of everything the checks read.
3. Refuse the start command without a pass that matches the fingerprint.
4. Watch the first minutes after a start, and pause on a bounce spike.

Design a launch gate for a cold email sending tool.
Requirements: a list of checks that must all pass; a stored pass with a hash of the copy, leads, inboxes and settings;
a rule that the start command is refused if there is no pass from the last 12 hours or the hash no longer matches;
a monitor for the first 15 minutes after start that pauses the campaign if the bounce rate reaches 7% on at least 20 sent;
an override that can only be set outside the session. Use exactly these numbers. Output the checks, the data stored, and the refusal message.