Data Science For Marketing The Metrics And Models

You’re a marketing manager. You launch an email campaign on a Friday. On Monday, you see sales are up 40%. You high-five your team. The campaign worked, right?

But wait — it was also a holiday weekend. People had time off. They were shopping anyway. The spike might have happened with or without your email.

This is the classic trap in marketing analytics: confusing correlation with causation. It’s the same mistake as the famous ice-cream-and-drowning example — ice cream sales and drowning rates are strongly correlated, but banning ice cream won’t stop drownings. In marketing, the equivalent is assuming your campaign caused a sales lift when a holiday, a competitor’s outage, or a seasonal trend was the real driver.

So how do you separate signal from noise? How do you know which metrics actually matter, and which models give you trustworthy answers?

That’s exactly what this article is about. You’ll learn the core marketing metrics that data scientists actually use, the models that turn raw data into actionable insights, and the pitfalls that trip up even experienced analysts. By the end, you’ll have a unified framework for measuring marketing performance — one that separates real impact from random noise.

Let’s start with the metrics you need to know before you build a single model.

The Core Marketing Metrics You Need to Know (Intuition First)

Before we talk about models, we need to agree on what we’re measuring. Marketers care about a handful of key numbers. Each one tells a different part of the story.

Customer Lifetime Value (CLV)

Plain English: CLV is the total profit a customer is expected to generate over their entire relationship with your business. Not just their first purchase — every purchase they’ll ever make.

Think of it this way: A customer who buys a $50 item once has a low CLV. A customer who buys a$50 item every month for two years has a CLV of $$1,200 (minus costs). That’s the difference between a one-time shopper and a loyal customer.

Customer Acquisition Cost (CAC)

Plain English: CAC is the total cost of convincing a customer to buy from you. It includes ad spend, sales team salaries, software tools — everything it takes to acquire that customer.

Think of it this way: If you spend $1,000 on Facebook ads and get 10 new customers, your CAC is$100 per customer. If CLV is $150, you're profitable. If CLV is$80, you’re losing money on every customer.

Return on Ad Spend (ROAS)

Plain English: ROAS is the revenue generated for every dollar you spend on advertising.

Think of it this way: If you spend $500 on Google Ads and generate$2,000 in revenue, your ROAS is 4:1 — you made $4 for every$1 spent.

Conversion Rate

Plain English: The percentage of users who take a desired action — like making a purchase, signing up for a newsletter, or clicking a link.

Think of it this way: If 100 people visit your landing page and 5 buy something, your conversion rate is 5%.

Churn Rate

Plain English: The percentage of customers who stop doing business with you over a given period (usually a month or year).

Think of it this way: If you start the month with 1,000 customers and lose 50 by the end, your monthly churn rate is 5%.

Net Promoter Score (NPS)

Plain English: A measure of customer loyalty based on a single question: “How likely are you to recommend us to a friend?” Customers answer on a 0-10 scale. Promoters (9-10) minus Detractors (0-6) gives your NPS.

Think of it this way: A positive NPS means more people love you than hate you. A negative NPS means the opposite.

Now let’s calculate these metrics from real data. We’ll use a simulated e-commerce dataset so you can see exactly how the numbers work.

import pandas as pd
import numpy as np

# Set seed for reproducibility
np.random.seed(42)

# Simulate customer transaction data
n_customers = 1000
months = 12

# Generate customer IDs
data = []
for customer_id in range(1, n_customers + 1):
    # Each customer makes a random number of purchases per month (0-5)
    for month in range(1, months + 1):
        purchases = np.random.poisson(lam=0.5)  # average 0.5 purchases per month
        for _ in range(purchases):
            purchase_amount = np.random.uniform(10, 200)  # between $10 and $200
            data.append({
                'customer_id': customer_id,
                'month': month,
                'purchase_amount': purchase_amount
            })

df = pd.DataFrame(data)
print(f"Total transactions: {len(df)}")
print(df.head())

# Calculate CLV per customer
# CLV = total revenue from that customer over all months
customer_revenue = df.groupby('customer_id')['purchase_amount'].sum().reset_index()
customer_revenue.columns = ['customer_id', 'total_revenue']

