how to build a customer acquisition system that gets smarter after every lead

you spend money on ads today. leads arrive today. and the real reason last month's deals died is still sitting inside a call recording nobody has opened since.

the ad account knows what a lead cost. it does not know if the lead was any good. the sales side knows exactly why each deal stopped, and that knowledge lives in a head, a notepad, or a recording that gets archived and forgotten.

so the next campaign gets written from memory and mood. you pay a second time for a lesson you already bought.

a customer acquisition system gets smarter after every lead when the sales process records what happened, why it happened, and what should change, then routes that evidence into the next campaign.

Campaign → lead → sales outcome → buyer signal → better next campaign

here is what that looks like once it runs. a call ends. ten minutes later the lead record is filled in, the buyer's own words are saved under the ad angle that brought them, and a card is sitting in a Discord channel asking one question.

friday morning, before you open your laptop, the review is finished. the biggest leak is named with the lead ids behind it. three paused ad sets, written from lines real buyers said out loud this week, are already built in the ad account and waiting for one yes.

the whole machine is one chain:

call ends → Fathom sends the transcript → Hermes reviews it against your rules → writes the lead record → posts a decision card in Discord → the nightly check flags unfinished leads → the friday review finds the repeated pattern → drafts new ads from real buyer words → builds them paused through autoady → you approve → next campaign

here is what you will build:

> the stack, nine slots and you probably own six already.

> ten rule files that your team and your agent both read.

> three routines the agent runs on its own.

> six wires that carry one lead id from the click to the cash.

> decision cards in one Discord channel where your only job is yes or no.

> a seven day install.

copy every block as you read.

1. pick the stack

slot 1. Meta Ads Manager. this is where the money leaves and where the source of every lead gets stamped. at the ad level you fill the URL parameters field with one string so every click carries its own labels.

utm_source=meta&utm_campaign={{campaign.name}}&utm_adset={{adset.name}}&utm_ad={{ad.name}}&ad_id={{ad.id}}

slot 2. a landing page and a form with hidden fields. Typeform, Tally, HubSpot forms, or the form on your own site. hidden fields are invisible boxes that catch those labels and carry them with the submission.

slot 3. a CRM with pipeline stages, custom fields, activities, and an API. Pipedrive or HubSpot both do this. the smallest honest version is one Google Sheet with a row per lead. an API is just a door that lets software read and write your data without a human clicking. Hermes can read and write both a CRM and a Google Sheet through their APIs or MCP servers.

slot 4. a booking tool. Calendly or Cal.com. the only thing that matters is that your booking link can pass lead_id through, so the meeting comes back attached to the right person.

slot 5. Fathom as the call recorder. it records Zoom, Google Meet, and Teams calls. it has an API at a fixed address that takes an API key in the X-Api-Key header, and you generate that key in User Settings under API Access. it also has webhooks that fire when a new meeting's content is ready, and the payload can include the transcript, the summary, and the action items. you add one under API Access with Manage, then Add Webhook, then a destination URL, then a choice of which recordings trigger it and what data to send. it has an MCP server and an official Claude connector. one thing to know up front: an API key only reaches meetings you recorded, or that were shared with you or your team.

slot 6. Hermes as the agent. this is the part that makes the system run without you. Hermes is an open-source agent that lives on a small server, and a cheap VPS is enough. it keeps a folder of skill files and memory, connects to MCP servers, runs scheduled jobs, accepts webhooks, and talks to you through Discord or Telegram.

without slot 6 you still have a real system. you also have a human pasting every transcript, every export, and every row, forever.

slot 7. Discord as the approval surface. one channel called #acquisition. every card that lands there ends with one yes or no.

slot 8. autoady for the marketing half. it connects to your Meta ad account and reads spend, leads, CPL, CTR, and frequency for every live ad. it sweeps daily, shows which ads need attention and why, and queues the next safe action for approval. through its MCP it can also build campaigns, ad sets, ads, and copy. free for one account at autoady.io.

slot 9. Meta Conversions API for one positive event. three ways to send it: your CRM's built-in Meta integration, an automation step, or a small server function. you can also have Hermes send it when the stage flips.

