Build your first cascading WhatsApp → Phone → SMS campaign

This is the tutorial we give every new customer who wants to understand how cascading campaigns actually work before committing to a deployment. You can follow it with any multi-channel platform; the concepts are platform-agnostic.

What you'll build

A single campaign that:

1. Sends a WhatsApp message to every customer in the list.
2. Waits 6 hours for a reply.
3. If no reply — triggers a phone call from a voice agent.
4. Waits 2 hours for the call to be answered.
5. If still no answer — sends an SMS.
6. Measures every step and feeds the results back into the rules so tomorrow's cascade starts with whichever channel actually worked for each customer segment.

What you'll need

• A WhatsApp Business API account with at least one approved template.
• A voice provider connected to a real phone number (SIP trunk or DID — not a web widget).
• An SMS provider or aggregator.
• A simple customer list with name, phone, and segment columns.

Step 1 — Prepare the content for each channel

Every channel in the cascade needs its own message, not a copy-paste of the previous one. A customer who didn't answer WhatsApp doesn't want to see the same text again on SMS.

WhatsApp (approved template): conversational, rich-media-friendly, 1–2 sentences. Include one concrete ask (a link, a button, or a direct question).

Voice (agent system prompt): personality calibrated to your brand, an opening line that references the WhatsApp attempt, and a short script that lets the customer answer in their own words.

SMS: 160 characters or fewer, with a trackable shortlink and no greeting — you're already three touchpoints in, the customer knows it's you.

Step 2 — Define the cascade rules

Write the rules out explicitly before you build them. In our deployments we use a simple JSON format:

{
  "start": "whatsapp",
  "steps": [
    {
      "channel": "whatsapp",
      "wait": "6h",
      "if_no_reply": "phone"
    },
    {
      "channel": "phone",
      "wait": "2h",
      "if_no_answer": "sms"
    },
    {
      "channel": "sms",
      "wait": null,
      "terminal": true
    }
  ]
}

Put these rules in version control. Every change to cascade logic should be a pull request — not a click in an admin UI that leaves no audit trail.

Step 3 — Wire the outcome signals back in

For each customer you'll get one of these outcomes per step: delivered, read, replied, answered, clicked, no_answer, bounced, or opted_out.

Every outcome feeds one thing: the next cascade's starting channel for that customer's segment. After 200–500 cascades in a segment you'll typically see the optimal start channel emerge. At that point, flip start from whatsapp to whatever actually won.

Step 4 — Run one cascade, small

Don't turn this loose on your whole list. Pick a 100-customer segment and run one cascade end-to-end. Watch the logs. Something will break — a template will reject, a voice provider will throttle, an SMS will bounce. This is normal. Fix those in the small-cohort run before you scale.

Step 5 — Measure and tune

After the first week, answer three questions:

• Which channel is converting most per cost? Rank WhatsApp / phone / SMS by conversion per unit cost, per segment.
• Which wait timer is wrong? If >80% of the conversions from a channel happen in the first N% of the wait window, shorten the window.
• Which segment has a clearly different winner? If "enterprise accounts reply on email 2.1× more than retail", split that segment out with its own starting channel.

That's the whole loop. Build, run small, measure, retune. That's what "real-time learning" is, in practice. No magic — just a rigorous feedback loop that you never stop running.

Common failure modes

• Skipping the small-cohort run. Everyone thinks their setup is right. It isn't.
• Re-using the same copy on every channel. WhatsApp voice is warm, SMS voice is terse. Using the same line in both loses 20–30% of the attribution.
• Never updating the rules. A cascade that still runs Day 1 rules after 90 days of data is flushing money.

Want us to build this on your stack? That's what Path 3 — Run it for you covers.