How Sales Executives Can Enter Data Science in 2026

# sales_pipeline_analysis.py — a real analysis a sales exec turned analyst does
# This is the kind of project that directly uses your existing domain knowledge.

import pandas as pd
import numpy as np

# 1. Load the CRM export (a normal weekly export from any sales tool)
deals = pd.read_csv("crm_deals.csv", parse_dates=["created_at", "closed_at"])

# 2. Clean
deals = deals.dropna(subset=["deal_id", "amount", "stage"])
deals["amount"] = pd.to_numeric(deals["amount"], errors="coerce")
deals = deals[deals["amount"] >= 0]

# 3. Compute the standard sales metrics — the ones you already track
total_deals = len(deals)
won_deals = deals[deals["stage"] == "Won"]
win_rate = len(won_deals) / total_deals * 100

# 4. Average deal size and sales cycle
avg_deal = won_deals["amount"].mean()
avg_cycle_days = (won_deals["closed_at"] - won_deals["created_at"]).dt.days.mean()

# 5. Which lead source produces the best pipeline?
by_source = (
    deals.groupby("lead_source")
      .agg(
          total_deals=("deal_id", "count"),
          won=("stage", lambda s: (s == "Won").sum()),
          revenue=("amount", lambda a: a[deals.loc[a.index, "stage"] == "Won"].sum()),
      )
      .assign(win_rate=lambda d: (d["won"] / d["total_deals"] * 100).round(1))
      .sort_values("revenue", ascending=False)
)

# 6. Which reps convert best — normalised for deal count
by_rep = (
    deals.groupby("owner")
      .agg(total=("deal_id", "count"), won=("stage", lambda s: (s == "Won").sum()))
      .assign(win_rate=lambda d: (d["won"] / d["total"] * 100).round(1))
      .query("total >= 10")
      .sort_values("win_rate", ascending=False)
)

print(f"Overall win rate: {win_rate:.1f}%")
print(f"Average deal size: ₹{avg_deal:,.0f}")
print(f"Average sales cycle: {avg_cycle_days:.1f} days")
print("\nTop lead sources by revenue:")
print(by_source.head())
print("\nTop reps by win rate:")
print(by_rep.head())

# What makes this a great first portfolio project for a sales exec:
# - You already know what these metrics mean — no explanation needed.
# - The analysis asks the same questions sales leaders ask weekly.
# - You can write a memo that sales leadership will actually read.
# - It shows a hiring manager you can translate domain knowledge into
#   reproducible analysis.
#
# What you will learn by building it:
# - pandas groupby, apply, and lambda (the core of any analysis)
# - Data cleaning and validation (the unglamorous 60% of real work)
# - How to write business outputs, not just code

# churn_model.py — a small ML project that predicts customer churn
# Every entry-level data science interview tests something like this.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, roc_auc_score

# 1. Load customer data (the kind of data you already look at)
df = pd.read_csv("customers.csv")
df = df.dropna()

# 2. Separate target from features
y = df["churned"].astype(int)
X = df.drop(columns=["churned", "customer_id"])

# 3. Identify column types for preprocessing
cat_cols = X.select_dtypes(include="object").columns.tolist()
num_cols = X.select_dtypes(exclude="object").columns.tolist()

preprocess = ColumnTransformer(
    transformers=[
        ("num", StandardScaler(), num_cols),
        ("cat", OneHotEncoder(handle_unknown="ignore"), cat_cols),
    ]
)

# 4. Split — always stratify for imbalanced churn data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

# 5. Baseline: logistic regression
lr = Pipeline([
    ("pre", preprocess),
    ("clf", LogisticRegression(max_iter=1000)),
])
lr.fit(X_train, y_train)

# 6. Stronger model: random forest
rf = Pipeline([
    ("pre", preprocess),
    ("clf", RandomForestClassifier(n_estimators=200, random_state=42)),
])
rf.fit(X_train, y_train)

# 7. Compare — on AUC, not just accuracy
for name, model in [("Logistic Regression", lr), ("Random Forest", rf)]:
    proba = model.predict_proba(X_test)[:, 1]
    auc = roc_auc_score(y_test, proba)
    print(f"{name}: AUC = {auc:.3f}")