the swap rule, once, for all nine slots. any tool here can be replaced by one that does the same job. Fathom can be tl;dv or Fireflies if they give you a webhook with the transcript. Hermes can be another agent runtime that accepts webhooks and runs scheduled jobs. the rules and the routines below do not care which brand sits in the slot.

do not connect anything yet.

2. write the rules as files

a system that thinks needs written rules, because a rule inside somebody's head cannot be read by a teammate or by an agent.

so the rules become files. plain text. your team opens them in a shared drive. Hermes gets the same folder uploaded as skills, which means the agent and the humans argue from the same page instead of two different memories.

the folder is called acquisition-system. ten files.

acquisition-map.md says who owns what.

# acquisition map path: 

ad → page or form → new lead → scheduled → confirmed → showed → qualified → proposal → won or lost → cash collected → reason → next campaignmarketing owns: source, promise, ad, page, formsales owns: contact, stage, outcome, reason, buyer evidence, next actionoperations owns: the join, missing-record checks, the agent, weekly reviewfounder approves: spend, price, offer, sales policy, customer contact, positive event, every new campaign one lead_id follows the person from form to cash

tools: [list your stack here, one per line]

stage-rules.md stops the pipeline from lying to you. a stage is a claim, and every claim needs proof.

# stage rules  
a lead moves only when the proof for the next stage exists  
new lead: known source and one lead_id  
scheduled: a real call time exists and confirmation was sent  
confirmed: the lead replied yes to the confirmation  
showed: the call happened and a transcript exists  
qualified: the lead met the written rule in qualification-rule.md  
proposal: a specific offer was presented with a next step, owner, and due date  
won: the buyer accepted under our written definition of won: [write it]  
lost: the deal stopped and one reason from reason-codes.md was recorded  
cash collected: the payment system confirmed the money arrived  
if the proof is missing, keep the current stage and flag the missing fact

reason-codes.md is the short list of why deals stop. a short list is what makes counting possible.

# reason codes  
pick the first clear reason the deal stopped. one reason per lead. extra detail goes in the call note.  
no answer  
no-show  
wrong fit  
no authority  
timing  
price or weak value  
trust or missing proof  
competitor  
offer mismatch  
unknown  
banned: bad lead

"bad lead" is banned because it hides the answer. it can mean the ad promised the wrong thing, or the form let anyone through, or nobody called back in time. those are three different fixes with three different owners.

qualification-rule.md is your definition of a good buyer, written down before you need it.

# qualification rule  
a lead is qualified when all of these are true:  
fit: [who you serve, in one line]  
problem: [the problem you solve, in one line]  
authority: the person on the call can say yes or brings the person who can  
timing: [when they need it, in one line]  
ability: [what they need to be able to buy, in one line]  
if any line is unknown after the call, the lead is not yet qualified. record which line is unknown.

lead-record-columns.md is the shape of one lead. build these as custom fields in your CRM, or as columns in the sheet.

# lead record columns  
lead_id  
created_at  
utm_source  
utm_campaign  
utm_adset  
utm_ad  
ad_id  
page  
form  
name  
email  
phone  
stage  
stage_updated_at  
qualification_result  
problem  
desired_result  
buying_trigger  
objection  
proof_needed  
exact_buyer_words  
offer_presented  
outcome  
reason  
next_action  
owner  
due_date  
call_link  
reviewed_by  
cash_status  
positive_event_sent  
unknown_or_conflicting

positive-event-rule.md decides the one thing you will teach Meta to find more of.

# positive event rule  
the stage we want Meta to find more of: [booked, qualified, won, or paid]  
proof that stage is true: [copy the line from stage-rules.md]  
event name sent to Meta: [Lead, Schedule, Purchase, or your custom name]  
sent from: server through the Conversions API  
browser event also sent: [yes or no]  
if yes, both share the same event_id so Meta counts it once  
every lead stays in the lead record. only leads that meet this rule send the event.  
owner: [name]  
last tested: [date]

