Lina spots a sponsored post on Instagram at midnight. Limited-run sneakers. She taps. The mobile site loads, adds her size, and she is halfway through checkout when the baby monitor lights up. Thirty minutes later she is back, opens her laptop, and your site greets her like a stranger. Empty cart. No memory of her place. She types her email in the header because there is a tiny sign in link, and the page forgets the last step again. By morning she gets an email about a backpack she looked at two weeks ago, not the sneakers. Her phone buzzes with a push about a sale that ended yesterday. Later that day she visits a store for curbside pickup of something else and the associate cannot see her online cart at all.
That little tumble through channels is common right now. Stores are reopening with curbside. Call centers are slammed. TikTok might vanish in the US. Twitter got hit by a massive account hijack in July. Ad budgets keep moving to digital. People bounce between phone, laptop, tablet, and back again. The brands that feel easy are the ones that keep the thread of a task through all of that. That is channel continuity and its close cousin journey continuity.
Both sound obvious. Keep context. Keep the state. Help people finish what they started. Yet the moment you try to build it, a lot of small decisions stack up. Identity, timing, consent, source of truth, fallbacks. This post is a field note from teams building this right now.
Analysis
First, a quick split. Channel continuity is when a person can switch from one channel to another and their state follows. Cart keeps items. Form keeps answers. Search filters persist. Customer service can see what happened in the app. Journey continuity is slightly different. It is not just state sync. It is awareness of where the person is in a task and what the next helpful step looks like. If someone viewed shipping options twice and then stalled, a reminder about free shipping with a pre filled cart link is more useful than a generic ad about a new collection.
The work behind both starts with identity. Pre sign in you have a mix of device IDs, first party cookies, local storage, email clicks, and app instance IDs. Post sign in you have customer IDs and maybe a loyalty number. Right now tracking has friction. Safari blocks third party cookies. CCPA enforcement started in July. iOS 14 is around the corner with changes to IDFA and consent flows. So plan for a world where identity stitching is first party and consent driven.
The glue is your event stream. Every important action becomes an event with consistent names and fields. Think cart_updated with product IDs, quantity, price, currency, and source. Think checkout_step_viewed with step name, timestamp, channel, and customer ID if available. Keep product IDs canonical across web, app, and store systems. Keep time zones straight. Deduplicate with an idempotency key so you do not double count.
Where does this data go first. Some teams start with a CDP like Segment, mParticle, or Tealium feeding analytics, push, email, and ads. Some teams pipe into a data warehouse and fan out from there. Some teams let a marketing automation tool sit in the middle. Pick a single source of truth for state that can be read by the rest with low lag. If you need cart continuity between web and app, your cart service should be that truth. If you want journey continuity across all channels, an event store with near real time processing helps.
Time is the next big factor. Plenty of tools promise real time, then you find out it is one minute plus. For a cart handoff that is fine. For fraud checks it might not be. Decide what is truly instant and what can be batch. A good line is this. If the person is staring at a screen waiting, go as fast as you can. If the next touch is an email within the hour, batch is fine.
On the front end, design for continuity in simple ways. Show a Continue where you left off card on home screens. Put the last category or search term in the search box as a suggestion. For support journeys, let people pick up an open case without making them repeat their story. For content, save progress and offer a deep link that opens the app at the right step, or the web page at the right anchor. Magic links for sign in reduce friction, just do it right with short lived tokens and clear copy.
Consent and respect matter a lot. Onboarding that asks for push, email, SMS, and location in the first minute burns trust. Tie consent asks to a clear benefit. Say why. Let people say yes to some and no to others. And record that choice so your orchestration respects it across channels. This is not only friendly. With CCPA now in force you need an audit trail.
A practical pattern that works. Pick the top three journeys that drive revenue or support tickets. For most brands that is new user onboarding, checkout rescue, and order support. For software that might be installation, first value, and upgrade. Map the steps as a simple state machine. Example for checkout. Viewed product, added to cart, viewed cart, viewed shipping, entered payment, order placed. Add drop reasons you can detect like payment declined or address validation failed. Then set the rules for channel handoff. If a person leaves at shipping, show a banner with free pickup on next visit, send an email with their cart link after sixty minutes, and send a push only if the app is installed and push is allowed. Keep it simple.
Metrics keep you honest. Measure time to completion across channels. Measure step drop rates. Measure reply rates on nudges. Measure support contacts per order. Watch for fatigue. If your nudges lift short term conversion but increase refunds or churn, you are pushing the wrong way.
Tooling wise, you do not need a giant overhaul to start. You need a clean event spec, a place to store state, a service that builds audiences or triggers based on that state, and channels that listen. Your ESP should accept an external cart link and personalization fields. Your app should read a last seen step and print a card. Your site should read a cart token and show it even pre sign in. Your customer service tool should surface recent events. Stitch these with a simple ID graph. Email as a link key. Customer ID for signed in actions. Device ID as a hint. Stitch with caution and clear consent.
Risks
The biggest risk is creepiness. When the follow up feels like surveillance, you lose. Context helps. Say why you are reaching out. Use plain copy. Offer an easy opt out.
The next risk is identity drift. People share devices. Cookies expire. App IDs reset. If your stitching is too aggressive, you might blend two people into one profile. That leads to the wrong message to the wrong person. Keep strict rules for merges. Prefer logins over guesses. Let people unmerge if needed.
Data quality will bite you. If product IDs change between catalog and app, your cart link fails. If event names vary, your triggers do not fire. If time zones are mixed, your send windows get weird. Create a small contract and lint it in every client.
Latency creates awkward moments. A person completes an order, then gets a nudge that says finish your checkout. Build suppression windows around key events. Cancel messages when the state changes.
Privacy and regulation are moving targets. CCPA is live. GDPR already changed the playbook. iOS consent prompts for tracking will change flows. Shift to first party data and make consent screens clear and friendly. Keep records and honor requests.
Do not forget a channel outage plan. Push services fail. Email gets throttled. Ads get blocked. Twitter locked down after the July hack and some support teams were blind for hours. Build fallbacks and a quiet mode.
Decision checklist
- Source of truth. What service holds cart state, journey step, and consent. Can every channel read it fast enough.
- Identity. What are your keys pre sign in and post sign in. What are your merge rules. How do you handle unmerge.
- Consent. Where and how do you capture channel level consent. How is it stored. How fast do channels receive updates.
- Event spec. Do you have standard names and fields for the top journeys. Are IDs canonical across app, web, and store.
- Real time vs batch. Which triggers must be instant. Which can be processed every few minutes or hourly.
- Suppression logic. What cancels a message. What quiet hours do you enforce. How do you avoid sending after a conversion.
- Deep link and handoff. Do you have stable links that open the app to a step, or fall back to web with the same state.
- Failure modes. What happens if you cannot identify the person. What is the safe default if state is missing.
- Data quality. Who owns the schema. How do you test events. How do you monitor freshness and errors.
- Reporting. Which metrics prove continuity is helping. Who reviews them weekly.
- Privacy. How do you handle access and deletion requests. Do you log consent version and timestamp.
- Team workflow. Who can create a journey. How are changes reviewed. How fast can you roll back.
Action items
- Pick one journey where drop off hurts. Checkout rescue is usually the best start.
- Map the steps as a simple state machine with a whiteboard or a doc. Name each step and the events that move a person forward or back.
- Write a tiny event spec for that journey. Names, fields, ID rules, time zone, and dedupe key. Share it with web, app, and backend owners.
- Choose the store for journey state. For checkout, this is often the cart service with an added field for last completed step.
- Add a last seen step field to your profile store so channels can look it up fast.
- Build a deep link format that includes cart token and step. App opens to the right screen. Web reads the token and sets state.
- Instrument the events across web and app. QA by running through the journey and watching events in a debug view.
- Set up one trigger. If last seen step is shipping and no order after sixty minutes, send a single email with a pre filled cart link. Suppress if order placed or cart emptied.
- Add a small UI element on home screens. Continue where you left off with a button to resume.
- Wire up consent. Respect preferences per channel. Store a timestamp and source.
- Define a quiet mode. If your system sees more than one nudge in a day for the same person, hold back and log it.
- Launch to a small slice. Watch metrics. Time to completion, finish rate, reply rate, and support contacts for that journey.
- Fix rough edges. Product IDs missing. Links that fail on older app versions. Event naming mismatches. Clean that up before you expand.
- Add one more channel when the first works. Push or on site banner next. Keep the same rule and suppression logic.
- Document the pattern. Embed it in your playbook so every future journey follows the same shape.
Closing thought
Right now people do not follow a neat funnel. They start on a phone at night, hop to a laptop in the morning, chat with support during lunch, and pick up at the store after work. The brands that win are the ones that carry the thread from step to step. Not with fireworks. With small choices that respect attention, remember state, and make the next step obvious.
Build that thread one journey at a time. Keep it honest. Keep it fast. Keep it human. That is channel and journey continuity.