Business Use Cases by Industry

Analytics is not abstract. Every technique you learn in this course exists because a real business had a real problem that cost real money. This file grounds the theory in industry-specific examples so that when you sit across from a hiring manager or a stakeholder, you can talk fluently about their world.

Learning Objectives

• Recognize analytics use cases across five major industries
• Articulate the business question, the data needed, and the expected output for each use case
• Connect use cases to the analytics types covered in the previous file

---

How to Use This File

Each industry section follows the same structure: 1. The core business problem analytics solves in that industry 2. Specific use cases with the business question, data sources, and output format 3. A worked example showing what the analysis actually produces

Study the industries relevant to your target role. Skim the rest — you will encounter cross-industry patterns throughout your career.

---

Retail and E-commerce

The core problem: Retail is a margin game. Every unit of unsold inventory and every lost customer is a direct hit to profitability. Analytics in retail is primarily about understanding customer behavior and optimizing inventory.

Use Case 1: Customer Segmentation

Business question: Which customers are most valuable, and how do we treat them differently?

Data needed: - Transaction history (order date, items, amounts) - Customer profile (acquisition channel, signup date, demographics) - Product catalog (category, margin, price tier)

Method: RFM segmentation (Recency, Frequency, Monetary value)

import pandas as pd
from datetime import datetime

# Load transaction data
orders = pd.read_csv("orders.csv", parse_dates=["order_date"])
snapshot_date = datetime(2024, 9, 30)

# Calculate RFM metrics per customer
rfm = orders.groupby("customer_id").agg(
    recency=("order_date", lambda x: (snapshot_date - x.max()).days),
    frequency=("order_id", "count"),
    monetary=("order_value", "sum")
).reset_index()

# Score each dimension 1–5 (5 = best)
rfm["r_score"] = pd.qcut(rfm["recency"], 5, labels=[5, 4, 3, 2, 1]).astype(int)
rfm["f_score"] = pd.qcut(rfm["frequency"].rank(method="first"), 5, labels=[1, 2, 3, 4, 5]).astype(int)
rfm["m_score"] = pd.qcut(rfm["monetary"], 5, labels=[1, 2, 3, 4, 5]).astype(int)

rfm["rfm_segment"] = rfm["r_score"].astype(str) + rfm["f_score"].astype(str) + rfm["m_score"].astype(str)

# Label key segments
def label_segment(row):
    if row["r_score"] >= 4 and row["f_score"] >= 4 and row["m_score"] >= 4:
        return "Champions"
    elif row["r_score"] >= 4 and row["f_score"] <= 2:
        return "New Customers"
    elif row["r_score"] <= 2 and row["f_score"] >= 4:
        return "At Risk"
    elif row["r_score"] <= 1 and row["f_score"] >= 4:
        return "Lost"
    else:
        return "Potential Loyalists"

rfm["label"] = rfm.apply(label_segment, axis=1)
print(rfm.groupby("label").agg(
    customers=("customer_id", "count"),
    avg_monetary=("monetary", "mean"),
    avg_recency=("recency", "mean")
))

Output format: Segment membership table + recommended action per segment (retention email for "At Risk", win-back campaign for "Lost", VIP treatment for "Champions")

---

Use Case 2: Basket Analysis (Market Basket / Association Rules)

Business question: Which products are most commonly purchased together, and how do we use this for cross-selling?

Data needed: Transaction-level data with one row per product per order

Output format: Product pair table with support, confidence, and lift metrics, used by the merchandising team for product placement and recommendation engine rules

Key metric — Lift: - Lift > 1.0: The two products are purchased together more often than chance - Lift > 1.5: Strong association worth acting on - Lift > 3.0: Very strong — probably a canonical bundle

---

Use Case 3: Inventory Optimization

Business question: How much of each SKU should we stock to minimize stockouts without over-investing in inventory?

Data needed: Historical sales by SKU, lead times from suppliers, holding costs, stockout costs

Output format: Reorder point and safety stock calculation per SKU, delivered to the supply chain team as a weekly automated report

Formula:

Reorder Point = (Average Daily Demand × Lead Time) + Safety Stock
Safety Stock  = Z × σ_demand × √(Lead Time)

Where:
  Z = service level z-score (e.g., 1.645 for 95%)
  σ_demand = standard deviation of daily demand

---

Healthcare

The core problem: Healthcare analytics operates under a constraint that retail does not: errors have human consequences, not just financial ones. Analytics in healthcare focuses on outcomes, resource utilization, and population health management.

Use Case 1: Hospital Readmission Analysis

Business question: Which patients are at high risk of being readmitted within 30 days, and what interventions reduce that risk?

Data needed: - Patient admission and discharge records - Diagnosis codes (ICD-10) - Procedure codes - Length of stay - Prior admission history - Demographics (age, insurance type, zip code as proxy for social determinants)

Output format: Patient risk score (0–100) generated at discharge, with flagged patients routed to the care coordination team for follow-up calls