buyer-patterns.md is the new one, and it is the file that turns sales into marketing.

# buyer patterns  
hermes updates this after every reviewed call. humans read it before writing any ad.  
one block per ad angle. newest evidence on top.  
angle: [ad angle name]  
leads reviewed: [lead_ids]  
pains, in the buyer's own words:  
desired results, in the buyer's own words:  
buying triggers (what made them act now):  
objections and the proof they asked for:  
deepest stage most of them reached:  
most common reason they stopped:  
what this angle attracts that we want more of:  
what this angle attracts that we want less of:

ad-rules.md is the fence around anything the agent writes.

# ad rules  
hermes reads this before drafting any ad.  
offer: [one line]  
who we want: [copy from qualification-rule.md]  
who we do not want: [one line]  
claims we may make: [list]  
claims we may never make: [list]  
tone: [three words]  
every hook must come from a line in buyer-patterns.md. cite the lead_id.  
every new campaign enters PAUSED. a human turns it on.  
one angle per ad set. name: [angle]-[format]-[date]  
daily test budget per ad set: [amount you decide]  
never change price, offer, or sales script inside an ad test.

campaign-memory.md keeps the system from repeating itself.

# campaign memory  
one entry per approved change. newest on top.  
date:  
change:  
why: (the repeated reason and the lead_ids behind it)  
owner:  
what stayed fixed:  
result that judges it:  
result:  
kept or dropped:

decision-log.md is the one-line version, so a year of decisions fits on one screen.

# decision log  
one line per review  
date | biggest supported leak | lead_ids | owner | change | judged by | approved by

now fill every bracket. do not do it by staring at the files. paste this into Hermes or into Claude with the files attached, and answer the questions.

you are setting up my acquisition system. read the files. ask me one question at a time to fill every [bracket]. do not fill a bracket yourself. when done, print each file in full.

one question at a time matters. it stops you from writing a paragraph where one line was needed, and it stops the model from inventing your business for you.

3. wire the lead in

wire 1, ad to form. in Meta Ads Manager, open each ad and paste the parameter string into the URL parameters field. on your page, create hidden fields with the exact same names, plus one more called lead_id. give lead_id a unique value per submission, which your form tool or your site can generate. submit a test and check that every field arrived filled.

wire 2, form to CRM. connect the form to the CRM. map each hidden field to the matching custom field from lead-record-columns.md. set the stage to new lead on arrival, and send a message to the sales owner so a human knows within minutes.

wire 3, CRM to booking. the confirmation email or text carries the booking link with lead_id attached. the booking tool passes that value back when the meeting is created. write the call time into the CRM and set the stage to scheduled. when the lead replies yes to the confirmation, set confirmed.

three wires and the front half is done. one identifier now walks from the click to the calendar without anyone typing it twice.

4. wire the call to the agent

wire 4, Fathom to Hermes. in Fathom, open User Settings, then API Access, and generate the key. still under API Access, choose Manage, then Add Webhook. the destination URL is the route on your Hermes server, which ends in /webhooks/fathom-call on your server's address. choose your own recorded meetings as the trigger and include the transcript in the payload. then record a two minute test call with a colleague and watch for the card.

wire 5, Hermes to the CRM, autoady, and Discord. installing Hermes means putting the software on a small server you rent, so it stays awake when your laptop sleeps. once it is on, start the gateway, which is the part that listens for Discord messages and webhooks.

hermes gateway start

connect Discord during setup. it asks for the bot token and the channel, and after that Hermes answers you in #acquisition.

then add the two MCP servers. an MCP server is a standard door that lets an agent use another product's features directly.

hermes mcp add fathom --url https://api.fathom.ai/mcp

hermes mcp add autoady --url https://www.autoady.io/api/mcp --auth header

connect the CRM through its own MCP server, or with an API key by following your CRM's API key steps. upload the acquisition-system folder as skills so every routine reads the same rules.

now create the webhook route. this command makes the route Fathom will call, and the prompt inside it is routine 1 below.

hermes webhook subscribe fathom-call --deliver discord --prompt "[paste routine 1]"

