Create or Update Person in Customer.io

Overview

Create or update person in Customer.io is the workhorse action for keeping shopper profiles current as behavior changes across browse, checkout, and purchase. In a D2C environment, that means your cart recovery, post-purchase cross-sell, and reactivation programs stop guessing and start targeting based on fresh attributes like last_order_date, total_orders, VIP_tier, preferred_category, and SMS_opt_in.

A realistic scenario: a shopper starts on mobile, adds a product to cart, abandons, then later purchases from desktop after clicking a paid ad. If you update the person record at each step, you can suppress them from abandon cart once they buy, trigger the right post-purchase flow, and avoid sending mismatched offers.

Propel helps D2C teams map these identity and attribute updates into dependable revenue journeys inside Customer.io, if you want a second set of eyes you can book a strategy call.

How It Works

Create or update person in Customer.io works by writing attributes onto a customer profile (and creating the profile if it does not exist yet), so your segments and journeys always reference the latest truth.

Most D2C brands use it in three places:

• Identity capture: when you first get an email or phone number (email capture popup, checkout, Shop Pay, SMS keyword), you create the person and store consent fields.
• State changes: when a shopper moves from browsing to cart to checkout to purchase, you update fields like cart_status, checkout_started_at, last_purchase_at, and last_product_viewed.
• Value signals: after an order, you update rollups like total_spent, total_orders, AOV_bucket, returns_count, and LTV_tier to drive smarter offers.

Operationally, this action is often used inside workflows (for example, right after an event trigger like Added to Cart or Order Completed) and it can also be called through your integration layer depending on how you send data to Customer.io.

Step-by-Step Setup

Create or update person in Customer.io is easiest to implement when you standardize your attribute schema first, then wire updates into the moments that matter for revenue.

1. Pick your identifier strategy. Decide the primary key you will use (commonly email). If you also use phone, set a consistent approach for when it is present and how it relates to email.
2. Define a D2C attribute schema. Start with the attributes that power your core programs: first_purchase_date, last_purchase_date, total_orders, total_spent, last_product_category_viewed, cart_value, discount_affinity, SMS_opt_in, email_opt_in, and acquisition_source.
3. Add the Create or Update Person action in your workflow. Place it immediately after key events (email capture, add to cart, checkout started, order completed, refund) so downstream steps reference updated values.
4. Write attributes with clear naming and types. Use timestamps for date fields, numbers for spend, and controlled values for tiers (for example: "VIP", "Core", "New"). Avoid mixing formats like "03/22/26" in one place and ISO timestamps in another.
5. Protect your programs with suppression logic. After updating purchase attributes, add conditions to exit or suppress shoppers from abandon cart and browse abandon paths once they convert.
6. QA with real profiles. Test using internal orders and site activity, then confirm that segments update as expected (for example, “Purchased in last 7 days” and “Cart value over $100”).

When Should You Use This Feature

Create or update person in Customer.io is the right move when your revenue programs depend on accurate shopper state, not just raw events.

• Abandoned cart recovery that stops at purchase: update last_purchase_at and current_cart_status, then use exit conditions so buyers do not keep getting cart reminders.
• First purchase conversion journeys: when someone captures email but has not purchased, update lead_source and preferred_category so your welcome series can merch what they actually browsed.
• Post-purchase cross-sell and replenishment: update last_purchased_sku, last_purchased_category, and replenishment_window_days to personalize timing and product recommendations.
• VIP and loyalty segmentation: update total_spent and total_orders after each order, then move customers into higher-tier perks and early access campaigns.
• Reactivation with the right offer pressure: update days_since_purchase and discount_affinity so you can reserve steep discounts for truly at-risk customers.

Operational Considerations

Create or update person in Customer.io becomes a growth lever only when your data flow and orchestration rules are consistent across channels and platforms.

• Attribute ownership: decide which system is the source of truth for spend, orders, and subscription status (Shopify, your data warehouse, your subscription platform). Do not let two sources overwrite each other with different logic.
• Update timing: cart and checkout attributes should be near real-time, purchase rollups can tolerate small delays, but make sure delays do not break suppression (for example, sending a cart SMS after the order confirmation email).
• Segmentation reliability: segments that rely on “is set” attributes need clear defaults. If cart_value is sometimes missing, your “high intent” segment will be noisy.
• Channel consent and compliance: store explicit fields for email_opt_in and sms_opt_in and update them whenever consent changes. Keep your sending logic tied to those fields, not assumptions.
• Orchestration across journeys: if multiple workflows update the same attributes, document precedence (for example, last_product_viewed should always reflect the most recent browse event).

Implementation Checklist

Create or update person in Customer.io goes smoothly when you treat it like a data product, not a one-off workflow block.

• Confirmed primary identifier and how anonymous-to-known identity will be handled
• Standardized attribute naming conventions (snake_case recommended) and data types
• Defined the minimum viable attribute set for welcome, cart recovery, post-purchase, and reactivation
• Placed updates immediately after key events (email capture, add to cart, checkout start, purchase, refund)
• Added suppression and exit conditions that reference updated purchase fields
• Created QA profiles and test orders to validate segment membership changes
• Documented attribute ownership and overwrite rules across tools

Expert Implementation Tips

Create or update person in Customer.io is where strong D2C operators separate “messages sent” from “revenue generated.”

• Use attributes to simplify branching. In retention programs we’ve implemented for D2C brands, we often reduce complex event logic by writing a single “shopper_state” attribute (for example: browsing, cart, checkout, customer) and branching on that.
• Write purchase rollups at the moment of truth. If your “Order Completed” event is reliable, update total_orders and last_purchase_at right there. Then your cart recovery flow can exit instantly, even if your warehouse sync lags.
• Store category intent, not just SKUs. SKU-level data is useful, but category-level intent (like “haircare” or “running”) is what powers scalable merchandising in welcome and browse abandon.
• Set guardrails for discounting. Add attributes like discount_affinity or promo_last_used_at so you can avoid training repeat buyers to wait for coupons.

Common Mistakes to Avoid

Create or update person in Customer.io can quietly hurt performance when the updates are inconsistent or overwrite better data.

• Overwriting with blanks. If an integration sometimes sends empty values, you can accidentally wipe high-value fields like preferred_category or phone.
• Using inconsistent timestamp formats. Mixed formats break “within last X days” logic and cause segments to misfire.
• Updating too late for suppression. If last_purchase_at is updated minutes after purchase, cart recovery SMS can still send, which drives complaints and unsubscribes.
• Too many one-off attributes. Teams often create new fields for each campaign. That makes segmentation brittle and hard to maintain.
• No documented source of truth. If Shopify says total_spent is $500 and your warehouse says $480, whichever writes last wins, and your VIP program becomes inconsistent.

Summary

Create or update person is the foundation for accurate targeting and suppression across cart recovery, post-purchase, and reactivation. Use it whenever shopper state changes and your next message depends on the latest profile data inside Customer.io.

Implement with Propel

Propel can help you design the attribute schema, identity rules, and workflow placement so Customer.io runs cleanly across welcome, cart, and post-purchase programs. If you want help pressure-testing your setup, book a strategy call.