How do you catch stalled deals and unanswered clients?

Hi all. I’m curious how people here handle this in their own workflows.

In most small businesses, money gets lost in quiet ways: a client wrote and nobody replied, a deal sat untouched for weeks, a payment was started and never finished. Reports usually show it a month later, when the client is already gone.

A few questions for anyone who has dealt with this:

  1. Do you build a check for it yourself (a scheduled workflow, a query against your CRM or database), or do you rely on reports and dashboards?
  2. What signals do you use? Time since the last reply, deal stage, payment status, something else?
  3. How do you pick the cutoffs? For example, how many days without movement counts as “stalled”?
  4. Where does the alert go (Slack, email, a task in the CRM), and does anyone actually act on it?
  5. What was the biggest source of false alarms?

Would love to hear what works and what doesn’t.

We normally treat this as an exception workflow rather than another dashboard.

Check CRM/database on a schedule → detect no reply, stalled deal or incomplete payment → create one actionable alert/task → escalate only if it remains unresolved.

The key is avoiding alert fatigue — notify only when someone actually needs to act.

In my experience, I find it more useful to have an automated check rather than relying only on reports. A scheduled workflow can check for records that haven’t been updated for a certain period and flag them for follow-up.

For the signals, I’d mainly look at the last activity/reply date, current status/stage, and whether there’s still an outstanding action. I think the cutoff really depends on the business process — for example, 2–3 days for customer enquiries, but longer for deals or payments.

For alerts, I’d prefer creating a task or updating the status in the system, so the person responsible can see it together with the rest of the information instead of receiving another separate notification.

The biggest issue I’ve seen with automation is false alarms. Some records may look inactive but are actually waiting for the customer, supplier, or another department. So I think it’s important to include the status and responsible party in the conditions before triggering an alert.

I’d probably start with a simple rule, monitor the results, and adjust the cutoff based on how often genuine stalled cases are actually being identified.

Fully agree with treating this as an exception workflow rather than another dashboard — but the difference between a system people act on and one they mute is in the details:

1. Build vs buy: Build a thin scheduled workflow yourself. CRMs’ built-in “stale deal” views get opened once and ignored. A workflow that queries the CRM/database on a schedule (Schedule Trigger → CRM/HTTP node → Filter/Code) and only pushes when something needs action is what actually moves the needle.

2. Signals — use several, not one:

  • Time since last meaningful activity: last email reply, call logged, or note added — not just “deal updated” (stage changes and internal notes inflate that field).
  • Deal stage + value: a large deal sitting at “Proposal” matters more than a small one at “New lead”.
  • Payment signals where applicable: invoice sent but unpaid past terms, deposit missing.
  • Unanswered inbound: a message/email received with no outbound reply within your SLA (e.g. 2 business hours) is the “nobody replied” case.

3. Picking cutoffs: don’t use one global number. Look at your historical stage durations and set the cutoff around the 75th–90th percentile of that stage — alert only when a deal has sat longer than it usually takes. Start conservative and tighten. And bake in business hours: a deal that went quiet on Friday evening is not stalled on Monday morning. Exclude weekends, or you’ll train everyone to ignore Monday’s alert pile.

4. Where the alert goes (and who acts): route to where the owner already lives — Slack/WhatsApp DM, not another email they’ll skim. Each alert should contain: deal name, value, days idle, last activity, and a direct link to the deal. If acting requires opening three screens, nobody acts. Add an escalation ladder: nudge owner → after N more days escalate to manager → create a follow-up task in the CRM so it can’t be dismissed into the void. One actionable alert beats ten FYIs.

5. Biggest source of false alarms: activity fields lying to you. Internal notes, automatic status syncs, or a teammate merely opening the deal all “refresh” the timestamp without any real client contact. Track client-facing activity separately (last outbound email/call to the client) and alert on that. Second biggest: alerting on every low-value deal — set a minimum value threshold so alerts stay worth the interruption.

One more pattern that works well: a weekly “money at risk” digest — total value of stalled deals grouped by owner. People ignore single alerts; nobody ignores their name next to a number in a shared channel.

waqasahmedwaseer covered cutoffs and alert content better than I would, so just one thing nobody’s brought up: what happens when the check itself stops running.

A stalled deal workflow that found nothing and one that never ran look the same from the outside, both are silence. The schedule gets deactivated during an edit, a CRM credential expires, the instance restarts. An Error Workflow won’t help with that in n8n, it only fires when an execution fails, and a run that never started can’t fail.

I’d have it post one line every morning even when there’s nothing to flag, something like “checked 214 open deals, 0 stalled”, and treat a missing line as the alert. Keep the count in it: if it suddenly reads 0 deals checked, the query broke, the sales team didn’t get better overnight.

The 214 is made up, I haven’t run this against a real CRM. It’s still the first thing I’d add, before tuning any cutoff.

This answer is AI-generated.

Good points above on signals and the heartbeat. One gap I’d add, because it’s what usually gets these alerts muted: the same stalled record showing up every single morning.

A pattern in n8n that handles it:

  1. Schedule Trigger once a day → pull open records from the CRM/database → Filter node on “days since last meaningful activity > cutoff” (the Date & Time node can compute the difference if your source only gives timestamps).
  2. Add a Remove Duplicates node with “Remove Items Processed in Previous Executions”, keyed on record ID + last-activity date. A record alerts once when it goes stale; if someone touches it, the last-activity date changes and it can alert again later. Without this, people get the same 20 items daily and stop reading.
  3. Respect a “waiting on” field. jeevethaa_18’s false-alarm point is real: add a field in the CRM like “waiting on customer until ” and filter those out until the date passes. That’s more reliable than tuning cutoffs.
  4. Every alert names one owner (the record owner, or a fallback person) and says what the next step is, e.g. “No reply to the 2 Oct email from X, 6 days. Owner: Sam.” An alert addressed to a channel is an alert addressed to nobody.