then the two scheduled jobs. cron is a way to say run this at this time, every time.

hermes cron create "0 21   *" --name nightly-closeout --deliver discord "[paste routine 2 from section 5]"

hermes cron create "0 8   5" --name friday-review --deliver discord "[paste routine 3 from section 7]"

check your work with these two.

hermes cron list

hermes cron run nightly-closeout

routine 1, the call review. this is the prompt that fires when Fathom sends a finished call.

a sales call just ended. the payload contains the transcript and the invitees.  
find the lead in the CRM by the invitee email. if no lead matches, post "no lead found for [email]" in discord and stop.  
read stage-rules.md, reason-codes.md, and qualification-rule.md.  
use only the transcript and the CRM row. do not invent quotes, stages, outcomes, or buyer facts.  
fill these fields: deepest stage, qualification result and which line is unknown if any, problem, desired result, buying trigger, objection, proof needed, exact buyer words, primary reason if the deal stopped, next action, owner, due date.  
for every field, keep the exact line from the transcript that proves it.  
mark anything unproven as `unknown`. do not turn a guess into a fact.  
if the transcript and the CRM disagree on who the person is or what was offered, stop and post the conflict.  
write the fields to the lead record and set reviewed_by to "hermes, pending".  
add the pains, desires, triggers, objections, and exact words to the block for this lead's ad angle in buyer-patterns.md, with the lead_id.  
then post one card in discord:  
lead_id and name  
ad angle it came from  
deepest stage  
reason or next action  
the three most useful buyer lines  
anything unknown  
one question: approve this record? yes or no  
on yes, set reviewed_by to the approver's name. on no, leave the record pending and wait for the correction.

what the sales rep sees is small on purpose. a short card with the lead's name, where the deal got to, the reason or the next action, and three lines the buyer actually said. the rep reads it while the call is still fresh and types yes.

that is the whole job. no form to fill, no notes to write up later, no fight about whether the CRM is current.

the agent covers the call. humans cover the rest of the day, and the rest is four small actions.

after any contact that changes something, the owner sets the stage and the next action with a due date. when a proposal goes out, the owner writes what was presented and when the answer is expected. on a win, the owner records the offer accepted and the cash status. on a loss, the owner picks one code from reason-codes.md and puts the detail in the note.

5. the nightly check

people finish the call and forget the record. that is normal, and it is why the system needs something that looks every night without being asked.

read every lead whose stage_updated_at, next_action, or call_link changed today.  
check each one against stage-rules.md.  
list every lead that is missing a stage, a reason after stopping, a next action, an owner, or a due date.  
list every lead marked showed with no call_link.  
list every lead marked scheduled whose call time has passed with no stage change.  
list every record still marked "hermes, pending".  
do not change any record.  
post one card in discord with those lists, grouped by owner, each lead as a lead_id and a name.  
if every lead is finished, post "all leads finished" and nothing else.

at 21:00 the sales lead gets one card, split by owner. every name on it is a five minute fix that would have become a permanent hole in your data.

notice what the routine never does. it does not edit a record. an agent that silently repairs your pipeline teaches your team that the pipeline repairs itself, and then the pipeline becomes fiction.

a worked lead is unfinished when the stage, the reason, the next action, or the owner is missing. until tonight, nobody knew. now something tells you every single night, and the record stays honest enough to make decisions from.

6. route the problem to its owner

when a deal dies, the fix belongs to the step that failed. so read the reason and walk down this list in order. the first line that matches is your owner.

leads never reach the form, so the problem is the ad.

people reach the page and leave, so the problem is the page.

some start the form and stop, so the problem is the form.

the wrong people fill it in, so the problem is the ad promise and the form questions.

the right people never book, so the problem is routing and follow-up speed.

they book and never show, so the problem is confirmation.

calls happen and stall, so the problem is the sales call.

buyers ask for evidence you cannot hand them, so the problem is proof.

they want it and still say no, so the problem is the offer or the price.

money never lands after a yes, or it lands and they leave, so the problem is payment or delivery.

