Build a Customer Health Score Workflow in n8n

A customer success team can't watch every account. So they watch the loud ones, the ones already complaining, and miss the quiet account that just stopped logging in. A customer health score fixes that by turning scattered signals into one number you can sort and alert on. An n8n customer health score workflow computes it on a schedule and pings Slack the moment an account crosses into risk.

Most churn templates predict churn with a black-box AI call against Zendesk or HubSpot. They tell you an account is at risk; they don't show you the formula or let you tune it. This builds the transparent version: a weighted score you control, on a Google Sheets stack, with the escalation rule spelled out.

It's distinct from a winback campaign. This catches the account before it churns, while there's still something to do.

What you can automate with a health score

A scoring workflow drives most of the proactive side of customer success:

• A nightly score for every active account, written back to a sheet
• Threshold alerts: anything below a cutoff escalates to Slack
• A trend flag when a score drops sharply week-over-week
• Auto-assignment of at-risk accounts to a success manager
• A personalized check-in email for mid-risk accounts
• A weekly digest of the bottom accounts for the team standup

The score itself is the product. Everything downstream is just routing on a number.

Why a weighted formula beats a black-box prediction

The library templates predict churn with an LLM looking at Zendesk and HubSpot data. That's fine for a vibe, but a success manager can't act on "the model says 73% risk." They can act on "usage dropped 40% and the last two tickets were negative." A weighted health score keeps the signals visible.

Here's the take: for customer health, transparency beats accuracy. A slightly cruder score that a human understands drives more saves than a precise one nobody trusts. When the success manager can see which signal tanked, they know what to say on the call. A probability gives them nothing to open with. Build the formula explicit, in a Code node, where you can read and tune the weights.

The formula is a normalized weighted sum:

score = 0.4 * usage_trend
      + 0.35 * sentiment
      + 0.25 * recency

Each input is scaled to 0–100 first. The weights say usage trend matters most, sentiment next, recency last. Tune them to your product. That's the whole model, and you can read it.

The customer health score pipeline

Schedule Trigger (nightly)
  → Read account events (Google Sheets)
  → Code: normalize each signal to 0-100
  → Code: weighted sum → score
  → Write score back to the sheet
  → Switch: score < threshold? → Slack escalation

No warehouse, no ML service. A Schedule Trigger, two Code nodes, and a Switch. The scoring lives in code you can read and change.

1. Collect the signals

The Schedule Trigger fires nightly and reads an account events sheet: last login date, recent ticket sentiment, this week's usage count, last week's usage count, plan value. If your signals live across tools, a couple of read nodes (HubSpot for deals, a support export for sentiment) feed into a Merge before scoring. Keep the read step boring and the scoring step smart.

2. Normalize each input

A Code node scales every raw signal to 0–100 so the weights mean something. Usage trend becomes a ratio of this week to last; sentiment maps a -1..1 score to 0..100; recency maps days-since-login onto a decay.

// Code node: normalize signals
return items.map(({ json }) => {
  const trend = Math.min(100, (Number(json.usage_now) /
    Math.max(1, Number(json.usage_prev))) * 50);
  const sentiment = (Number(json.sentiment) + 1) * 50; // -1..1 -> 0..100
  const days = Number(json.days_since_login || 0);
  const recency = Math.max(0, 100 - days * 5);
  return { json: { ...json, trend, sentiment, recency } };
});

3. Score it

A second Code node applies the weights and writes a single score. Keep the weights as named constants at the top so tuning is a one-line edit, not a hunt through math.

const W = { trend: 0.4, sentiment: 0.35, recency: 0.25 };
return items.map(({ json }) => ({
  json: { ...json,
    score: Math.round(W.trend * json.trend +
      W.sentiment * json.sentiment + W.recency * json.recency) }
}));

4. Write back and escalate

The score writes back to the account row. A Switch checks it against your threshold (start around 50). Anything below escalates: a Slack message to the success channel naming the account, the score, and above all the weakest signal, so the manager knows whether it's a usage problem or a sentiment problem before they reach out.

5. Route by tier

Optionally, branch the mid-band into an automated check-in email and reserve Slack for the critical accounts. The Stalled Lead Rescue template handles that warm re-engagement step, detecting quiet contacts and firing a personalized AI email, which slots right onto the mid-risk tier here.

Implementation patterns

Pattern 1: transparent weighted scoring. Named weights, normalized inputs, a single Code node. Readable and tunable.

normalize(signals) → weighted_sum(W) → score

Pattern 2: threshold-with-context escalation. Branch on the score, but carry the weakest signal into the alert so it's actionable.

Switch(score < 50) → Slack(account, score, weakest_signal)

Pattern 3: trend escalation. Compare this run's score to the stored previous one; a sharp drop escalates even if the absolute score is still mid-band. Catches the fast decliners early.

n8n nodes you'll use most

Getting started

1. Build an accounts sheet: account, usage_now, usage_prev, sentiment, days_since_login, plan_value, score.
2. Add a Schedule Trigger on a nightly Cron.
3. Read the sheet and add the normalization Code node.
4. Add the scoring Code node with named weights you can tune.
5. Write the score back to each row.
6. Add a Switch on the threshold and a Slack alert that names the weakest signal.
7. Run it for a week and tune the weights against accounts you know are healthy or at risk.

A health score tells you who's slipping; the winback work is what saves them. For the campaign side once an account does churn, see the n8n SaaS churn-prevention build, and for the broader retention picture there's churn prevention automation in n8n. Build the formula transparent, alert on the weakest signal, and the team acts on numbers they actually trust.