# Average CLV
avg_clv = customer_revenue['total_revenue'].mean()
print(f"Average Customer Lifetime Value (CLV): ${avg_clv:.2f}")

# Calculate CAC (simulated: assume $50 cost per customer)
cac = 50
print(f"Customer Acquisition Cost (CAC): ${cac:.2f}")
print(f"CLV/CAC ratio: {avg_clv / cac:.2f} (should be > 3 for healthy business)")

# Calculate ROAS (simulated: assume $10,000 total ad spend)
total_ad_spend = 10000
total_revenue = df['purchase_amount'].sum()
roas = total_revenue / total_ad_spend
print(f"Total Revenue: ${total_revenue:.2f}")
print(f"Return on Ad Spend (ROAS): {roas:.2f}:1")

# Calculate conversion rate (simulated: assume 10,000 site visitors)
site_visitors = 10000
conversions = len(df)  # each transaction is a conversion
conversion_rate = conversions / site_visitors * 100
print(f"Conversion Rate: {conversion_rate:.2f}%")

# Calculate churn rate (simulated: customers who made 0 purchases in last 3 months)
last_3_months = df[df['month'] > 9]
active_customers = last_3_months['customer_id'].nunique()
churned_customers = n_customers - active_customers
churn_rate = (churned_customers / n_customers) * 100
print(f"Monthly Churn Rate (estimated): {churn_rate:.2f}%")

What these numbers tell us:

• The average customer generates about $$300 in revenue over their lifetime. That’s your CLV.
• With a $$50 CAC, your CLV/CAC ratio is about 6:1 — that’s healthy (anything above 3:1 is good).
• For every dollar you spend on ads, you get back about $$3 in revenue (ROAS).
• About 5% of your customers leave each month — that’s your churn rate.

These are the building blocks. Now let’s use them to understand your customers better.

Customer Segmentation: Who Are Your Customers, Really?

Not all customers are the same. Some buy frequently but spend little. Some buy once and never come back. Some are your biggest fans, spending hundreds of dollars every month.

Customer segmentation helps you group customers by their behavior so you can tailor your marketing to each group.

RFM Analysis: The Intuitive Way

RFM stands for Recency, Frequency, Monetary. It’s a simple, powerful way to understand customer behavior:

• Recency: How recently did they purchase? (Days since last purchase)
• Frequency: How often do they purchase? (Number of purchases in a period)
• Monetary: How much do they spend? (Total spend in a period)

Think of it this way: A customer who bought yesterday, buys every week, and spends $200 per purchase is very different from someone who bought six months ago, buys once a year, and spends$20.

K-Means Clustering: Automating the Segmentation

K-means is a simple algorithm that groups similar customers together. It’s like a librarian who sorts books into piles by topic — but instead of topics, it sorts customers by how recently, how often, and how much they buy.

This is the hardest part: naming the clusters. You can’t use fixed thresholds like “recency < 20 and frequency > 5 and monetary > 150 = VIP” because the actual clusters depend on your specific data. Instead, name clusters relative to each other — rank them by monetary value and by a recency/frequency composite.

Let’s build a full K-means pipeline.

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

# Set seed for reproducibility
np.random.seed(42)

# Simulate customer transaction data (same as before)
n_customers = 1000
months = 12

data = []
for customer_id in range(1, n_customers + 1):
    for month in range(1, months + 1):
        purchases = np.random.poisson(lam=0.5)
        for _ in range(purchases):
            purchase_amount = np.random.uniform(10, 200)
            data.append({
                'customer_id': customer_id,
                'month': month,
                'purchase_amount': purchase_amount
            })

df = pd.DataFrame(data)

# Compute RFM features
# Recency: days since last purchase (simulate with month number, assume month 12 is most recent)
last_purchase_month = df.groupby('customer_id')['month'].max().reset_index()
last_purchase_month.columns = ['customer_id', 'last_month']
last_purchase_month['recency'] = 12 - last_purchase_month['last_month']  # 0 = most recent

# Frequency: total number of purchases
frequency = df.groupby('customer_id').size().reset_index()
frequency.columns = ['customer_id', 'frequency']

# Monetary: total spend
monetary = df.groupby('customer_id')['purchase_amount'].sum().reset_index()
monetary.columns = ['customer_id', 'monetary']