# 8. Explain the strongest model in business terms
best_model = rf
feature_importance = best_model.named_steps["clf"].feature_importances_
feature_names = (
    num_cols
    + list(best_model.named_steps["pre"]
           .named_transformers_["cat"]
           .get_feature_names_out(cat_cols))
)
importance_df = (
    pd.DataFrame({"feature": feature_names, "importance": feature_importance})
      .sort_values("importance", ascending=False)
      .head(10)
)
print("\nTop churn drivers:")
print(importance_df.to_string(index=False))

# Why this is interview-ready:
# - Proper train-test split with stratification
# - Compares a baseline against a stronger model
# - Reports AUC (correct for imbalanced data), not just accuracy
# - Explains feature importance in business terms
# - Uses a pipeline so it would work in production
#
# What interviewers look for from a sales-turned-DS candidate:
# - Do you understand what "churn" means for THIS business?
# - Can you interpret feature importance in business terms?
# - Do you know why accuracy is misleading for imbalanced data?
# - Would a sales team actually use this output?

# dashboard_app.py — a Streamlit dashboard that drives a sales decision
# Deployment is the difference between a portfolio project and a homework.

import streamlit as st
import pandas as pd
import plotly.express as px

st.set_page_config(page_title="Sales Pipeline Dashboard", layout="wide")
st.title("Sales Pipeline — Weekly Snapshot")

# 1. Load data (in production this would be a live query)
deals = pd.read_csv("crm_deals.csv", parse_dates=["created_at", "closed_at"])

# 2. Sidebar filters — this is what makes dashboards usable
stage_filter = st.sidebar.multiselect(
    "Filter by stage",
    options=deals["stage"].unique(),
    default=deals["stage"].unique().tolist(),
)
deals = deals[deals["stage"].isin(stage_filter)]

# 3. Top KPIs — the numbers a sales leader wants in 5 seconds
total_revenue = deals.loc[deals["stage"] == "Won", "amount"].sum()
win_rate = (deals["stage"] == "Won").mean() * 100
avg_deal = deals.loc[deals["stage"] == "Won", "amount"].mean()

col1, col2, col3 = st.columns(3)
col1.metric("Total won revenue", f"₹{total_revenue:,.0f}")
col2.metric("Win rate", f"{win_rate:.1f}%")
col3.metric("Average deal size", f"₹{avg_deal:,.0f}")

# 4. Pipeline by stage — the funnel view
stage_agg = (
    deals.groupby("stage")
      .agg(deals=("deal_id", "count"), value=("amount", "sum"))
      .reset_index()
)
fig_stage = px.funnel(stage_agg, x="deals", y="stage", title="Deal count by stage")
st.plotly_chart(fig_stage, use_container_width=True)

# 5. Win rate by lead source — the diagnostic view
source_agg = (
    deals.groupby("lead_source")
      .agg(
          total=("deal_id", "count"),
          won=("stage", lambda s: (s == "Won").sum()),
      )
      .assign(win_rate=lambda d: (d["won"] / d["total"] * 100).round(1))
      .reset_index()
      .sort_values("win_rate", ascending=False)
)
fig_source = px.bar(
    source_agg, x="lead_source", y="win_rate",
    title="Win rate by lead source",
)
st.plotly_chart(fig_source, use_container_width=True)

# 6. Written summary — the part that actually gets read
top_source = source_agg.iloc[0]
st.markdown(
    f"### What this means\n"
    f"- {top_source['lead_source']} has the highest win rate "
    f"({top_source['win_rate']}%) — consider reallocating budget.\n"
    f"- Overall win rate is {win_rate:.1f}% — {'above' if win_rate > 30 else 'below'} the industry benchmark.\n"
    f"- Average deal size is ₹{avg_deal:,.0f} — worth monitoring over time."
)

# Why this dashboard stands out:
# - It answers a specific question for a specific person (sales leadership).
# - KPIs are at the top — they can be read in 5 seconds.
# - Funnel and diagnostic views match how sales teams already think.
# - Written summary is what turns a chart into a decision.
# - Streamlit deploys free in 2 minutes, so it lives online.
#
# For sales executives specifically:
# - You already know which charts a sales leader will trust.
# - You know which metrics they will argue about (and why).
# - That is exactly the advantage you bring to a data role.