Customer Lifetime Value

Customer Lifetime Value

Overview

Customer Lifetime Value (CLV) tells you the total net revenue expected from a customer over their relationship with your store, enabling smarter decisions on acquisition spend, retention investment, and customer tier management. Most platforms calculate historical CLV (total spent to date) natively. For predictive CLV and churn risk scoring, use a dedicated analytics app (Klaviyo, Metorik, Triple Whale) or build a custom model for stores with 10k+ customers.

When to Use This Skill

• When setting CAC targets for acquisition channels based on expected return
• When building a VIP tier program that needs a quantitative threshold
• When predicting which customers are likely to churn and triggering win-back automation
• When calculating the ROI of retention programs (loyalty points, VIP benefits)
• When segmenting customers by predicted future value rather than historical spend alone

Core Instructions

Step 1: Determine platform and choose the right CLV tool

---

Step 2: Access and track historical CLV

Historical CLV is the sum of all revenue from a customer. Platforms show this natively.

Shopify

1. Go to Admin → Analytics → Reports → Customers over time — shows total customers, orders, and revenue by cohort 2. Go to Admin → Customers → [Customer] — each customer profile shows total spent, order count, and last order date 3. For bulk export: go to Customers → Export — the CSV includes Total Spent and Number of Orders per customer

More advanced CLV reporting:

• Install Lifetimely from the App Store — provides cohort-based LTV curves, payback period by acquisition channel, and predicted future spend
• Install Triple Whale — includes CLV by acquisition source, cohort analysis, and attribution modeling

WooCommerce

1. Go to WooCommerce → Analytics → Customers — shows lifetime value, order count, and average order value per customer 2. Sort by Lifetime value descending to see your top customers 3. Filter by date range to see CLV for specific acquisition cohorts

Metorik for deeper analytics:

• Install Metorik (connects via WooCommerce REST API)
• Metorik's customer dashboard shows CLV distributions, cohort retention, and automatically flags at-risk customers
• Metorik Pro adds churn probability scoring and automated win-back email triggers

BigCommerce

1. Go to Analytics → Customers for a summary of customer spending 2. Individual customer profiles show total orders and lifetime spend 3. For cohort analysis: connect Google Analytics 4 and use the User Lifetime reports

---

Step 3: Set up CLV-based customer segments

Once you can measure CLV, create segments to target different value tiers with different messaging.

Shopify + Klaviyo

1. In Klaviyo, go to Lists & Segments → Create Segment 2. Create a "VIP Customers" segment: Customer → Predicted CLV is greater than $500 (Klaviyo calculates predicted CLV automatically for Shopify stores) 3. Create an "At Risk - High Value" segment: Customer → Predicted CLV > $200 AND Last order date is more than 90 days ago 4. Use these segments as audiences for targeted email flows

Klaviyo's predictive analytics (available on paid plans):

• Klaviyo shows Predicted CLV, Churn Risk, and Predicted Next Order Date per profile
• Find these under Analytics → Predictive Analytics or on individual customer profiles
• Use these predictions as segment filters without any custom code

WooCommerce + Klaviyo

1. Install Klaviyo for WooCommerce from WordPress.org 2. Klaviyo syncs customer purchase history automatically 3. Create the same CLV-based segments as described above

---

Step 4: Automate retention based on CLV and churn risk

Once segments are defined, create automated flows for each tier.

Win-back flow for high-value at-risk customers:

Klaviyo (all platforms): 1. Go to Flows → Create Flow → Win-Back 2. Set trigger: customer enters the "At Risk - High Value" segment 3. Configure the sequence:

• Day 0: personalized email — "We miss you" with product recommendations based on purchase history
• Day 7: email with a small incentive (free shipping or 10% off)
• Day 14: final email from the "founder" or customer success team

4. Stop the flow if the customer makes a purchase (add a flow filter: "Ordered zero times since starting this flow")