# Merge into one DataFrame
rfm = last_purchase_month.merge(frequency, on='customer_id').merge(monetary, on='customer_id')
rfm = rfm[['customer_id', 'recency', 'frequency', 'monetary']]

print("RFM Data (first 5 customers):")
print(rfm.head())

# Prepare features for clustering (exclude customer_id)
X = rfm[['recency', 'frequency', 'monetary']].values

# Scale features (important for K-means)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Fit K-means with k=4 clusters
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
rfm['cluster'] = kmeans.fit_predict(X_scaled)

# Examine cluster profiles
cluster_profiles = rfm.groupby('cluster').agg({
    'recency': 'mean',
    'frequency': 'mean',
    'monetary': 'mean',
    'customer_id': 'count'
}).reset_index()
cluster_profiles.columns = ['cluster', 'avg_recency', 'avg_frequency', 'avg_monetary', 'size']
cluster_profiles['percentage'] = (cluster_profiles['size'] / len(rfm)) * 100

print("\nCluster Profiles:")
print(cluster_profiles.round(2))

# Name clusters based on relative rankings
# Rank by monetary value (higher = better)
monetary_rank = cluster_profiles['avg_monetary'].rank(ascending=False)
# Rank by recency/frequency composite (low recency + high frequency = better)
rf_composite = -cluster_profiles['avg_recency'] + cluster_profiles['avg_frequency']
rf_rank = rf_composite.rank(ascending=False)

# Assign names
cluster_names = {}
for i in range(4):
    if monetary_rank[i] <= 2 and rf_rank[i] <= 2:
        cluster_names[i] = 'VIP'
    elif monetary_rank[i] <= 2:
        cluster_names[i] = 'Big Spenders'
    elif rf_rank[i] <= 2:
        cluster_names[i] = 'Frequent Buyers'
    else:
        cluster_names[i] = 'At Risk'

rfm['segment'] = rfm['cluster'].map(cluster_names)

print("\nCluster Names:")
for cluster, name in cluster_names.items():
    print(f"  Cluster {cluster}: {name}")

print("\nSample customers with segments:")
print(rfm.sample(10, random_state=42)[['customer_id', 'recency', 'frequency', 'monetary', 'segment']])

What this tells us:

• VIP customers buy recently, frequently, and spend the most. They’re your best customers.
• Big Spenders spend a lot but don’t buy as often. They might need reminders to come back.
• Frequent Buyers buy often but spend less per purchase. They’re loyal but low-value.
• At Risk customers haven’t bought recently, buy infrequently, and spend little. They might be about to churn.

Now you know who your customers are. But what’s actually driving their purchases? That’s where Marketing Mix Modeling comes in.

Marketing Mix Modeling (MMM): What’s Actually Driving Sales?

You’re spending money on Facebook ads, Google Ads, and TV commercials. Which one is actually working? Which one should you invest more in?

Marketing Mix Modeling (MMM) answers this question by using historical data to estimate the impact of each marketing channel on sales.

The Simple Version: Linear Regression

The simplest form of MMM is a linear regression:

Sales = β₀ + β₁ × TV_spend + β₂ × Digital_spend + β₃ × Print_spend + error

Each coefficient (β) tells you the sales impact of spending one more dollar on that channel, holding everything else constant.

But Wait — There’s a Catch: Multicollinearity

Channels are often correlated. You might increase TV spend during the same period you run a digital campaign. This makes it hard to isolate each channel’s effect. This is called multicollinearity.

So what does that mean for us? We need to check for multicollinearity using VIF (Variance Inflation Factor) and consider using Ridge regression (which adds a penalty to large coefficients) to handle it.

Let’s build an MMM model.

import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.preprocessing import StandardScaler
from statsmodels.stats.outliers_influence import variance_inflation_factor
import statsmodels.api as sm

# Set seed for reproducibility
np.random.seed(42)

# Simulate marketing spend data (52 weeks)
weeks = 52

# Generate correlated channel spends
tv_spend = np.random.uniform(10, 50, weeks)  # $10k-$50k per week
digital_spend = 0.6 * tv_spend + np.random.normal(0, 5, weeks)  # correlated with TV
print_spend = 0.3 * tv_spend + np.random.normal(0, 3, weeks)  # also correlated