Why it matters: 30-day readmissions are a primary metric for CMS value-based care programs. Hospitals are financially penalized for excess readmissions in certain diagnosis groups (CHF, pneumonia, COPD, hip/knee replacement, CABG).

Use Case 2: Staffing and Capacity Analysis

Business question: How do we align nurse staffing levels to patient census patterns to avoid both understaffing and costly overtime?

Data needed: - Historical patient census by hour and day of week - Admission and discharge timestamps - Nurse schedules and hours worked - Overtime cost data

Output format: Predicted census by unit by shift for the next 2 weeks, delivered to nursing managers every Sunday evening

-- Average census by day of week and shift
SELECT
    DAYNAME(admission_date)                          AS day_of_week,
    HOUR(admission_date) / 8                         AS shift_number,  -- 0=nights, 1=days, 2=evenings
    unit,
    AVG(patient_count)                               AS avg_census,
    STDDEV(patient_count)                            AS census_stddev,
    PERCENTILE_CONT(0.90) WITHIN GROUP
        (ORDER BY patient_count) OVER (
        PARTITION BY DAYNAME(admission_date), unit)  AS p90_census
FROM daily_census
WHERE census_date >= DATE_SUB(CURRENT_DATE, INTERVAL 90 DAY)
GROUP BY 1, 2, 3;

Use Case 3: Patient Outcome Tracking

Business question: Are patients with Diagnosis X achieving expected outcomes under our current treatment protocol?

Output format: Outcomes dashboard by diagnosis group and physician, reviewed monthly by medical leadership in quality improvement meetings

---

Finance and Banking

The core problem: Finance analytics operates under intense regulatory scrutiny and risk management requirements. The analytics questions are about identifying risk, explaining variance, and optimizing portfolio performance.

Use Case 1: Fraud Detection

Business question: Which transactions are likely fraudulent, so we can block or flag them in real time?

Data needed: - Transaction records (amount, merchant, timestamp, geolocation, device) - Customer baseline behavior (typical spend patterns, usual merchants) - Known fraud labels (chargebacks, confirmed fraud cases)

Method: The analyst role here is typically building the training dataset, computing features, and evaluating model performance. The data science team builds the model. Without clean labeled data, there is no model.

Key features analysts typically engineer:

# Transaction features for fraud detection
def compute_fraud_features(df, lookback_days=30):
    df = df.sort_values(["customer_id", "transaction_timestamp"])

    # Velocity features: how unusual is this transaction relative to history?
    df["txn_count_30d"] = df.groupby("customer_id")["transaction_id"] \
                            .transform(lambda x: x.rolling(lookback_days).count())
    df["avg_amount_30d"] = df.groupby("customer_id")["amount"] \
                             .transform(lambda x: x.rolling(lookback_days).mean())
    df["amount_vs_avg"] = df["amount"] / df["avg_amount_30d"].replace(0, 1)

    # Location features
    df["is_foreign_country"] = df["merchant_country"] != df["home_country"]
    df["hour_of_day"] = pd.to_datetime(df["transaction_timestamp"]).dt.hour
    df["is_unusual_hour"] = df["hour_of_day"].between(0, 5)  # midnight–5am

    return df

Use Case 2: Credit Risk Scoring

Business question: How likely is this loan applicant to default within 12 months?

Data needed: Application data, credit bureau data (credit score, utilization, derogatory marks), income verification, existing portfolio performance

Output format: Probability of default (PD) score, used by underwriting to approve/reject/price applications

Key analyst deliverable: Not the model itself, but the monitoring dashboard that tracks model performance over time — whether the approved loan population is performing as the model predicted.

Use Case 3: Portfolio Performance Attribution

Business question: What drove the portfolio's returns this quarter — asset allocation, security selection, or factor exposures?

Output format: Attribution report breaking down returns into systematic and idiosyncratic components, delivered to portfolio managers and risk committee

---

Marketing

The core problem: Marketing has the most analytics budget and the least consensus on what the numbers mean. Attribution — connecting spend to outcomes — is the central challenge.

Use Case 1: Multi-Touch Attribution

Business question: Which marketing channels and touchpoints actually drove a customer to convert?

Why it's hard: A customer might see a Facebook ad, search for the product on Google, click a retargeting ad, receive an email, and then convert. Which channel gets credit?

Attribution models:

Model	Logic	Strength	Weakness
Last touch	100% credit to last touchpoint	Simple, measurable	Ignores all prior influence
First touch	100% credit to first touchpoint	Shows acquisition channel	Ignores conversion driver
Linear	Equal credit to all touchpoints	Balanced	Assumes equal importance
Time decay	More credit to recent touchpoints	Favors closers	Ignores top-of-funnel
Data-driven	Algorithmic based on actual paths	Most accurate	Requires large dataset

-- Last-touch attribution: revenue credited to the last channel before conversion
SELECT
    last_channel,
    COUNT(DISTINCT customer_id) AS conversions,
    SUM(order_value)            AS attributed_revenue,
    SUM(order_value) / COUNT(DISTINCT customer_id) AS revenue_per_conversion
