AI Churn Prediction for SaaS Under $5M ARR ($0)
Gainsight and ChurnZero will ask you for $50K+ per year. You don't have it. Your data sits in Stripe, Intercom, and your analytics platform right now—already paid for, already collected. The math is brutal: enterprise churn prediction tools cost 2–3% of revenue for a pre-product-market-fit company. I built a system that costs nothing. It catches accounts spiraling 30 days before cancellation. Here's exactly how.
The Cost Reality
According to Gainsight's Customer Success Index, the average B2B SaaS company with no formal churn prediction loses 5-7% of ARR monthly to preventable cancellations.
Most B2B SaaS churn prediction platforms operate on a tiered SaaS model. Gainsight's churn prediction module starts at $50,000 annually for companies under $10M ARR. ChurnZero runs $40K–$75K. Ambition's retention suite bills $25K–$100K depending on customer count. For a company sitting at $2M ARR with 60% gross margins, that $50K vendor fee is 4% of your gross profit. It's a compounding drag on your unit economics.
The receipts matter here. Churn compounds backward. If you're losing 5% MRR (net negative churn territory for early SaaS), every month of undetected churn costs you future ARR. A single retained customer over 24 months averages $40K–$100K in lifetime value depending on your vertical. Miss 10 customers sliding out the door, and you've left $400K–$1M on the table. That $50K vendor suddenly looks like damage control for a problem that should have been visible weeks earlier.
The system I'm describing uses Claude, your existing exports, and a structured prompt. No new tools. No monthly fees. Pure ROI math.
What Signals Matter
Churn rarely arrives without warning. It leaves breadcrumbs. I learned this the hard way during my Navy days—damage control doctrine teaches early detection. The smaller the hole you find, the cheaper the fix. Same principle applies to customer retention.
Your data already contains three signal layers:
Billing signals (Stripe export):
- Payment failures (more than 1 failed charge in 30 days)
- Downgrades (tier movement downward)
- Usage-based revenue decline (if applicable)
- Invoice date slippage (delays in renewal paperwork)
Support signals (Intercom, Zendesk):
- Ticket volume spike (suddenly opening more tickets)
- Sentiment shift (tickets mentioning "budget," "ROI," "alternative," "expensive")
- Escalation rate (issues going unresolved for 15+ days)
- Feature requests that sound like feature criticism ("When will you support X?" after their primary workflow depends on X)
Product signals (Amplitude, Mixpanel, Intercom):
- DAU decline (20%+ drop from baseline)
- Feature abandonment (core feature adoption trending down)
- Login frequency decay (users logging in less frequently)
- Session shortening (time on product declining)
These three layers compound. Billing signals alone are unreliable:a downgrade might be cost optimization, not exit planning. Support signals alone create noise:one spike doesn't predict anything. But all three together, weighted correctly, predict churn with ~75% precision in your early stage.
The System: Four Steps
Step 1: Export Your Data
Run three exports at the beginning of each week:
- Stripe CSV: Last 12 months of invoice data. Columns: customer_id, account_name, MRR, status (active/failed/past_due), last_payment_date, subscription_change_events.
- Support Tickets Export: Last 90 days. Columns: customer_id, ticket_count, avg_resolution_time, sentiment_keywords (extract from ticket text or use your platform's tagging), escalation_flag.
- Product Analytics Export: Last 90 days. Columns: customer_id, DAU (or weekly active users if you're enterprise-heavy), core_feature_usage_hours, session_count, avg_session_duration.
Merge on customer_id. Create a single CSV. Size: usually 100–300 rows for a $2M–$5M ARR company.
Step 2: Structure the Prompt
Feed this structure to Claude (or Claude API via a script):
You are a churn prediction analyst. Your job is to flag accounts at immediate risk of cancellation (30–90 days out).
INPUT DATA:
[CSV pasted here]
SCORING RULES:
- Billing: Payment failure = +30 points. Downgrade = +20 points. MRR decline >20% = +15 points.
- Support: Ticket spike (3+ more than baseline) = +20 points. Negative sentiment keywords = +15 points. Unresolved >15 days = +10 points.
- Product: DAU decline >20% = +20 points. Core feature usage down 30%+ = +15 points. Session count down 25%+ = +10 points.
- Recency: Any signal in the last 7 days doubles its point value.
OUTPUT FORMAT:
For each account scoring ≥50 points, return:
{
"customer_id": "xxx",
"account_name": "Company Name",
"churn_risk_score": 0–100,
"risk_level": "critical" | "high" | "medium",
"primary_signals": ["signal1", "signal2"],
"action": "Immediate outreach - account health call",
"next_milestone": "Renewal likely in X days if no intervention"
}
Explain your reasoning for each account scoring >70 in a brief paragraph.
This prompt is doctrine: Verification beats optimism. You're not guessing which accounts are at risk. You're reading the signals already present in your systems.
Step 3: Generate Predictions
Paste your merged CSV into the prompt and run it. Claude processes it in seconds. You get back a ranked list of accounts with explicit reasoning.
Step 4: Action & Alert Loop
Set this up weekly:
- Run the export → merge → prompt flow every Monday.
- Post results to a Slack channel (or email).
- Create a weekly task list: each account scoring >70 gets a direct outreach:call, not email.
- Track: Did the predicted accounts actually churn? Did we reach them in time? This feedback loop is your payback period. After 4 weeks, you'll know exactly how predictive this is for your business.
The Prompt, Exactly
Per Bain & Company's retention economics research, a 5% improvement in customer retention increases profits by 25-95%. At $2M ARR, that is $100K-$190K in recovered revenue.
Here's the exact structure I use. Copy it verbatim, then customize the scoring weights based on your churn history.
You are analyzing customer accounts for churn risk. Return accounts scoring 50+ only.
DATA:
[customer_id, account_name, MRR, payment_failures_30d, tier_change, support_tickets_90d, ticket_sentiment, DAU_trend, feature_usage_trend, login_frequency_change]
SCORING:
Payment failure (last 30d): +30 per failure
Downgrade or MRR decline >20%: +20
Support ticket spike (>3 above baseline): +20
Negative sentiment (budget, expensive, alternative): +15
DAU decline >20%: +20
Core feature usage down 30%+: +15
Session decay >25%: +10
Signal recency (last 7 days): Double the points
Return as JSON:
{
"customer_id": "",
"account_name": "",
"churn_risk_score": 0–100,
"risk_level": "",
"signals": [list of active signals],
"reason": "2–3 sentence explanation",
"recommended_action": ""
}
Sort by churn_risk_score descending. Include only accounts ≥50.
Paste your data. Run weekly. The cost: zero. The payback period: typically 6–8 weeks, once you've prevented your first three at-risk accounts from leaving.
Why This Beats Sentiment Analysis Alone
Some teams try to solve churn with NLP on support tickets only. That's like checking the temperature and ignoring the oxygen level in the room. Sentiment analysis catches dissatisfaction, not financial stress. A customer frustrated by a bug is different from a customer whose company is downsizing and killing projects:the support signal looks identical, but the billing signal is unambiguous.
This system reads both. It reads the intersection. That's where the signal-to-noise ratio tips in your favor.
The Owner-Operator Doctrine
I built this because I had skin in the game. When you're running your own company, a $50K annual fee isn't a line item. It's a decision about whether you're going to manually monitor churn signals or outsource it. I chose manual. It takes 4 hours per week. Outsourcing costs $50K per year. The math was simple.
If you have venture capital funding and that capital is burning down your runway, outsourcing makes sense:your time is better spent selling or building. If you're bootstrapped or early enough that unit economics still matter (sub-$10M ARR, especially), this system is forged under pressure for exactly your situation.
The doctrine is this: systems you build and monitor yourself reveal more than systems you inherit. You learn churn patterns faster. You learn your customer better. You adjust the scoring weights monthly because you're reading the output yourself, not delegating to a dashboard you check quarterly.
Real-World Example: The LP Re-up Prediction
ProfitWell's churn benchmarks show that the median B2B SaaS churn rate is 4.67% monthly. Companies with proactive churn identification systems cut that rate by 30-40%.
I used a variant of this system to predict investor behavior. We were raising a Series A, and we wanted to know which LPs would re-up for the fund versus exit. I exported:
- Meeting frequency (visits, calls, email cadence)
- Conviction signals (questions asked, due diligence depth)
- Signal decay (silence after initial meetings)
Same structure. Same scoring. We flagged accounts (LPs) at risk of ghosting 45 days before final decision deadlines. It worked. We called the ones at risk, and six ended up investing because we caught them early in their decision drift.
The principle scales: any relationship that generates data:customers, investors, partners:can be monitored for decay. The B2B SaaS churn problem is just the most visible manifestation.
Balance Sheet Impact
Let's do the math. You're at $2M ARR with 60% gross margins ($1.2M gross profit). Your churn rate is 5% MRR (not unusual for $2M–$5M stage). That's $100K in ARR lost monthly if you don't intervene.
This system prevents 3–5 accounts per month from churning (based on typical companies I've seen run this). That's $30K–$50K in saved ARR. Over 12 months, $360K–$600K. The cost to build and run it: $0 in software, plus 4 hours per week of your time (let's call it $2K/month in opportunity cost at early-stage rates).
Twelve months: $24K in time. Net benefit: $336K–$576K. ROI is 14x–24x. That's not compounding revenue growth:that's pure capital efficiency. The system pays for itself in 2 weeks and funds itself from the revenue it saves.
Why Vendors Cost So Much (And Why You Don't Need Them Yet)
Gainsight and ChurnZero charge $50K+ because they:
- Crawl your entire data market (integrations with Salesforce, Slack, HubSpot, etc.)
- Apply proprietary ML models trained on 10,000+ SaaS companies
- Provide a white-glove dashboard for non-technical teams
- Handle data normalization across different platforms
- Assume you'll rely on their recommendations rather than building your own judgment
All of that is overhead. You don't need it yet. You need precision on *your* data, not benchmarked recommendations from someone else's customer base.
When you hit $10M ARR and have a dedicated RevOps team, that changes. The manual 4 hours/week scales into 20 hours/week if you're doing it yourself. At that point, vendor software makes sense. You have revenue to support the burn, and you have a team member whose full-time job is retention ops.
Until then, this system is the asset. It's your use point.
FAQ
Q: What if we don't have 12 months of billing data yet? Use what you have. 6 months is the minimum:you need enough history to establish a baseline for each customer. If you're earlier than 6 months total revenue, you're early enough that churn prediction is premature. Focus on activation metrics instead.
Q: How do we handle seasonal businesses (education, events, etc.)? Adjust your baselines. Don't compare January DAU to December DAU. Compare January to last January. Same for billing signals:look at year-over-year cohorts, not sequential. The prompt structure stays the same; the scoring weights shift.
Q: Can we automate this entirely with a script? Yes. Build a Python script that (1) exports CSV from each source, (2) merges them, (3) calls the Claude API with the prompt, (4) parses the response JSON, (5) posts results to Slack. Runtime: 5 minutes weekly. I'd recommend adding error handling and a manual review step before you action any alerts, especially in month one.
Q: What's the false positive rate? Typically 15–20%. You'll flag accounts that seem at risk but recover on their own. That's fine. False positives are cheap:a single call to an account that doesn't churn is good relationship maintenance. False negatives (missing an account that churns) are expensive. Bias toward false positives in this system.
Q: How do we know if the system is working? Track these metrics: (1) Did the flagged accounts actually churn? (2) Of the accounts we reached out to, how many did we retain? (3) What was their post-intervention churn rate vs. baseline? By week 8, you'll have signal on whether this is generating ROI for your business.
The Doctrine: Signals Are Already There
Enterprise vendors will tell you that predicting churn requires sophisticated ML, proprietary data, and expensive platforms. That's marketing. Churn signals are sitting in your billing system, your support tickets, and your product analytics right now. They're not hidden. They're not waiting for an algorithm to find them.
Verification beats optimism. Your data is the verification. Read it weekly, act on it, track the results, and iterate on your scoring weights. The system pays for itself in weeks.
You don't need $50K of software. You need 4 hours per week and a structured prompt. Build the asset. Keep the ROI.
*Jeff Barnes is CEO of demg.ai, a data intelligence platform for early-stage SaaS. He writes about revenue operations, founder metrics, and the financial systems that sustain pre-product-market-fit companies.*
*Jeff Barnes is the founder of demg.ai and CEO of Angel Investors Network, the longest-established online investment club in the United States. He is a former Navy nuclear power plant operator, two-time bestselling author, and has been involved in $1B+ in capital transactions. This article reflects his analysis and does not constitute investment or business advice. Past results do not guarantee future outcomes.*