# Generate sales with known effects
# True effects: TV = 0.5, Digital = 0.3, Print = 0.2 (per $1k spend)
true_effects = {'TV': 0.5, 'Digital': 0.3, 'Print': 0.2}
sales = (0.5 * tv_spend + 0.3 * digital_spend + 0.2 * print_spend + 
         np.random.normal(0, 5, weeks))  # add noise

# Create DataFrame
df_mmm = pd.DataFrame({
    'week': range(1, weeks + 1),
    'tv_spend': tv_spend,
    'digital_spend': digital_spend,
    'print_spend': print_spend,
    'sales': sales
})

print("Marketing Spend Data (first 5 weeks):")
print(df_mmm.head())

# Prepare features and target
X = df_mmm[['tv_spend', 'digital_spend', 'print_spend']].values
y = df_mmm['sales'].values

# Fit linear regression
lr = LinearRegression()
lr.fit(X, y)

print("\nLinear Regression Results:")
print(f"Intercept: {lr.intercept_:.2f}")
print(f"Coefficients:")
for i, col in enumerate(['TV', 'Digital', 'Print']):
    print(f"  {col}: {lr.coef_[i]:.3f}")

# R-squared
r2_lr = lr.score(X, y)
print(f"R-squared: {r2_lr:.3f}")

# Compare to true effects
print("\nTrue effects vs Estimated:")
for i, col in enumerate(['TV', 'Digital', 'Print']):
    print(f"  {col}: True={true_effects[col]}, Estimated={lr.coef_[i]:.3f}")

# Check for multicollinearity using VIF
# Add constant for VIF calculation
X_with_const = sm.add_constant(X)
vif_data = pd.DataFrame()
vif_data['feature'] = ['const', 'TV', 'Digital', 'Print']
vif_data['VIF'] = [variance_inflation_factor(X_with_const, i) for i in range(X_with_const.shape[1])]

print("\nVariance Inflation Factor (VIF):")
print(vif_data)
print("\nInterpretation: VIF > 5-10 indicates high multicollinearity")

# Apply Ridge regression to handle multicollinearity
ridge = Ridge(alpha=1.0)
ridge.fit(X, y)

print("\nRidge Regression Results (alpha=1.0):")
print(f"Coefficients:")
for i, col in enumerate(['TV', 'Digital', 'Print']):
    print(f"  {col}: {ridge.coef_[i]:.3f}")

# Compare coefficients
print("\nComparison of Coefficients:")
print(f"{'Channel':<10} {'True':<10} {'Linear':<10} {'Ridge':<10}")
print("-" * 40)
for i, col in enumerate(['TV', 'Digital', 'Print']):
    print(f"{col:<10} {true_effects[col]:<10.3f} {lr.coef_[i]:<10.3f} {ridge.coef_[i]:<10.3f}")

What this tells us:

• The linear regression gives us estimates of each channel’s impact. For example, a coefficient of 0.5 for TV spend means that for every $1,000 increase in TV spend, sales increase by$500, holding other channels constant.
• The VIF values tell us if multicollinearity is a problem. Values above 5-10 indicate high correlation between channels.
• Ridge regression shrinks the coefficients, making them more stable when channels are correlated. The coefficients are closer to the true values.

But MMM is based on historical data — it can’t tell us about causation. For that, we need experiments.

A/B Testing: The Gold Standard (But Only If You Do It Right)

A/B testing is the most reliable way to measure causal impact. You randomly assign users to a control group (no treatment) and a treatment group (e.g., a new email design). Then you compare the outcomes.

The Metric: Lift in Conversion Rate

The key metric is the difference in conversion rate between the treatment and control groups. But you need to calculate statistical significance (p-value) and practical significance (effect size).

This Is the Hardest Part: Interpreting p-values

A p-value of 0.03 means there’s a 3% chance of seeing this result (or more extreme) if the null hypothesis were true — not a 97% chance the treatment works.

Think of it this way: A p-value is the probability of being fooled by random chance, not the probability that your treatment is effective.

Common Pitfalls

1. Peeking at results too early: If you check your A/B test every day and stop as soon as you see a significant result, you inflate your false positive rate.
2. Multiple comparisons: If you test 20 different metrics, you’re likely to find at least one “significant” result by chance. Use Bonferroni correction.
3. Small sample sizes: If your sample is too small, you won’t have enough statistical power to detect a real effect.