FROM (
    SELECT
        customer_id,
        order_value,
        LAST_VALUE(channel) OVER (
            PARTITION BY customer_id
            ORDER BY touchpoint_timestamp
            ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
        ) AS last_channel
    FROM customer_journey
    WHERE converted = 1
) AS attributed
GROUP BY last_channel
ORDER BY attributed_revenue DESC;

Use Case 2: Funnel Analysis

Business question: Where in the customer journey are we losing people, and what is the drop-off rate at each step?

Data needed: User event data (page views, button clicks, form submissions, purchases)

Output format: Funnel chart showing conversion rate at each step, with segment breakdowns (mobile vs desktop, new vs returning, by acquisition channel)

-- Conversion funnel: visit → product_view → add_to_cart → purchase
WITH funnel AS (
    SELECT
        user_id,
        MAX(CASE WHEN event_type = 'visit'        THEN 1 ELSE 0 END) AS visited,
        MAX(CASE WHEN event_type = 'product_view' THEN 1 ELSE 0 END) AS viewed_product,
        MAX(CASE WHEN event_type = 'add_to_cart'  THEN 1 ELSE 0 END) AS added_to_cart,
        MAX(CASE WHEN event_type = 'purchase'     THEN 1 ELSE 0 END) AS purchased
    FROM user_events
    WHERE event_date = CURRENT_DATE - 7
    GROUP BY user_id
)
SELECT
    SUM(visited)        AS step1_visits,
    SUM(viewed_product) AS step2_product_views,
    SUM(added_to_cart)  AS step3_cart_adds,
    SUM(purchased)      AS step4_purchases,
    ROUND(SUM(viewed_product) / NULLIF(SUM(visited), 0) * 100, 1)        AS visit_to_view_pct,
    ROUND(SUM(added_to_cart)  / NULLIF(SUM(viewed_product), 0) * 100, 1) AS view_to_cart_pct,
    ROUND(SUM(purchased)      / NULLIF(SUM(added_to_cart), 0) * 100, 1)  AS cart_to_purchase_pct
FROM funnel;

Use Case 3: Campaign ROI Analysis

Business question: Did this campaign generate more revenue than it cost?

Output format: Campaign P&L showing spend, attributed revenue, incremental revenue (vs baseline), ROAS, and net ROI, with confidence intervals if an A/B test was run

---

HR and People Analytics

The core problem: HR analytics is growing rapidly but is culturally sensitive. The questions involve real people's careers and livelihoods. Data quality is often poor (manual entry into HRIS systems). Privacy and ethics constraints are real.

Use Case 1: Attrition Prediction

Business question: Which employees are at highest risk of leaving in the next 6 months?

Data needed: - HRIS data: tenure, compensation, role, manager, performance ratings, promotion history - Engagement survey scores (if available) - System access logs (sometimes a proxy for disengagement) - Exit interview data (for training labels)

Output format: Risk score per employee, reviewed by HR business partners (not direct managers) with recommended retention interventions

Ethics in people analytics

Sharing individual attrition risk scores directly with managers creates a conflict of interest — a manager who knows an employee is "high risk" may treat them differently in performance reviews or project assignments. Aggregate outputs (team-level attrition risk) are safer than individual scores in many organizational cultures.

Use Case 2: Hiring Funnel Analysis

Business question: Where in our recruiting pipeline are we losing qualified candidates, and are we losing them disproportionately from underrepresented groups?

Data needed: ATS (Applicant Tracking System) data with stage, disposition reason, time in stage, recruiter, and hiring manager

Output format: Funnel conversion rates by stage and by demographic group (where legally permissible to collect), used by the Talent Acquisition leader to identify process bottlenecks

Use Case 3: Compensation Benchmarking

Business question: Are our salaries competitive with the market, and do we have unexplained pay gaps by gender or race/ethnicity?

Data needed: Internal comp data (role, level, salary, equity, bonus), external market data (Radford, Mercer, Levels.fyi)

Output format: Pay equity analysis showing % of employees above/at/below market rate, with unexplained pay gap analysis controlling for role, level, tenure, and performance

---

Cross-Industry Summary Table

Industry	Most Common Analytics Question	Primary Data Source	Typical Deliverable
Retail	Which customers are most valuable?	POS + CRM	Segmentation report + campaign targeting list
Healthcare	Which patients are highest risk?	EHR	Risk scores + care team alerts
Finance	Which loans will default?	Credit bureau + internal	PD score + monitoring dashboard
Marketing	Which channels drive revenue?	Event data + ad platforms	Attribution report + budget recommendation
HR	Which employees will leave?	HRIS + ATS	Attrition risk report + retention playbook

The portable skill

The analytical pattern — define the question, find the data, compute the metric, segment the result, recommend an action — is the same across every industry. Domain vocabulary changes. The workflow does not. Learn the pattern once; apply it everywhere.

---

Previous: 02-types-of-analytics | Next: 04-analytics-workflow