Customer journey automation connects the touchpoints a prospect moves through, an ad click, a landing page visit, an email, a demo booked, so each step triggers the next one automatically based on what the prospect actually does. For a B2B SaaS company, it means a trial user who goes quiet gets a relevant follow-up instead of falling out of the pipeline unnoticed.
This guide shows how to build it in five steps: map one real journey, find the gaps in your own data, turn each gap into a trigger, test the rules on sample events, and review them monthly. It includes a query and a rules script that run as shown, a trigger template you can download, and a short walkthrough video. Skill level: comfortable with a spreadsheet and a basic script. Time: about half a day for a first journey.
Why do most B2B SaaS teams have an incomplete journey?
Most B2B SaaS teams can describe their customer journey in general terms: someone finds us, they reach out, we follow up, they book. What is usually missing is what happens at each specific gap, the one to three days between a demo request and the first callback, or the two to three weeks between a proposal and a decision.
Those gaps are where leads are lost. Not because the business did anything wrong, but because following up consistently, at the right time, with the right message, is hard to do by hand across dozens or hundreds of leads a month.

What do you need before you start?
| Item | What you need | Why |
|---|---|---|
| Data | Timestamps for form submissions, first callback, proposal sent, and replies | Gaps are measured from these events, so export them from your CRM or email tool |
| Tools | A spreadsheet, Python 3, and your CRM or automation tool | The scripts below use only the Python standard library |
| Time | About half a day for one journey | Most of it is mapping and agreeing the thresholds |
| Result | A trigger map, tested rules, and a monthly review habit | Plus a downloadable template and checklist |
Step 1: Map a real journey before automating it
Write out an actual journey a real customer went through recently, not a generic funnel. For a B2B SaaS company, that might look like this:
- Sees a LinkedIn ad and clicks through to a landing page
- Signs up for a free trial or requests a demo
- Gets a confirmation email (sometimes)
- Waits for a sales follow-up, which may take one to three days
- Has a demo call scheduled
- Receives a pricing proposal
- Goes quiet for two to three weeks while evaluating internally
- Either converts or the lead goes cold with no further contact
Written out this way, the gaps are obvious: the inconsistent confirmation, the one-to-three day callback delay, and the total silence after the proposal is delivered. Each is a specific point where automation can close the gap, not with a vague “improve follow-up” initiative, but with a defined trigger and action. Capture each stage in a table so nothing stays implicit.
| Stage | Touchpoint | Owner today | What the prospect sees | Time to next step |
|---|---|---|---|---|
| Form submitted | Landing page form | Marketing | Thank-you page, sometimes an email | Minutes to never |
| First callback | Phone or email from sales | Sales rep | Nothing until contacted | 1 to 3 days |
| Demo | Video call | Sales rep | Calendar invite | Days |
| Proposal | Emailed document | Sales rep | The document | 2 to 3 weeks of silence |
Common mistake: mapping the journey you wish you had. Use a real lead and the timestamps in your CRM.
Step 2: Find the gaps in your own data
Before building anything, measure how long leads actually wait. Export the created time and the first-touch time for recent leads, then list every lead whose wait passed your threshold. The query below runs on a scratch SQLite database with six illustrative leads, using a 12-hour threshold and a fixed “now” so the output repeats.
find_gaps.py (swap the scratch table for your own export)
import sqlite3
NOW = "2026-10-12 09:00" # fixed so the output is repeatable
THRESHOLD_HOURS = 12 # flag leads that waited longer than this for a first touch
db = sqlite3.connect(":memory:")
db.executescript("""
CREATE TABLE leads (id TEXT, created_at TEXT, first_touch_at TEXT);
INSERT INTO leads VALUES
('L1', '2026-10-06 09:10', '2026-10-06 15:00'),
('L2', '2026-10-09 14:30', NULL),
('L3', '2026-10-01 11:00', '2026-10-02 09:00'),
('L4', '2026-09-20 10:00', '2026-09-21 10:00'),
('L5', '2026-10-11 16:00', NULL),
('L6', '2026-10-12 08:30', NULL);
""")
query = """
SELECT id, created_at, COALESCE(first_touch_at, 'none yet') AS first_touch, hours_waiting
FROM (
SELECT id, created_at, first_touch_at,
ROUND((julianday(COALESCE(first_touch_at, ?)) - julianday(created_at)) * 24, 1) AS hours_waiting
FROM leads
)
WHERE hours_waiting > ?
ORDER BY hours_waiting DESC;
"""
for row in db.execute(query, (NOW, THRESHOLD_HOURS)):
print(row)
Output (illustrative sample data, columns: lead, created, first touch, hours waiting):
('L2', '2026-10-09 14:30', 'none yet', 66.5)
('L4', '2026-09-20 10:00', '2026-09-21 10:00', 24.0)
('L3', '2026-10-01 11:00', '2026-10-02 09:00', 22.0)
('L5', '2026-10-11 16:00', 'none yet', 17.0)
Expected result: a short list of leads that waited too long, with the longest wait first. Common mistake: leads with no first touch yet. The query counts them as waiting until “now”, which is correct, so they surface as soon as they pass the threshold.
Step 3: Turn each gap into a trigger
A trigger has three parts: the event that fires it, the action it takes, and the condition that stops it. Writing all three prevents the two classic failures, silence and over-messaging.
| Gap | Trigger event | Action | Stop condition | Owner |
|---|---|---|---|---|
| Confirmation depends on a person | Form submitted | Send a confirmation within minutes, every time | None, one message | Marketing |
| Callback depends on someone noticing | No callback logged 24 hours after the form | Alert the lead owner and log the alert | Callback logged | Sales manager |
| Follow-up depends on someone remembering | Proposal sent | Follow-up messages on day 3, day 10, and day 21 | Prospect replies | Sales rep |
| Hand-off depends on someone noticing the reply | Prospect replies | End the sequence and assign a rep | Not applicable | Sales rep |

