Loading tutorials…
Loading tutorials…
Email + SMS + Push is the canonical SaaS lifecycle trifecta. Adding SMS lifts onboarding completion 8-15%. Adding push lifts re-engagement on mobile apps 20-35%. The setup is one weekend of work, ongoing.
Who this is forSaaS teams with a working Customer.io email setup who want to add SMS, push, or both. Especially relevant for mobile-first products, B2C SaaS, or any product where users have downloaded a mobile app.
What you'll need
Step 1
Customer.io needs a Twilio account, phone number(s), and Messaging Service. Then connect Twilio under Settings.
In Twilio (twilio.com) → create account if needed → buy a phone number for your origin country (US 10DLC, toll-free, or short code depending on volume needs).
Twilio Console → Messaging → Services → Create Messaging Service. Add your phone number(s) to the service.
For US sends: register 10DLC brand + campaign via Twilio Console → Trust Hub. This takes 1-3 business days and is required for US carrier acceptance — without it, messages get filtered.
Get Twilio credentials: Account SID + Auth Token + Messaging Service SID.
In Customer.io → Settings → SMS Settings → Twilio integration → paste credentials → Save. Test connection.
Verify by sending a test SMS: Customer.io → People → find your test profile → Send Test Message → SMS → pick the Twilio number. Confirm it arrives.
Step 2
SMS consent must be EXPLICIT and SEPARATE from email consent. Store consent timestamp + IP. Provide STOP/HELP keywords.
In your product, add a separate SMS opt-in checkbox to signup or account settings: 'I agree to receive SMS messages from YourApp. Reply STOP to opt out. Message and data rates may apply.'
On opt-in: fire a Customer.io identify call with `sms_consent: true`, `sms_consent_at: <timestamp>`, `sms_consent_ip: <user_ip>`, `sms_phone: <e164_format>`.
TCPA requires explicit opt-in with disclosed sender, purpose, frequency, and opt-out method. Have legal review your opt-in copy if doing significant SMS volume.
Configure Twilio auto-responders for STOP, START, HELP keywords: Twilio Console → Messaging Service → Opt-out management. These are automatic but verify they work.
When user replies STOP, Twilio handles the opt-out at the carrier level AND fires a webhook. Wire that webhook to Customer.io: set `sms_consent: false` on the profile via identify.
Every SMS workflow must filter to `sms_consent == true`. No exceptions.
Step 3
Customer.io → Settings → Push Settings. Connect Firebase Cloud Messaging key + APNs auth key. Integrate Customer.io mobile SDK in your app.
Firebase (Android): Firebase Console → Project Settings → Cloud Messaging → Server Key (or new HTTP v1 service account JSON). Copy.
APNs (iOS): Apple Developer Portal → Certificates → Keys → + Key → enable APNs → download .p8 file + note the Key ID + Team ID.
Customer.io → Settings → Push Settings → Android → paste Firebase server key. iOS → upload .p8 + Key ID + Team ID + bundle ID.
In your mobile app, integrate Customer.io mobile SDK (iOS Swift, Android Kotlin, React Native, Flutter — all supported). The SDK handles device token registration with Customer.io automatically.
On app launch (after user authentication), call `CustomerIO.identify(userId)` from the SDK to associate the device token with the profile.
Test: Customer.io → People → test profile → Send Test → Push. Confirm push arrives on a real device.
Step 4
Edit existing Journey workflows. Add SMS block or Push block alongside or instead of email blocks.
Open your Onboarding Series Journey.
Add an SMS block: Day 1, after the welcome email — short SMS reinforcing the activation step. SMS character limit: 160 (or 1,600 if you accept multi-segment billing). Keep under 160 unless necessary.
Add filter on the SMS block: `sms_consent == true` (only sends to consented users; rest skip the SMS step).
Add a Push block: Day 3, for users who have a registered device. Filter: `has device_token`.
Push character limit: 178 chars for iOS lock screen, 65 chars for the title. Keep titles tight.
For deep linking from push: Customer.io supports deep link URLs in push payload. Your app should handle the URL when the user taps the notification.
Workflow goal stays the same (e.g., `Activation Event Hit`). Exit on goal removes user from all remaining steps including SMS/push.
Step 5
Some lifecycle moments are SMS-better than email. Payment failed, security alert, abandoned-cart-equivalent for SaaS (workflow abandoned), 2FA codes.
**Payment Failed**: trigger on `Payment Failed` event. Send SMS within 10 minutes: "Hi {{ first_name }}, your YourApp payment failed. Update your card to keep your subscription: {{ billing_link }}". Recovery rate jumps 15-30% vs email-only.
**Security Alert**: trigger on `Suspicious Login Detected` from your backend. SMS to verify "Was this you? {{ login_location }}." Higher-trust channel than email for security.
**Workflow Abandoned**: in SaaS, "user started but didn't finish [important task]." SMS at 24 hours: short nudge with deep link back to where they left off.
**Trial Ending**: 24 hours before trial end, SMS reminder. Combined with email, lifts trial-to-paid conversion 4-8%.
Resist the urge to SMS everything. SMS open rate is 95%+ which means it's a finite trust resource. Use for time-sensitive, high-value moments only.
Step 6
Analytics → SMS / Push. Different metrics from email — delivery, click-through (for SMS short links), opt-out rate (critical).
SMS metrics to watch: Delivery rate (target 95%+), Click-through (4-15%), Opt-out rate per send (target <2%).
Push metrics: Delivery (varies; users with notifications disabled won't receive — that's normal), Tap rate (8-25%).
SMS cost: track in Customer.io + Twilio. US 10DLC SMS is roughly $0.008-0.012 per segment. At 50K sends/mo, that's $400-600/mo Twilio cost on top of Customer.io.
Watch opt-out rate weekly. Spike from 1% to 5% means your SMS content is too aggressive or too frequent — pull back immediately.
Reconcile SMS sent in Customer.io vs SMS delivered in Twilio dashboard. Gap >5% suggests carrier filtering issue.
Step 7
SMS list health is more fragile than email. 2-4 SMS per user per month is a reasonable upper bound.
Heaviest SMS usage I'd recommend for SaaS lifecycle: 2-4 SMS per user per month — security alerts, payment issues, trial-ending, 1 promotional max.
Set workspace-wide SMS frequency cap: 1 SMS per user per 24 hours, 4 per user per 30 days.
Quarterly: prune the SMS opt-in list. Anyone who's been opted-in 12+ months without clicking any SMS short link — remove them. Keeps the list healthy.
Document the SMS strategy in writing: which lifecycle moments warrant SMS, which don't, who can approve a new SMS campaign. Without this, SMS volume creeps up over 6 months and opt-outs spike.
Common mistakes
SMS without separate opt-in (treating email opt-in as covering SMS)
What goes wrong: TCPA violation. Class-action plaintiffs target this exact pattern. Settlement range $500-1,500 per message. Even a 5,000-person SMS blast can cost $2.5M-7.5M in legal exposure. Multiple SaaS startups have folded over this.
How to avoid: Build separate, explicit SMS opt-in. Store consent + IP + timestamp. Audit opt-in records before any SMS send. If you have legacy email-only opt-ins, send a re-permission SMS asking for explicit SMS consent — yes you'll lose 60-80% of the list, that's the cost.
No 10DLC registration for US SMS
What goes wrong: US carrier filtering drops delivery from 95%+ to 30-60%. You're paying Twilio per-segment for messages that never arrive. At 10K SMS/mo with 50% filtering, that's $50-60/mo of wasted spend AND 5,000 customers who never got the message.
How to avoid: Twilio Console → Trust Hub → register 10DLC brand + campaign. Takes 1-3 business days. $4-15/mo ongoing. Required for any US SMS volume.
Sending SMS during quiet hours
What goes wrong: Recipient gets a 3am SMS. Files TCPA complaint with FTC. Even if not legally pursued, opt-out rate spikes 5-10x for that send. Brand trust takes 6+ months to recover.
How to avoid: Customer.io → SMS Settings → Quiet Hours → enable, set 9pm-8am recipient local time. Use Customer.io's recipient timezone field to schedule per-recipient.
Push notifications without context (asking permission on app launch)
What goes wrong: iOS push permission grant rate drops from achievable 60-75% to 25-30%. Half your install base can't receive push notifications. Re-engagement workflows lose 30-50% of reach.
How to avoid: Ask for push permission AFTER the user hits their first activation event in your app — when value is established. Use in-app primer screens to explain the value before triggering the OS-level prompt.
No frequency cap, SMS storm from overlapping workflows
What goes wrong: User signs up + does activation + fires payment + invites teammate, all in one day. Gets 4 SMS in 6 hours. Opts out immediately. Worse: complains to carrier, who flags the Messaging Service for review.
How to avoid: Workspace SMS cap: 1 SMS per user per 24 hours. Per-workflow SMS cap as backup. Audit overlap quarterly.
Push payload too long, gets truncated on lock screen
What goes wrong: iOS shows '...' on lock screen at ~65 chars title. Users see meaningless truncated message. Tap rate drops 40-60% vs well-sized payloads.
How to avoid: Title under 50 chars. Body under 150 chars. Test on real devices. Make the title a complete thought, the body supplements.
Recap
Done — what's next
How to build Customer.io segments and Journeys workflows that actually fire
Read the next tutorial
Hand it off
Multi-channel orchestration is where Customer.io specialists earn their keep. A specialist who's launched 20+ SMS+push programs will set up Twilio, register 10DLC, integrate mobile SDK, wire up the 4-5 highest-ROI multi-channel workflows in 1-2 weeks — typically $1,200-2,800 at $14-16/hr. TCPA compliance review alone is usually worth the engagement.
See specialist rates
Yes. Twilio is the SMS gateway (sends the actual message). Customer.io is the orchestration layer (decides who, when, what content). Customer.io's SMS feature requires a Twilio integration. Alternative gateways: MessageBird and Telnyx are supported on Premium+.
10DLC = 10-Digit Long Code. It's the US carrier registration program for application-to-person SMS via long codes. Required since 2022 for any US SMS volume. Without it, US carriers heavily filter your messages. Toll-free (888, 877, etc.) is an alternative path with simpler registration but lower throughput.
On Premium+ via Twilio's WhatsApp Business API integration. Setup is heavier than SMS — Twilio approves your sender, then template messages must be approved by Meta. Worth it for international SaaS in WhatsApp-heavy markets (LATAM, EMEA, India). Not worth the complexity for US-only.
Push itself is free (Firebase and APNs are free at SaaS scale). Customer.io charges per push send on some plans (typically $0.001-0.002 per push above plan limits). For a 100K-user app sending 1M pushes/mo, the cost is usually $100-500/mo.
Yes — Customer.io supports in-app messages (banners, modals, slideouts) on Premium+. Different setup from push. See the dedicated in-app messaging tutorial for details on the SDK integration and message types.
Attentive and Postscript are e-commerce-focused SMS platforms with strong Shopify integration and pop-up capture. Customer.io's SMS is part of a broader orchestration layer — better for SaaS multi-channel programs. If you're doing >50K SMS/mo as your primary marketing channel, a dedicated SMS platform may be better. For SaaS lifecycle where SMS supports email + push, Customer.io is the right call.
Customer.io
Segments are how Customer.io decides who. Workflows are how it decides when and what. Most SaaS teams get one or the other right but rarely both — and the gap shows up as activation campaigns missing 40% of eligible users.
Customer.io
Customer.io's email side has three distinct surfaces — Broadcasts, Newsletters, and Transactional — and each has its own rules. Mix them up and you'll send marketing content from your transactional IP (bad) or transactional from your marketing IP (worse).
Customer.io
In-app messaging closes the gap email can't reach — the user who is actively using your product right now. Banners, modals, slideouts, and inline messages reach users at the exact moment of intent.
Customer.io
Liquid is what turns Customer.io from 'mass blast tool' into 'one-to-one personalization at scale.' Knowing the right 20% of Liquid syntax — variables, defaults, conditionals, filters — covers 95% of SaaS personalization use cases.
Customer.io
When a Customer.io workflow isn't firing, 80% of the time it's an event-delivery problem upstream, not the workflow itself. This is the diagnostic path that finds the root cause in minutes instead of days.
Customer.io
DIY Customer.io is the right call — until it isn't. In healthy SaaS, lifecycle email + in-app should drive 20-35% of activation and 10-20% of retention. If yours is at 5-10%, the gap is the program isn't being worked. Here's the honest framework for when to hire.