the discipline is to fix the step that failed. a founder whose deals die at the proof step will rewrite the ad, because the ad is the easy thing to touch. the ad was never the problem, and next month looks the same.

then there is the question of how much evidence you need. climb this ladder.

one lead with a clear reason is a note. write it down and move on.

several leads that share a stage, a reason, a source, an ad angle, an offer, or a buyer fact are a pattern. now you may act.

a change you make on purpose, with everything else held still, is a controlled test. the result either holds or it does not.

a result that holds twice becomes a rule, and the rule goes into the files so it survives the person who found it.

i will not give you a lead count for that second rung, because your deal size and your volume decide it. what does not change is the shape of a supported decision. name the leads and the stage where they stopped. write what they share. then the one thing that changes, everything that stays fixed, and the result that will judge it next week.

7. the friday review that writes the next ads

this is the routine that closes the loop back into the ad account.

read every lead record from the last seven days, buyer-patterns.md, ad-rules.md, campaign-memory.md, and the current ad setup.  
use only those records. do not invent causes, quotes, stages, or patterns.  
first find where good buyers stopped. a good buyer meets qualification-rule.md.  
group leads only when they share a supported stage, reason, source, ad angle, offer, or buyer fact.  
a single lead may create a note. it cannot create a pattern by itself.  
route the biggest supported leak to the part that owns it: ad, page, form, qualification, routing, follow-up, confirmation, sales call, proof, offer, price, payment, or delivery.  
then read the autoady sweep for the same seven days and place spend, leads, and CPL next to each ad angle's sales outcomes. an angle with cheap leads and no qualified calls is a leak, whatever the CPL says.  
then draft the next test. use buyer-patterns.md only. every hook must quote or closely follow a real buyer line and cite its lead_id. follow ad-rules.md for claims, tone, and naming.  
write up to three angles. for each: the angle name, the buyer lines behind it, three hooks, one primary text, one headline, and the ad-set name.  
build them in the ad account through autoady as one testing campaign, one ad set per angle, every ad set paused.  
post one card in discord:  
biggest supported leak, with lead_ids  
cause or unknown  
owner and one proposed change  
what stays fixed  
result that will judge it  
the paused campaign name and each ad set name with its hooks  
approval needed: change yes or no, campaign on yes or no  
then write the campaign-memory.md entry and the decision-log.md line, marked "awaiting approval".  
if missing outcomes prevent a supported decision, post that and build nothing.

read that again and see what just happened.

the same evidence that explains why deals stopped is now the raw material for the next ads. a pain a buyer said out loud on tuesday becomes a headline on friday, with the lead id sitting next to it so anyone can check the source.

that is the difference between writing ads and harvesting them. nobody sat in a room guessing what the market wants. the market already said it, on the phone, in its own words, and the system kept the receipt.

the sweep matters just as much. cheap leads with zero qualified calls will look like your best ad angle in Ads Manager forever, because Ads Manager cannot see a sales call. placing spend and CPL next to sales outcomes is what stops you from feeding the angle that fills your calendar with people who were never going to buy.

then the campaign gets built and left paused. you read the card, you say yes or you say no, and marketing turns it on. price, offer, sales script, and other live ads all stay fixed, because one change at a time is what makes next friday's result mean anything.

the entry lands in campaign-memory.md with the reason and the lead ids behind it. in three months you can read the file and see exactly which buyer told you to make each change.

8. send Meta one true signal

wire 6, CRM to Meta. build the positive-event path with your CRM's Meta integration, an automation step, a small server function, or Hermes. set the trigger so it fires only when the stage equals the one written in positive-event-rule.md. use the same event_id as any browser event for that person. mark positive_event_sent on the record. then confirm in Events Manager that exactly one event arrived for one eligible test lead.

every lead stays in your system. Meta only ever hears about the ones that met your written rule.

that is the whole point. an ad platform will happily find you more of whatever you tell it to find. if you send it every form fill, it finds you form fillers. if you send it only the stage you actually want, it starts hunting for people who look like the ones who got there.

