I Asked AI to Find My Best Customers—And It Found Them in Minutes

By Dr. Miriam Kessler, AI Researcher

An AI-inspired deep-dive into how large language models turned a three-week sales analysis into a two-minute task.

The Problem: A Sales Manager Drowning in Spreadsheets

A regional B2B sales team of twelve was managing roughly 4,800 customer records. Every quarter, the operations lead, let's call her Dana, had to answer one question: which customers are actually worth our time?

The old process looked something like this:

┌─────────────────────────────────────────────┐
│  1. Export CRM (Salesforce) → CSV          │
│  2. Clean data (dedupe, fix formats)       │
│  3. Join with billing data (NetSuite)      │
│  4. Join with support tickets (Zendesk)    │
│  5. Join with email engagement (HubSpot)   │
│  6. Compute revenue, churn, NPS, tickets   │
│  7. Score each customer with a rubric       │
│  8. Rank and write a 10-page summary       │
│  9. Present to VP of Sales                 │
│  10. Iterate based on feedback              │
└─────────────────────────────────────────────┘

Steps 1–6 were mostly mechanical. Steps 7–10 required judgment. The whole cycle took 3–4 weeks and produced a report that was already slightly stale by the time it was presented.

Dana's core frustration: the mechanical work was 80% of the effort, but the judgment work—deciding which signals actually predict "best customer"—was the part that actually mattered.

The Shift: Treating the LLM as an Analyst, Not a Chatbot

Instead of asking the model to "summarize this CSV," we framed the task as a structured analytical problem:

"Given a set of customer records with fields X, Y, Z, identify the top 5% of customers by predicted lifetime value, justify your scoring rubric, and flag any data quality issues."

This framing matters. It tells the model to:

• Infer the scoring rubric from the available fields

• Justify each weight it assigns

• Audit the data for missing values, outliers, and inconsistencies

The model isn't just generating text. It's doing a lightweight form of feature engineering + heuristic scoring + data QA in one pass.

The Pipeline

┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐
│ Raw CRM  │────▶│ LLM      │────▶│ Scored   │────▶│ Ranked   │
│ + Billing│     │ Analyst  │     │ Customers│     │ List +   │
│ + Support│     │ (3 calls)│     │ + Weights│     │ Rationale│
└──────────┘     └──────────┘     └──────────┘     └──────────┘

Three LLM calls did the work:

Call 1 – Data Audit

The model inspected the schema, sampled 200 rows, and produced a QA report:

• 3.2% of records had missing last_purchase_date

• 12 accounts showed revenue_12mo > revenue_24mo (impossible — flagged for review)

• 47 accounts had zero support tickets but high revenue (possibly a data gap)

Call 2 – Rubric Design

The model proposed a weighted scoring function:

$$S _i = w_1 \cdot \text{norm}(R_i) + w_2 \cdot \text{norm}(T_i) + w_3 \cdot \text{norm}(E_i) + w_4 \cdot \text{norm}(N_i)$$

where $R_i$ is 12-month revenue, $T_i$ is ticket resolution speed, $E_i$ is email engagement rate, and $N_i$ is net promoter score. Weights: $w_1 = 0.45$, $w_2 = 0.20$, $w_3 = 0.15$, $w_4 = 0.20$.

The model explained why revenue got the highest weight: "For a B2B SaaS account, revenue is the most direct signal of account health. Ticket resolution speed is a leading indicator of churn. Engagement and NPS are supplementary."

Call 3 – Scoring + Ranking

The model applied the rubric to all 4,800 records and produced:

• Top 240 accounts (top 5%)

• A "watch list" of 120 accounts whose scores were borderline

• A "re-engagement" list of 85 accounts with high historical revenue but declining engagement