Let’s simulate an A/B test and see what happens.

import numpy as np
from scipy import stats

# Set seed for reproducibility
np.random.seed(42)

# Simulate an A/B test
n_control = 1000
n_treatment = 1000

# True conversion rates
control_rate = 0.05  # 5%
treatment_rate = 0.07  # 7% (treatment increases conversion by 2 percentage points)

# Generate conversion outcomes (1 = converted, 0 = didn't)
control_conversions = np.random.binomial(1, control_rate, n_control)
treatment_conversions = np.random.binomial(1, treatment_rate, n_treatment)

# Calculate conversion rates
control_conv_rate = control_conversions.mean()
treatment_conv_rate = treatment_conversions.mean()
lift = (treatment_conv_rate - control_conv_rate) / control_conv_rate * 100

print(f"Control conversion rate: {control_conv_rate:.3f} ({control_conversions.sum()}/{n_control})")
print(f"Treatment conversion rate: {treatment_conv_rate:.3f} ({treatment_conversions.sum()}/{n_treatment})")
print(f"Absolute lift: {treatment_conv_rate - control_conv_rate:.3f}")
print(f"Relative lift: {lift:.1f}%")

# Perform chi-squared test for statistical significance
from scipy.stats import chi2_contingency

# Create contingency table
contingency_table = np.array([
    [control_conversions.sum(), n_control - control_conversions.sum()],
    [treatment_conversions.sum(), n_treatment - treatment_conversions.sum()]
])

chi2, p_value, dof, expected = chi2_contingency(contingency_table)

print(f"Chi-squared statistic: {chi2:.3f}")
print(f"P-value: {p_value:.4f}")
print(f"Statistically significant at 0.05 level: {p_value < 0.05}")

# Calculate effect size (Cohen's h)
from scipy.stats import norm

def cohens_h(p1, p2):
    return 2 * np.arcsin(np.sqrt(p1)) - 2 * np.arcsin(np.sqrt(p2))

effect_size = cohens_h(treatment_conv_rate, control_conv_rate)
print(f"Effect size (Cohen's h): {effect_size:.3f}")
print("\nInterpretation:")
print(f"  P-value of {p_value:.4f} means there's a {p_value*100:.2f}% chance of seeing this result")
print(f"  (or more extreme) if the null hypothesis were true.")
print(f"  Effect size of {effect_size:.3f} is {'small' if abs(effect_size) < 0.2 else 'medium' if abs(effect_size) < 0.5 else 'large'}.")

# Demonstrate the problem of peeking
# Simulate checking the test every 100 users
print("\n--- Peeking Problem Demonstration ---")
np.random.seed(42)

# Simulate sequential testing
peek_results = []
for i in range(1, 11):  # 10 peeks
    n = i * 100  # check every 100 users per group
    control_sample = np.random.binomial(1, control_rate, n)
    treatment_sample = np.random.binomial(1, treatment_rate, n)
    
    # Calculate p-value
    cont_table = np.array([
        [control_sample.sum(), n - control_sample.sum()],
        [treatment_sample.sum(), n - treatment_sample.sum()]
    ])
    _, p_val, _, _ = chi2_contingency(cont_table)
    
    peek_results.append({
        'sample_size': n,
        'control_rate': control_sample.mean(),
        'treatment_rate': treatment_sample.mean(),
        'p_value': p_val,
        'significant': p_val < 0.05
    })

peek_df = pd.DataFrame(peek_results)
print(peek_df.round(4))
print("\nNotice how p-values fluctuate! If you stop at the first 'significant' result,")
print("you're more likely to get a false positive.")

What this tells us:

• The A/B test shows a clear lift in conversion rate (about 40% relative improvement).
• The p-value is well below 0.05, so the result is statistically significant.
• But if you peek early, you might see a “significant” result that disappears with more data. That’s why you should decide your sample size in advance and not peek.

Causal Inference: When You Can’t Run an A/B Test

Sometimes you can’t run an A/B test. Maybe you can’t randomly assign users to a TV ad. Maybe a policy change affected everyone at once. In these cases, you need causal inference methods.