Most automation tools express this in two ways, and it helps to know which you are using. Event triggers fire when something happens, such as a form submission. Filter triggers fire when a record matches a condition. HubSpot’s documentation, for example, states that workflows can be triggered off filter-based criteria or event-based criteria, and that by default records enroll only the first time they meet the trigger unless you allow re-enrollment. That default matters for a proposal sequence, because a lead who reopens a deal would otherwise never re-enter it.

Step 4: Test the rules on sample events before connecting a tool
Logic errors are cheaper to find in a script than in a live automation. The script below implements the four triggers, reads a CSV of events, and prints the action due for each lead at a date you pass in. Giving it a fixed date makes the run repeatable.
journey_rules.py (run as python journey_rules.py events.csv "2026-10-12 09:00")
import csv, sys
from datetime import datetime, timedelta
FOLLOW_UP_DAYS = [3, 10, 21] # days after the proposal is sent
NOW = datetime.fromisoformat(sys.argv[2]) # pass "now" so the run is repeatable
events = {}
for r in csv.DictReader(open(sys.argv[1], newline="")):
events.setdefault(r["lead"], []).append((datetime.fromisoformat(r["time"]), r["event"]))
def when(evts, kind):
return next((t for t, k in sorted(evts) if k == kind), None)
for lead, evts in sorted(events.items()):
kinds = {k for _, k in evts}
actions = []
form = when(evts, "form_submitted")
if form and "confirmation_sent" not in kinds:
actions.append("send confirmation now")
if form and "callback_done" not in kinds and NOW - form > timedelta(hours=24):
actions.append("ALERT: no callback within 24 hours")
proposal = when(evts, "proposal_sent")
if "replied" in kinds:
actions.append("stop sequence, hand to a rep")
elif proposal:
for d in FOLLOW_UP_DAYS:
if proposal + timedelta(days=d) <= NOW and f"followup_day{d}_sent" not in kinds:
actions.append(f"send follow-up day {d}")
print(f"{lead}: {'; '.join(actions) if actions else 'no action due'}")
The input is a log with one row per event. These are the illustrative events used for the test.
events.csv (illustrative)
lead,time,event
L1,2026-10-06 09:10,form_submitted
L1,2026-10-06 09:11,confirmation_sent
L1,2026-10-06 15:00,callback_done
L1,2026-10-07 10:00,proposal_sent
L2,2026-10-09 14:30,form_submitted
L3,2026-10-01 11:00,form_submitted
L3,2026-10-01 11:01,confirmation_sent
L3,2026-10-02 09:00,callback_done
L3,2026-10-02 16:00,proposal_sent
L3,2026-10-05 16:00,followup_day3_sent
L4,2026-09-20 10:00,form_submitted
L4,2026-09-20 10:02,confirmation_sent
L4,2026-09-21 10:00,callback_done
L4,2026-09-21 15:00,proposal_sent
L4,2026-09-24 15:00,followup_day3_sent
L4,2026-09-25 09:00,replied
L5,2026-10-11 16:00,form_submitted
L5,2026-10-11 16:01,confirmation_sent
L6,2026-10-12 08:30,form_submitted
Output on 2026-10-12 09:00:
L1: send follow-up day 3
L2: send confirmation now; ALERT: no callback within 24 hours
L3: no action due
L4: stop sequence, hand to a rep
L5: no action due
L6: send confirmation now