VIP tier recognition: 1. Create a VIP segment (CLV > $500 or 5+ orders) 2. When a customer enters the segment, send a personalized "You're now a VIP" email with exclusive benefits 3. On Shopify: tag the customer with vip automatically using Shopify Flow (Plus) or a tagging app; use the tag to show VIP-specific content on the storefront

---

Custom / Headless

For stores building their own CLV calculations:

// lib/clv.ts

// Simple parametric CLV prediction — practical for most stores
export function calculatePredictedCLV(inputs: {
  avgOrderValue: number;
  avgOrderFrequencyPerYear: number;
  avgCustomerLifespanYears: number;
  grossMarginRate: number;
}): number {
  const { avgOrderValue, avgOrderFrequencyPerYear, avgCustomerLifespanYears, grossMarginRate } = inputs;
  return avgOrderValue * avgOrderFrequencyPerYear * avgCustomerLifespanYears * grossMarginRate;
}

// Per-customer prediction from their actual order history
export async function predictCustomerCLV(customerId: string, projectionYears = 2): Promise<number> {
  const orders = await db.orders.findMany({
    where: { customerId, status: { notIn: ['cancelled', 'refunded'] } },
    orderBy: { createdAt: 'asc' },
  });
  if (orders.length < 2) return 0;  // Not enough history

  const dates = orders.map(o => o.createdAt.getTime());
  const tenureDays = (dates[dates.length - 1] - dates[0]) / 86400000;
  const avgIntervalDays = tenureDays / (orders.length - 1);
  const purchasesPerYear = 365 / avgIntervalDays;
  const aov = orders.reduce((sum, o) => sum + o.subtotalCents / 100, 0) / orders.length;

  // Reduce projection for customers who haven't ordered recently
  const daysSinceLast = (Date.now() - dates[dates.length - 1]) / 86400000;
  const effectiveYears = daysSinceLast < 90 ? projectionYears : projectionYears * 0.5;

  return aov * purchasesPerYear * effectiveYears * 0.50;  // 50% gross margin
}

// Churn probability based on recency vs. typical purchase cadence
export async function calculateChurnProbability(customerId: string): Promise<number> {
  const orders = await db.orders.findMany({
    where: { customerId, status: { notIn: ['cancelled', 'refunded'] } },
    orderBy: { createdAt: 'desc' },
  });

  if (orders.length === 0) return 0.95;
  if (orders.length === 1) return 0.65;

  const daysSinceLast = (Date.now() - orders[0].createdAt.getTime()) / 86400000;
  const avgInterval = orders.slice(0, -1).reduce((sum, o, i) =>
    sum + (o.createdAt.getTime() - orders[i + 1].createdAt.getTime()) / 86400000, 0) / (orders.length - 1);

  // Sigmoid: churn probability rises as recency exceeds 2× typical interval
  const recencyRatio = daysSinceLast / avgInterval;
  return Math.min(0.99, Math.max(0.01, 1 / (1 + Math.exp(-2 * (recencyRatio - 2)))));
}

// Nightly job: update CLV scores and trigger win-back automation
export async function runChurnPreventionNightly() {
  const activeCustomers = await db.customers.findMany({ where: { orderCount: { gte: 2 } } });

  for (const customer of activeCustomers) {
    const [churnProbability, predictedCLV] = await Promise.all([
      calculateChurnProbability(customer.id),
      predictCustomerCLV(customer.id),
    ]);

    await db.customers.update({ where: { id: customer.id }, data: { churnProbability, predictedCLV } });

    // High-value, high-churn-risk: trigger win-back
    if (churnProbability > 0.70 && predictedCLV > 200) {
      const alreadyTriggered = await db.winBackTriggers.findFirst({
        where: { customerId: customer.id, createdAt: { gte: new Date(Date.now() - 90 * 86400000) } },
      });
      if (!alreadyTriggered) {
        await klaviyo.triggerFlow(customer.email, 'win-back-high-value');
        await db.winBackTriggers.create({ data: { customerId: customer.id } });
      }
    }
  }
}