Difference-in-Differences (DiD)

Intuition before formalism: You want to know if a new ad campaign increased sales. You compare sales before and after the campaign in the exposed region, and compare that to the change in a similar region that wasn’t exposed.

Think of it this way: If Region A (exposed) saw sales go from $100k to$150k, and Region B (control) saw sales go from $100k to$110k, the DiD estimate is ($150k -$100k) - ($110k -$100k) = $40k. That$40k is the causal impact of the campaign.

Instrumental Variables (IV)

This is the hardest part: finding a valid instrument. An instrument is a variable that affects the treatment but not the outcome directly. For example, distance to a store might affect whether someone receives an in-store promotion, but it shouldn’t directly affect their spending (except through the promotion).

The instrument must satisfy two conditions:

1. Relevance: It’s strongly correlated with the treatment.
2. Exclusion restriction: It affects the outcome only through the treatment.

Let’s implement a simple DiD analysis.

import pandas as pd
import numpy as np
import statsmodels.api as sm

# Set seed for reproducibility
np.random.seed(42)

# Simulate DiD data
# Two regions: Treatment (exposed to campaign) and Control (not exposed)
# Time periods: Pre-campaign (0) and Post-campaign (1)

n_per_group = 500  # customers per region per time period

# Generate baseline sales (in dollars)
baseline_sales = 100  # average $100 per customer

# True causal effect of campaign: $30 increase
causal_effect = 30

# Generate data
data = []

# Control region, pre-campaign
for _ in range(n_per_group):
    sales = baseline_sales + np.random.normal(0, 20)
    data.append({'region': 'Control', 'time': 'Pre', 'sales': sales, 'exposed': 0})

# Control region, post-campaign
for _ in range(n_per_group):
    sales = baseline_sales + 5 + np.random.normal(0, 20)  # natural growth of $5
    data.append({'region': 'Control', 'time': 'Post', 'sales': sales, 'exposed': 0})

# Treatment region, pre-campaign
for _ in range(n_per_group):
    sales = baseline_sales + np.random.normal(0, 20)
    data.append({'region': 'Treatment', 'time': 'Pre', 'sales': sales, 'exposed': 0})

# Treatment region, post-campaign
for _ in range(n_per_group):
    sales = baseline_sales + 5 + causal_effect + np.random.normal(0, 20)  # natural growth + campaign effect
    data.append({'region': 'Treatment', 'time': 'Post', 'sales': sales, 'exposed': 1})

df_did = pd.DataFrame(data)

print("DiD Data Summary:")
print(df_did.groupby(['region', 'time'])['sales'].describe().round(2))

# Calculate DiD estimate manually
# Step 1: Calculate means for each group
means = df_did.groupby(['region', 'time'])['sales'].mean()

control_pre = means[('Control', 'Pre')]
control_post = means[('Control', 'Post')]
treatment_pre = means[('Treatment', 'Pre')]
treatment_post = means[('Treatment', 'Post')]

print(f"\nMean sales by group:")
print(f"  Control, Pre: ${control_pre:.2f}")
print(f"  Control, Post: ${control_post:.2f}")
print(f"  Treatment, Pre: ${treatment_pre:.2f}")
print(f"  Treatment, Post: ${treatment_post:.2f}")

# DiD estimate = (Treatment_post - Treatment_pre) - (Control_post - Control_pre)
treatment_change = treatment_post - treatment_pre
control_change = control_post - control_pre
did_estimate = treatment_change - control_change

print(f"\nChange in Control: ${control_change:.2f}")
print(f"Change in Treatment: ${treatment_change:.2f}")
print(f"DiD Estimate (causal effect): ${did_estimate:.2f}")
print(f"True causal effect: ${causal_effect:.2f}")

# Do the same with regression (more formal)
# Create dummy variables
df_did['post'] = (df_did['time'] == 'Post').astype(int)
df_did['treatment'] = (df_did['region'] == 'Treatment').astype(int)
df_did['interaction'] = df_did['post'] * df_did['treatment']

# Regression: sales = β0 + β1*post + β2*treatment + β3*interaction + error
X = df_did[['post', 'treatment', 'interaction']].values
y = df_did['sales'].values
X_with_const = sm.add_constant(X)