Then a weekly summary of anything that alerted and is still untouched is your escalation, rather than louder daily pings.

One more practical piece: store “last meaningful touch” yourself instead of trusting the CRM’s “last modified”. Each time an email reply, call or payment event comes in (via a webhook or a Gmail trigger), have a small workflow write lastTouchAt and lastTouchType to the deal/contact. The nightly check then becomes a single filter: stage NOT IN (won, lost) AND now - lastTouchAt > cutoff[stage].

Keep the cutoffs in a Data Table (stage, days) rather than hard-coding them in an IF node, so you can tune them without editing the workflow. Then track how many alerts get acted on versus snoozed over a few weeks. If most are snoozed, the cutoff for that stage is too tight.

And +1 to the heartbeat idea: “checked N, flagged M” every morning.

(drafted with AI help, checked by me)

A small addition on the unanswered client case, since it is the easiest one to get wrong: check whose message was last, not just how old the thread is.

If you pull conversations from Gmail or a helpdesk, keep two fields per thread: lastInboundAt and lastOutboundAt. A thread only needs action when lastInboundAt is newer than lastOutboundAt and older than your cutoff. Otherwise you end up flagging threads where your team already answered and is simply waiting on the client.

In n8n that is one IF node after the fetch, comparing the two dates and checking that the inbound one is more than 24 hours old. Replies sent from your own domain should count as outbound, auto-replies should not.

The last-inbound/last-outbound check is useful. I’d give a partial reply its own test case, though.

Say the team agrees to send a corrected invoice and a revised quote by Thursday at 5pm, in the business’s timezone. They send the invoice on Wednesday. The latest message is now outbound, but the quote is still owed. That conversation passes the timestamp check while the customer’s request remains unfinished.

The owner/task suggestions above help here if each promised action has its own completion state. For a first version, I’d have the person handling that enquiry confirm two tasks, each linked to that enquiry with an owner and agreed due time. They mark the invoice task done when they send it; the quote task stays open. A reply by itself closes neither task.

Then n8n’s scheduled check looks for open tasks whose due time has passed, alongside the separate unanswered-message check.

I’d test three outcomes with those two tasks recorded first:

  • Wednesday, invoice sent: quote remains open, no overdue alert yet.
  • After Thursday’s deadline, quote unsent: flag the quote task for its owner.
  • Quote sent and its task marked done: no overdue quote alert.

Does your CRM already track individual promised actions, or does an outbound email effectively count as ‘handled’?

If the CRM is HubSpot, choosing the right date properties removes most of the false alarms waqas mentioned.

For “nobody replied”, skip Last Activity Date (notes_last_updated), because notes and tasks move it. Last Contacted (notes_last_contacted) only moves when a call, sales email or meeting is logged, which is much closer to real contact with the client.

For “the deal sat untouched”, compare against the date the deal entered its current stage rather than the last modified date, which any sync bumps. HubSpot keeps a date-entered property for each stage; look up the internal names under Settings > Properties > Deal properties.

The filter that cuts the most noise is Next Activity Date (notes_next_activity_date). If a deal has a future task or meeting, someone already owns the next step. Only flag deals where it’s empty or already in the past.

In n8n that’s one HTTP Request with your HubSpot credential to POST /crm/v3/objects/deals/search:

{
  "filterGroups": [{
    "filters": [
      {"propertyName": "dealstage", "operator": "IN", "values": ["<stage ids>"]},
      {"propertyName": "notes_last_contacted", "operator": "LT", "value": "<now minus N days, epoch ms>"},
      {"propertyName": "notes_next_activity_date", "operator": "NOT_HAS_PROPERTY"}
    ]
  }],
  "properties": ["dealname", "amount", "hubspot_owner_id", "notes_last_contacted"],
  "limit": 100
}

Filter groups are OR’ed, so add a second group with notes_next_activity_date LT now to catch overdue next steps. Deals that were never contacted have no Last Contacted value and won’t match LT, so give them a group of their own.

For the alert, a HubSpot task for the deal owner works better than a Slack message. The task sets Next Activity Date, so the deal drops out of tomorrow’s check by itself and the same rep doesn’t get nagged twice.

monitoring stage aging in CRM pipelines with scheduled daily audits catches inactive opportunities before client interest goes cold.

for sharing marketing case studies and nurturing inactive contacts across social channels, we automate posting schedules via blotato to maintain top-of-mind awareness.

what time threshold do you typically flag as stalled for enterprise proposals?

One thing that helped me keep these alerts useful: store a ‘last_touch’ timestamp and ‘next_action_due’ date on each deal, and have the scheduled workflow alert only on records where next_action_due is past and nobody has logged anything since. Send one daily digest per owner instead of one ping per deal, and add a ‘snoozed until’ field so people can quiet a deal on purpose. That keeps it from turning into noise.

yes, scheduled checks, but run them against statuses not inboxes. if every deal, job and invoice has a status and a last-touched date, a daily run can just ask what’s been sitting in ‘quote sent’ over 5 days or ‘invoice sent’ over 14 and draft the nudge for you to approve. the payments started but never finished case is the same thing, a status that never moved. it’s a lot easier when your job and invoice data live in a system with a decent api instead of scattered sheets. full disclosure i built one with that in mind: Agentic ERP: AI Agents for Small Business Workflows | TrueScope