choosing that stage is a real decision, so use three tests. how long does the stage take to happen, because a signal that arrives many weeks late teaches slowly. how many of them happen, because a stage that occurs rarely gives the platform almost nothing to learn from. and how clean is the record, because a stage your team sets inconsistently will teach the platform your sloppiness.

qualified is a common answer and it is not the universal one.

a business with fast, frequent wins can send won.

a business with long sales cycles and thin volume may have to send booked and live with the noise.

the Conversions API is the server-side way to tell Meta something happened. instead of the browser reporting an event when a page loads, your system sends the event directly from software to Meta. that matters here because the stages you care about happen days after the click, inside your CRM, where no browser is watching.

event_id is the deduplication key. if the same person triggers both a browser event and a server event, giving both the same event_id lets Meta recognise them as one thing and count it once. without it, you inflate your own numbers and then optimise against the inflation.

9. one lead through every tool

say someone is scrolling and sees an ad about growing faster. they click.

the parameters ride along and the hidden fields on the page fill themselves with the campaign, the ad set, the ad, and the ad id. they submit the form.

a record appears in the CRM at stage new lead with a lead_id. the sales owner gets a message. the confirmation goes out with a booking link that carries the same lead_id.

they book, so the stage becomes scheduled. they reply yes to the confirmation, so the stage becomes confirmed.

the call happens on Zoom and Fathom records it. when it ends, the webhook fires and Hermes reads the transcript against the rule files.

what it finds: the person has the problem, wants the result, and cannot decide alone. their business partner has to be in the room.

so the fields get written. qualification result says the authority line is unknown, and the reason is no authority. its exact line about the partner is saved, and the next action becomes a follow-up call with both of them, with an owner and a due date.

the card lands in #acquisition. the rep reads it, sees the three buyer lines, and types yes. buyer-patterns.md gains that evidence under the ad angle that brought this person in.

at 21:00 the nightly check runs and finds nothing missing on this lead, so it does not appear on the card.

friday morning the review reads the week. three other leads from that same ad angle stopped in the same place, for the same reason. that is a pattern.

the leak gets routed to the ad message and to the form, because the angle is speaking to someone who cannot say yes on their own.

so Hermes drafts one angle aimed at the person who does decide. the hooks come straight from what those four buyers said, each with a lead id attached. it builds the campaign through autoady, one ad set, paused.

the card asks two questions. the founder says yes to adding an authority question to the form, and yes to turning the campaign on. marketing flips it live.

next friday judges it.

10. install it in seven days

day 1. write the ten files. run the setup prompt and answer one question at a time. done when two people on your team, given the same old lead, pick the same stage without arguing.

day 2. wire the ad to the form to the CRM. done when a test submit shows every hidden field and a lead_id sitting in the CRM record.

day 3. wire the booking link. install Hermes on the server, start the gateway, and connect Discord. done when Hermes answers you in the channel.

day 4. generate the Fathom key, add the webhook pointing at your Hermes route, add the Fathom MCP. record a two minute test call. done when the call card lands in Discord with the fields filled and the buyer lines quoted.

day 5. upload the acquisition-system folder as skills. create the nightly cron and run it once against old leads. done when the closeout card lists every unfinished lead correctly and changes nothing.

day 6. connect autoady, create the friday cron, and run it once. done when a paused campaign exists in the ad account with hooks that cite lead ids, and nothing is turned on.

day 7. build and test the positive-event path. done when Events Manager shows one event for one eligible test lead, and nothing at all for an ineligible one.

after that, the week runs like this.

a call ends and the record writes itself. the nightly check catches whatever got missed. friday, the review names the leak and the next ads are already built from what buyers said out loud. you say yes.

the next campaign starts with everything the last one learned.

11. what you just built

the sales half of this is yours. ten files, three routines, and a channel where the only thing anyone types is yes or no. it costs you a weekend and it stops your best evidence from dying inside call recordings.

autoady is the marketing half. it watches every live ad daily, tells you which ones need attention and why, and builds the paused tests the friday review writes. free for one account at autoady.io.

sales teaches the record. the record teaches the review. the review writes the next ads.