For stores with 100k+ customers: Use the BG/NBD probabilistic model (Python lifetimes library) for significantly more accurate predictions than the parametric approach:

from lifetimes import BetaGeoFitter, GammaGammaFitter
from lifetimes.utils import summary_data_from_transaction_data

# Build RFM summary and fit BG/NBD model
rfm = summary_data_from_transaction_data(orders_df, 'customer_id', 'created_at', 'subtotal_cents')
bgf = BetaGeoFitter(penalizer_coef=0.001)
bgf.fit(rfm['frequency'], rfm['recency'], rfm['T'])

ggf = GammaGammaFitter(penalizer_coef=0.001)
ggf.fit(rfm[rfm['frequency'] > 0]['frequency'], rfm[rfm['frequency'] > 0]['monetary_value'])

rfm['predicted_clv_12mo'] = ggf.customer_lifetime_value(bgf, rfm['frequency'], rfm['recency'], rfm['T'], rfm['monetary_value'], time=12, discount_rate=0.01)

Best Practices

• Use Klaviyo's predictive CLV for Shopify/WooCommerce before building anything custom — their model is well-calibrated and works out of the box
• Refresh CLV scores weekly at minimum — customer behavior changes; stale scores lead to mistargeted retention campaigns
• Separate predicted CLV from historical spend in your segments — they answer different questions: historical shows past value, predicted shows where to invest
• Set CAC ceilings per acquisition channel based on CLV — if average CLV from Google Ads customers is $80 at 50% margin, your maximum sustainable CAC is $40
• Calibrate churn probability against actual outcomes — compare predictions from 6 months ago to who actually churned; adjust thresholds if the model is over- or under-predicting

Common Pitfalls

Related Skills

• @customer-segmentation
• @referral-program
• @personalization-engine

Probabilistic Customer Lifetime Value Prediction

Problem/Feature Description

FreshCart, an online grocery platform with over 80,000 repeat customers, wants to move beyond rule-based customer segmentation and adopt a statistically rigorous approach to predicting which customers are most valuable over the next year. Their head of analytics has heard about probabilistic models that account for both purchase frequency and order value separately, and wants to evaluate one for use in their annual customer value report.

The data team has an export of completed orders from the last 3 years. They want a Python script that ingests this transaction data, fits a probabilistic model, and outputs a 12-month predicted CLV for each customer — ready to be imported back into their data warehouse. The script should be production-quality: documented, reproducible, and designed to be rerun monthly without overfitting on any particular data slice.

Output Specification

Produce a Python script clv_model.py that:

1. Loads transaction data from the provided CSV file (see Input Files below) 2. Prepares the RFM (recency, frequency, monetary) summary needed for model fitting 3. Fits the appropriate probabilistic models for purchase frequency and monetary value 4. Generates 12-month CLV predictions for all customers 5. Saves predictions to clv_predictions.csv with columns: customer_id, predicted_clv_12mo

Also produce a model-notes.md file that explains:

• Which Python library and model classes are used
• The regularization approach and the coefficient value chosen
• Why customers with zero repeat purchases are handled separately in one of the model fitting steps
• The discount rate assumption used for the time-value calculation

Input Files

The following files are provided as inputs. Extract them before beginning.