Here is why each lead got the result it did, so you can check the logic against your own events.
| Lead | What the log shows | Action due | Why |
|---|---|---|---|
| L1 | Proposal sent 7 Oct 10:00, no reply, no follow-up sent | Send follow-up day 3 | Day 3 was due on 10 Oct; day 10 is not due yet |
| L2 | Form on 9 Oct, no confirmation, no callback | Send confirmation; alert | More than 24 hours with no callback |
| L3 | Proposal 2 Oct, day 3 sent | No action due | Day 10 falls on 12 Oct at 16:00, after “now” |
| L4 | Replied on 25 Sep | Stop sequence, hand to a rep | A reply ends the sequence |
| L5 | Form 11 Oct 16:00, confirmation sent | No action due | Only 17 hours, under the 24-hour alert |
| L6 | Form 12 Oct 08:30, no confirmation | Send confirmation now | The confirmation trigger has not fired yet |
Common mistake: a rule that keeps firing after the prospect replies. The stop check runs first in the script for exactly that reason.
Step 5: Monitor and adjust
Once the rules run in your tool, review each trigger monthly. You are checking that it fires, that it works, and that it stops.
| Check | How to measure it | What it tells you |
|---|---|---|
| Fired | Count of times the trigger ran in the month | Whether the trigger is wired up at all |
| Replied | Prospects who responded within the sequence | Whether the message and timing work |
| Stopped on reply | Sequences that ended when a reply arrived | Whether the stop rule works |
| Alerts actioned | Alerts that led to a logged callback | Whether the owner actually acts on them |
Adjust one threshold at a time and compare the next month. Changing the callback alert and the follow-up days together hides which change mattered.
How do you fix the common problems?
| Symptom | Likely cause | Fix |
|---|---|---|
| A prospect gets follow-ups after replying | The stop condition is missing or checked after the send | Check for a reply before every send, as the script does |
| A lead never enters the sequence | Records enroll only once by default and this one already did | Enable re-enrollment where a lead can legitimately restart |
| Alerts pile up unread | No owner or too many alerts | Assign a named owner and tighten the threshold |
| Timestamps are in different time zones | CRM and email tool store different zones | Convert everything to one zone before measuring gaps |
Checklist
- One real journey is written out stage by stage
- Every gap is measured from your own data
- Each gap has one trigger, one action, and one stop condition
- The rules are tested on sample events before launch
- Fired, replied, and stopped are reviewed monthly
Downloads: Journey trigger map template (CSV) and Journey automation checklist (PDF).
Where does this connect to AI agents and orchestration?
Journey automation is the strategy layer: which touchpoints exist, and what should happen at each one. The execution of those triggers is where AI orchestration and dedicated AI agents for sales come in. They are what actually sends the message, updates the record, or books the appointment when a trigger fires. Journey mapping without that execution layer is just a diagram; the automation is what makes the diagram run on its own.
The same logic extends past the sale. Once a lead becomes a customer, the trigger-and-action approach carries into onboarding and retention, covered in our guide to AI for customer success.
MV3 Marketing builds these journeys as part of its demand generation work, starting from a business’s actual customer path rather than a generic funnel template.
| Layer | What it does | Where it lives in this guide |
|---|---|---|
| Strategy | Decides which touchpoints exist and what each should trigger | Steps 1 and 3: the journey map and the trigger table |
| Rules | Encodes event, action, and stop condition | Step 4: journey_rules.py, then your CRM workflow |
| Execution | Sends the message, updates the record, books the meeting | Your email tool, CRM, or an AI agent |
| Measurement | Shows what fired, replied, and stopped | Step 5: the monthly review |
Frequently asked questions
What is customer journey automation?
Customer journey automation is the practice of connecting the individual touchpoints a prospect experiences, ads, website visits, emails, calls, so that each one can trigger an appropriate next action automatically, based on what the prospect did, rather than requiring a person to track and follow up on every lead manually.
How is this different from email marketing automation?
Email automation is one channel within the journey. Customer journey automation coordinates across channels, ads, website behavior, email, SMS, and calls, so the follow-up a prospect gets reflects everything they have done, not just whether they opened an email.
Where should a B2B SaaS team start mapping their journey?
Start with the actual path a real customer took recently, from first contact to signed contract, and write down every touchpoint and every gap where follow-up depended on someone remembering to do it. Those gaps are where automation has the most immediate impact.
Does journey automation require a large marketing team to manage?
No. Once the journey is mapped and the automated triggers are built, it runs continuously without daily manual oversight. The setup work is front-loaded; ongoing management is mostly monitoring and periodic adjustment.
If you have never mapped out where your leads actually go quiet, that is the fastest place to start. Book a call and we will map it with you.
Share this article
Ready to audit your organic growth opportunity?
$2,500 flat. 5 business days. Six deliverables tied to pipeline , not rankings. No retainer required.
Get the Organic Growth Audit →