model = sm.OLS(y, X_with_const).fit()
print("\nDiD Regression Results:")
print(model.summary().tables[1])

# The coefficient for 'interaction' is the DiD estimate
print(f"\nDiD estimate from regression: ${model.params[3]:.2f}")

What this tells us:

• The DiD estimate ($30) matches the true causal effect ($30) — the campaign increased sales by $$30 per customer.
• The regression gives us the same answer with standard errors and confidence intervals.
• This method works because we’re controlling for time trends (the control group’s change) and time-invariant differences between regions.

Putting It All Together: A Unified Measurement Framework

Now you have all the pieces. Here’s how they work together in a real marketing data science workflow:

The Framework

1. Start with customer segmentation (RFM + K-means) to understand your audience. Who are your VIPs? Who’s at risk of churning?

2. Use MMM to attribute sales to channels and optimize budget allocation. Which channel gives you the best ROAS?

3. Run A/B tests to validate specific campaigns and creative changes. Does the new email design actually increase conversions?

4. Use causal inference (DiD or IV) for campaigns that can’t be randomized. Did that TV ad really drive sales, or was it just seasonal?

5. Monitor CLV, CAC, and churn over time to track long-term health. Are you acquiring customers profitably? Are they sticking around?

Key Findings from Our Analysis

Metric / Model	Result	Interpretation
Average CLV	~$$300	Each customer generates about $$300 in lifetime revenue
CLV/CAC Ratio	~6:1	Healthy business (target > 3:1)
ROAS	~3:1	For every $1 spent on ads, you get$3 back
Churn Rate	~5% monthly	5% of customers leave each month
Customer Segments	4 clusters	VIP, Big Spenders, Frequent Buyers, At Risk
MMM (Linear Regression)	TV: 0.5, Digital: 0.3, Print: 0.2	Per $1k spend, TV drives $500 in sales, Digital$300, Print $$200
A/B Test Lift	~40% relative increase	New email design significantly improves conversion
DiD Estimate	~$$30 per customer	Campaign increased sales by $$30 per customer

Important note: These numbers come from our simulated dataset with a specific random seed. In real-world data, the exact numbers will differ, but the framework and interpretation remain the same.

Recap: What You’ve Learned

• Core marketing metrics (CLV, CAC, ROAS, conversion rate, churn rate, NPS) give you the foundation for measuring performance.
• Customer segmentation (RFM + K-means) helps you understand different customer groups and tailor your marketing.
• Marketing Mix Modeling (MMM) attributes sales to different channels, but watch out for multicollinearity.
• A/B testing is the gold standard for causal measurement, but you need to avoid peeking and multiple comparisons.
• Causal inference (DiD, IV) helps when you can’t run an experiment.

These tools work together to give you a complete picture of your marketing performance — one that separates real impact from random noise.

Check Your Understanding

Remember:

• What does CLV stand for, and what does it measure?
• What are the three components of RFM analysis?

Understand:

• Why is it dangerous to confuse correlation with causation in marketing?
• Explain in plain English what a p-value of 0.03 means.

Apply:

• Given a dataset with customer transactions, calculate the average CLV and CAC.
• Run a K-means clustering on RFM features and name the resulting segments.

Analyze:

• Your MMM shows a coefficient of 0.8 for TV spend, but VIF is 12. What’s the problem, and how would you fix it?
• An A/B test shows a p-value of 0.04 after checking every 100 users. Why might this be misleading?

Evaluate:

• A colleague claims that a new Facebook campaign caused a 20% sales increase. You notice the campaign ran during a major holiday. How would you evaluate this claim?
• Compare the strengths and weaknesses of MMM vs. A/B testing for measuring marketing effectiveness.

Create:

• Design a measurement framework for a company launching a new product. Which metrics would you track? Which models would you use? How would you validate the results?

Related articles

• Data Science for Marketing: The Metrics and Models That Actually Get Used — This is the article you just read. It covers the foundational metrics and models.
• Causal Inference for Marketers: When A/B Tests Aren’t Possible — A deeper dive into DiD, IV, and other causal methods for marketing.
• Customer Segmentation with RFM and K-Means: A Complete Guide — An extended tutorial on segmentation with real-world case studies.