=============== FILE: inputs/orders.csv =============== customer_id,created_at,subtotal_cents,status C001,2022-01-15,4500,completed C001,2022-04-20,5200,completed C001,2022-09-10,4800,completed C001,2023-02-14,5100,completed C001,2023-08-22,4900,completed C002,2022-03-01,12000,completed C002,2022-06-15,9800,completed C002,2023-01-10,11500,completed C002,2023-07-20,10200,completed C002,2024-02-08,11000,completed C003,2022-05-20,3200,completed C003,2023-11-30,2900,completed C004,2022-02-10,6700,completed C004,2022-05-18,7200,completed C004,2022-11-25,6900,completed C004,2023-04-12,7100,completed C004,2023-10-08,6800,completed C004,2024-03-15,7300,completed C005,2022-07-01,2100,completed C005,2022-10-15,1950,completed C005,2023-03-22,2200,completed C006,2022-08-10,15000,completed C006,2023-02-28,14500,completed C006,2023-09-14,16000,completed C006,2024-01-20,15500,completed C007,2022-04-05,890,completed C007,2023-12-01,920,completed C008,2022-06-20,5500,completed C008,2022-09-30,5800,completed C008,2023-01-15,5300,completed C008,2023-06-10,5600,completed C008,2023-12-05,5400,completed C008,2024-04-01,5700,completed C009,2022-11-01,3400,completed C010,2022-03-15,8900,completed C010,2022-07-22,9200,completed C010,2023-01-08,8700,completed C010,2023-08-14,9100,completed C010,2024-02-20,8800,completed

Customer Value Prediction Engine

Problem/Feature Description

Petal & Co., a growing direct-to-consumer flower subscription service, wants to prioritize customer support and marketing spend more intelligently. Their current approach treats all customers equally, but the team suspects a small segment of loyal customers generates the majority of revenue. Before investing in a full data science platform, they want a lightweight TypeScript utility that predicts how much each customer is worth going forward and how likely they are to stop buying.

The engineering team has access to each customer's order history (order IDs, timestamps, amounts) and wants two things: a function that computes a forward-looking predicted lifetime value per customer, and a function that produces a churn probability score between 0 and 1. Both functions will be called from a nightly background job that processes the entire active customer base.

Output Specification

Produce a single TypeScript file clv.ts that exports:

1. calculatePredictedCLV(inputs) — a pure function that takes aggregate statistics and returns a numeric CLV prediction 2. predictCustomerCLV(customerId, projectionYears?) — an async function that queries order history from a db object and returns a predicted CLV value 3. calculateChurnProbability(customerId) — an async function that queries order history from a db object and returns a churn probability score

The db object is assumed to be available in scope (you can declare it as a module-level import or constant). Write the logic so another developer can read it and understand the calculation approach.

Also produce a README.md that:

• Describes the formulas and thresholds used in each function
• Lists the key assumptions (e.g., gross margin rate used, how recency affects projections)

Input Files

No additional input files are provided. Implement the functions based on your knowledge of CLV modeling best practices.

Nightly Retention Engine and Loyalty Tier System

Problem/Feature Description

Nomad Outfitters, an outdoor gear retailer with 50,000 active customers, is losing roughly 12% of their mid-tier customers each quarter — mostly to a competitor running aggressive promotions. The retention team has identified that timely, targeted outreach is the difference between winning back a lapsing customer and losing them permanently, but right now all outreach is manual and sporadic.

They want two things built: First, a nightly automated job that evaluates each customer's predicted CLV and churn risk and routes them into the appropriate action — high-risk, high-value customers should receive a win-back campaign while moderately at-risk customers should get a personalized nurture touch. Second, a loyalty tier assignment function that segments customers into named tiers (platinum, gold, silver, standard) based on their predicted and historical value, so the merchandising team can adjust offers accordingly.

The existing codebase already has calculateChurnProbability(customerId), predictCustomerCLV(customerId), and db.customers.findActiveWithOrders({ minOrders }) available. The email/action triggers triggerWinBackFlow(customerId, opts) and triggerPersonalizedNurtureEmail(customerId) are also available as imported functions.

Output Specification

Produce a TypeScript file retention.ts that exports:

1. runChurnPreventionAutomation() — the nightly job function 2. assignCustomerTier(customerId) — tier assignment based on CLV values

Also write a retention-design.md file documenting:

• The churn probability thresholds used to route customers into different actions
• The CLV threshold used to decide whether a win-back discount is justified
• How the tier thresholds and blending weights are determined
• Any idempotency or duplicate-prevention logic used

Input Files

No additional input files are provided. The functions listed above (db, triggerWinBackFlow, etc.) can be treated as available in scope.