A UK marketing agency's sales process, rebuilt as a system that runs itself

The situation

A UK digital marketing agency selling growth services to small businesses had a sales process that existed, but only in people's heads and inboxes.

Enquiries arrived through the website, phone, and chat, and were handled by whoever picked them up. Contracts went out manually and got chased when someone remembered. Invoices sat unpaid because nobody had a system for escalating them. And when a deal did close, moving that client into delivery meant a set of manual handoffs that were easy to skip when things got busy.

The four specific problems:

Enquiries weren't qualified before they reached a human. Every enquiry, serious buyer or casual browser, consumed the same amount of someone's time.

Contracts stalled silently. An NDA would go out and then nothing. No follow-up sequence, no visibility on who had signed and who hadn't, no trigger telling anyone to chase.

Invoices needed chasing that nobody had time for. Payment reminders were manual, which meant they were inconsistent, which meant money arrived later than it should have.

Sales and delivery were disconnected. A won deal didn't automatically become an onboarded project. Somebody had to remember to start it.

What I found

Mapping the process surfaced one structural issue that shaped the whole build.

The agency's real bottleneck wasn't lead volume. It was the gap between stages. Leads came in fine. Calls got booked. But every transition between stages depended on a human noticing that the previous stage had finished. Enquiry to qualification, call to contract, contract to payment, payment to delivery. Each handoff was a place where a deal could go quiet for a week and nobody would know.

So the system had to do two things: qualify before a human is involved, and make every stage transition automatic, with a task attached so the responsible person knows what's expected.

What I built

An end-to-end GoHighLevel system covering the full journey from first enquiry to onboarded project.

AI chatbot and voice agent on the front door

An AI agent handles first contact on the website chat widget in Auto Pilot mode. It replies from trained data rather than just suggesting responses to a human.

It's configured with real actions, not just conversation: appointment booking, workflow triggering, contact info capture, human handover, and a stop condition so it knows when to step back. It's trained on the agency's own material (setup timelines, requirements, what the service involves), so the answers are the agency's answers.

Alongside it, a voice AI agent takes calls and does structured work during and after them: triggers the follow-up workflow mid-call, books appointments, and extracts email, phone, first name and last name into the CRM automatically. A call becomes a properly populated contact record without anyone typing.

The chat widget runs both channels (live chat and voice AI) from one sticky widget.

A nine-stage sales pipeline

The full commercial journey, mapped to stages that reflect what happens:

Plus an Irrelevant / Lost stage, so dead leads exit cleanly instead of sitting in the active pipeline distorting the numbers.

Each stage change is a trigger. Nothing waits for someone to notice.

Appointment booking, no-show and cancellation handling

Three separate calendars feed one booking workflow: a discovery call, a strategy call, and a demo. The workflow branches on which calendar was used, records the lead source, assigns the owner, creates the opportunity, and sends confirmation.

Then it protects the booking. A reminder sequence runs at 24 hours and 1 hour before, and each reminder checks the cancellation status before firing so a cancelled client never receives a "see you tomorrow" message.

Two dedicated handlers cover what happens when it goes wrong:

• No-show handler — tags the no-show, records the date, and runs a rebooking chase with an attempt counter, so the sequence escalates and then stops rather than nagging forever
• Cancellation handler — removes the booking tag, sends confirmation, then runs its own rebooking sequence with the same attempt logic

Both use a math operation to track attempts and branch on the count: chase up to a limit, then hand off to a human with a notification.

Automated NDA sending and chasing

When a deal reaches NDA Sent, the system sends the document, tags the contact, records the send date, notifies the team internally, and creates a task.

Then it chases: four reminders over sixteen days, each one gated by a timeout condition that checks whether the document has been signed. Sign at any point and the sequence stops. Reach the end without signing and the opportunity updates, the internal team gets notified, and the lead moves to Interested / Not Ready with a task created for a human to take over.

Nobody has to remember to chase a contract. Nobody has to remember to stop chasing one that's already signed.

Invoice reminders that escalate

Same pattern applied to money. When a signed deal moves to Payment Pending, the system notifies the team, creates a task, and starts an invoice reminder counter.

It waits, increments the counter, and branches: under the threshold, send another reminder and notify internally; over the threshold, the invoice is flagged as overdue and escalated to a person. The reminder count lives in a contact field, so the system knows how many times it has asked.

Sales to delivery handover

When payment is received, the system closes the sale properly: updates contact fields, removes the contact from the sales workflows so they stop receiving sales messaging, tags the deal closed, marks the opportunity won, sends the client confirmation, and notifies the team.

Then it branches on which product the client bought and moves them into the matching onboarding pipeline. The won deal becomes an active project automatically.

The delivery pipeline runs its own stages:

The task layer

Every stage produces a task, and every task carries the context needed to act on it.

A chase task doesn't just say "chase the NDA." It carries the client's name, email, phone, which product they're interested in, their intent category, the date the document was sent, and the current stage. Plus a plain-English note explaining what the system is already doing and when a human needs to step in: four reminder emails go out over the next sixteen days; you'll be told when they sign; if they haven't signed by then, the card moves and a task will be created.

That's the difference between a reminder and an instruction. Somebody new to the account can open a task and know exactly what's happening and what's expected of them, without asking anyone.

The whole system, at a glance

The hard part

The awkward problem in this build was knowing when to stop.

Automated chasing is easy to start and hard to end well. Chase too little and deals go quiet. Chase too much and you're the agency that sends five emails about a contract someone already signed. That costs more goodwill than the deal is worth.

Three mechanisms solve it, and they run through every chase sequence in the system:

Timeout conditions instead of fixed waits. Each reminder in the NDA sequence sits behind a condition that checks the actual document status, so the sequence runs until the state changes. Sign on day two and reminders three and four never send.

Attempt counters in contact fields. The no-show, cancellation, and invoice sequences each track how many times they've tried, using a math operation to increment and a condition to branch on the count. The system knows the difference between a first nudge and a fourth.

A defined exit to a human. Every sequence has an end. When the counter passes its threshold, the automation stops chasing, updates the opportunity, notifies the team, and hands the client to someone with the full context.

The same three-part pattern (check state, count attempts, exit to a human) is what makes the whole system safe to leave running unattended.

Stack

GoHighLevel — Pipelines & Opportunities · Workflow Builder · AI Agents (chatbot + voice) · Calendars · Documents & Contracts · Payments · Conversations (Email, SMS, Chat) · Tasks · Custom Fields