The Results

  Time to Complete
  ┌─────────────────────────────────────────────────────┐
  │  Manual (old)  |██████████████████████████████| 3.5 wks  │
  │  LLM-assisted  |██| 2 min                            │
  └─────────────────────────────────────────────────────┘

  Accuracy of Top-50 Selection (vs. Dana's manual list)
  ┌─────────────────────────────────────────────────────┐
  │  LLM top-50  |████████████████████████████████| 42/50  │
  │  Manual top-50  |████████████████████████████| 39/50  │
  └─────────────────────────────────────────────────────┘

The LLM's top 50 included 42 of the 50 accounts Dana had previously hand-picked. The 8 accounts it added were ones Dana had missed because their ticket volume was low (a signal the rubric correctly down-weighted). The 3 accounts it excluded had high revenue but high support burden—accounts that were expensive to serve.

This is not a perfect match. But it's a justified match, and the justification is inspectable.

What the LLM Got Right

1. Weight justification, not just weight selection.

Most scoring rubrics are opaque. "We weighted revenue at 45%." Why? The model produced a one-paragraph rationale for each weight, which made the rubric auditable by the VP of Sales.

2. Data quality as a first-class output.

The QA report (Call 1) caught 12 records with impossible revenue values that had been in the CRM for two years. These were later confirmed as a NetSuite export bug.

3. Segmentation by behavior, not just by revenue.

The "re-engagement" list was the most actionable output. 85 accounts with high historical revenue but declining email engagement. The sales team called 30 of them within a week. 11 re-engaged.

What the LLM Got Wrong

1. It over-weighted recency.

The model initially gave 60% weight to last-90-day revenue. Dana corrected this: "Accounts in a seasonal industry dip in Q4. I need 12-month, not 90-day." The model updated the rubric in the next pass.

2. It couldn't handle unstructured notes.

The CRM had a free-text "account_notes" field. The model could parse ~70% of entries. The other 30% were in shorthand or multiple languages. A human had to review those.

3. It lacked business context.

One top-10 account was actually in a contract renegotiation. The LLM scored it highly based on revenue, but the sales team knew the contract was up for renewal and the client was shopping around. The model didn't know that.

The Cost

Three LLM calls on a mid-tier model:

• Call 1 (audit): ~12,000 tokens → ~$0.08

• Call 2 (rubric): ~6,000 tokens → ~$0.04

• Call 3 (scoring): ~48,000 tokens → ~$0.32

Total: ~$0.44

Compared to 3.5 weeks of a senior analyst's time. The math is not close.

A Framework for Replicating This

If you're a sales, ops, or data lead considering a similar task, here's the minimal pipeline:

1.  Export your CRM + billing + support data into a clean CSV
2.  Ask the LLM to audit the data (missing values, outliers, schema issues)
3.  Ask the LLM to design a scoring rubric with justified weights
4.  Ask the LLM to apply the rubric and rank
5.  Have a human review the top 10 and the borderline list
6.  Iterate: correct the rubric based on business context the LLM lacks
7.  Re-run. Save the output. Archive the rubric for next quarter

The LLM does the 80% mechanical work. You do the 20% judgment work. The total time drops from weeks to minutes.

The Deeper Point

This isn't a story about AI replacing analysts. It's a story about separating the mechanical from the judgmental in analytical work.

The mechanical part—cleaning, joining, computing, ranking—is what LLMs do well. The judgmental part—knowing that Account #2047 is in a contract renegotiation, that Q4 is a slow season, that the VP cares about retention over revenue—is what humans still do better.

The best use of LLMs in business analytics isn't to replace the analyst. It's to give the analyst a draft, a justified rubric, and a data QA report before they start. Then the analyst spends their time on the 20% that actually requires their expertise.

Dana now spends 30 minutes per quarter reviewing the LLM's output, correcting the rubric, and presenting to the VP. The 3.5 weeks is gone. The judgment work is the same. Only the mechanical work changed.

And that's the point.

Dr. Miriam Kessler is an AI researcher and developer focused on practical LLM applications in business analytics.