Forem: Riya Sharma

Add Churn Prevention to Your SaaS App in 10 Minutes with npm

Riya Sharma — Fri, 08 May 2026 18:28:26 +0000

Okay so I'll be upfront — churn was genuinely the last thing I was thinking about when I was in the middle of building.

Like I was in it. Head down, tunnel vision, the whole thing. Fixing bugs at 1am that honestly maybe two people would ever notice. Shipping features I thought were cool. Refreshing Twitter like that was somehow part of my job. Retention felt so far away. It felt like a problem that belonged to a future version of me — the one who had users, real traction, some kind of momentum. Not right now me.

And then one week I lost four paying users. In three days.

No email. No complaint. Not even an angry reply to one of my newsletters. They just — stopped. Logged in less, then not at all, then at some point clicked cancel and were gone. I sat there staring at the numbers genuinely not knowing what happened. Did something break? Did I raise the price wrong? Did someone launch a competitor I hadn't heard of yet? I had nothing. No idea whatsoever.

The silence was the worst part. Not the churn itself — the fact that I had zero signal about why.

So I finally — finally — sat down and actually thought about this. And what I realized was kind of embarrassing honestly. All that energy going into getting people to sign up, and I had zero. Like literally nothing set up to figure out why they were quietly disappearing.

The Thing Nobody Talks About (but Should)

Here's the thing about churn that took me embarrassingly long to figure out — it's not a moment. Here's the thing nobody told me — churn isn't really a moment. Like yeah, there's a cancel button and someone clicks it. But that's not when you lost them. That's just when the paperwork catches up.
It's more like... they just slowly stop showing up. It starts days before the cancel — sometimes weeks before. Logins get less frequent. The feature they used every single day, they just quietly stop opening it. Sessions get shorter. The person is already mentally somewhere else, and you have no idea because you're still sending them emails they stopped opening three weeks ago.

By the time they actually cancel — honestly, you've already lost them. Like way earlier. That cancel button is just the moment you finally find out.

That realization kind of wrecked me a little. Because it meant all the "retention" stuff I thought I was doing — the occasional check-in email, the feature announcement — was already too late. I was reaching out to people who had already moved on. Long gone.

And then there's the other thing. Even when people did cancel, I had no clue why. I had one of those dropdown menus on my cancel page. You know exactly which ones I mean because you've seen them everywhere.

Too expensive
Not using it enough
Missing features
Found a better alternative
Other

I looked at my cancellation data one afternoon and it was basically just split between "not using it enough" and "other." Okay. Great. What am I supposed to do with that? "Not using it enough" — but why weren't you using it? Was onboarding confusing? Did you not get what the product was actually for? DOr did something just come up and they forgot the tab was even open? I mean those are completely different situations. One's a product problem, one's a messaging problem, one's just life. I can't do anything with "not using it enough" as a reason. But if onboarding was confusing? That I can fix today. I just needed someone to actually tell me that.
And "other." I mean. Come on.

The people leaving knew exactly why they were leaving. They just had no good way to actually tell me. And I'd given them a dropdown that made it way easier to just pick anything and be done with it.

What I Actually Needed

Once I figured out what was actually going on, what I needed wasn't that complicated.

I needed to catch drift before it became a cancel. Something that would flag a user and basically say — hey, this one's slipping, talk to them now. Not a spreadsheet full of numbers I'd have to sit down and interpret every week. Just a label. "Drifting. Do something today."

And I needed real words from people at the moment they were leaving. Not a dropdown. Not stars out of five. Just — let them type what's going on. In whatever language they actually use. Because that's the stuff you can do something with.

I went back and forth on building it myself. The drift scoring logic isn't some crazy algorithm — you're basically just looking at when they last logged in, whether they hit the core features, whether usage is trending up or down. Combine those somehow, generate a score, put a label on it. I could probably hack together a first version over a weekend.

But then. Then I'd have to keep the thing running. Build a dashboard for it. Handle the cancel flow UI. Store feedback somewhere I could actually search later. Add notifications for when someone tips from Risky into Drifting. Handle edge cases. Write tests. Keep it all working while simultaneously trying to ship the actual product I'm supposed to be building.

That's not a weekend thing anymore. That's a whole second project that starts quietly eating the first one alive. I've watched that happen before.

So I went looking for something I could just drop in.

Finding Flidget

Found Flidget pretty late one night while going down a rabbit hole on retention tooling. What got me immediately was that it wasn't trying to be some enterprise customer success platform. No "book a demo." No sales team I'd have to talk to. No implementation guide that's 60 pages long. It was clearly built for developers. Install it, send some events, look at data. That's it.

And it handles exactly the two things I actually needed:

Drift detection — watches behavior, builds a score, labels every user Healthy, Risky, or Drifting. Tells you why in plain language. Not a number you have to go decode somewhere else.

Exit chat — when someone hits your cancel button, a small chat widget opens. Right there on the page. Not a redirect. Not some separate form URL. Right there. They can type or leave a voice response explaining why they're leaving. Everything goes into a searchable dashboard.

Both problems. One install. That was honestly enough.

The Setup (It Really Is 10 Minutes)

Okay here's what it actually looks like.

Install the package:

npm install @flidget/web-sdk

Then drop this somewhere early — main entry file, auth handler, wherever:

import Flidget from '@flidget/web-sdk';
Flidget.init({ publicKey: 'your_public_key' });

That's it for the exit chat. Like genuinely that's the whole thing. The second this is running, Flidget catches your cancel button and opens the chat automatically. You don't touch anything else for that part to work.

Setting Up Drift Detection

This part needs slightly more thought. Still not much more code though.

You need to figure out which 3 to 5 actions in your app actually mean someone is getting value. Not every click. Not every page view. The specific things that separate users who stick around from users who don't.

For most SaaS apps it ends up being something like:

Finishing onboarding
Using the core feature the first time
Inviting someone from their team
Creating something real — a project, a workflow, a report
Coming back on their own on day 7 or day 30

Once you have that list, tracking is just:

Flidget.track('complete_onboarding', { userId: user.id });
Flidget.track('used_core_feature', { userId: user.id });
Flidget.track('invite_teammate', { userId: user.id });
Flidget.track('created_first_project', { userId: user.id });

Give it a few days of data. After that, every user in your app gets a score. Dashboard shows you the full list sorted by risk level, with a reason attached.

Something like: "Drifting — 11 days inactive, never used core feature."

Okay so — what do you actually do with that? You know exactly where they got stuck. So instead of firing off some "hey we miss you!" blast that goes straight to the promotions tab, you send something specific. "Hey — I saw you signed up a couple weeks ago but never got a chance to try [core feature]. Honestly that's where most people have their first real moment with the product. Want me to walk you through it?"

That email gets replies. I've sent enough of them. It works.

What the Dashboard Actually Gives You

Once both pieces are running the dashboard becomes something you actually want to open. Which, for an analytics tool, is kind of rare.

Drift side: live list, sorted by risk. Filter to just Drifting users, see why each one got flagged, decide what to do. Some you reach out to directly. Some you put in a sequence. Some you watch for a few more days before doing anything.

The point is you're moving before they cancel. Not reacting after.

Exit side: feed of cancellation reasons in actual human words. Searchable, filterable. After a few weeks you start seeing things you wouldn't have found in any dropdown. Multiple people using almost identical phrasing to describe the same problem. The thing you assumed was driving churn — usually price — barely showing up. But something else showing up constantly.

That's the kind of thing that changes what you build next. Not a pie chart of dropdown selections. Real sentences from real people explaining what didn't work.

Oh and the rescue emails — when someone hits Drifting, Flidget can automatically fire an email from your own domain. Not a marketing blast. A specific message, timed to when they're most likely to actually respond. That part alone is probably worth the whole subscription cost.

Why I Didn't Just Build It Myself

I know exactly what some people reading this are thinking. "I could just build this." I had that same thought for like two weeks.

You probably could build a version 1. The drift scoring really isn't complicated — days since last login, did they use the key feature, is usage going up or down. Weight those somehow, generate a score, slap a label on it. Exit chat is maybe a day's work. Overlay on the cancel click, simple input, store the response somewhere.

Version 1 is always easy.

Version 2 needs a real dashboard. Version 3 needs search and filtering. Version 4 needs notifications. Version 5 needs the email automation. And somewhere in there something breaks in production on a random Thursday evening and you spend three hours debugging your own internal analytics tool instead of the feature three users have been asking about for a month.

I've done this. I have the internal tools to prove it. Things that started as "quick weekend project" and slowly turned into things I dreaded having to touch.

Flidget costs money. That's genuinely fine. Paying for it means someone else is handling the edge cases and the infrastructure and the 3am production incidents. My job is to build my product. That's the whole trade.

Honestly Wish Someone Had Told Me This Earlier

Set it up before you need it. Like way before.

I set it up after I already had a visible churn problem. By then I'd lost weeks of data that would've been really useful. And — worse — I'd lost users I probably could've kept if I'd known they were drifting even a few days earlier.

When you have 50 users it feels completely overkill to worry about retention tooling. But those 50 people are honestly your most valuable resource. Every single one of them looked at your product and decided it was worth trying instead of just doing nothing. Understanding why some of them stay and some of them leave — while you can still have an actual conversation with all of them — is data you can't just buy back later.

By the time you've got 500 users and churn is visibly hurting your MRR, you've already burned through months of signal you could've had. You're playing catch-up instead of being ahead of it.

The signals were in my users' behavior the whole time. I just wasn't collecting them.

Quick Rundown of What You're Getting
Okay so just to make it concrete — here's what actually happens when you add Flidget:
Your users are getting watched in the background. Not in a creepy way — just logins, are they using the thing, how long are sessions, that kind of stuff. And based on that it builds a score. When someone drops below a threshold, they move from Healthy to Risky to Drifting, and you get notified.

When someone tries to cancel, a chat opens right there on the page. No redirect. No separate form. Right where they are. They type or record why they're leaving. That lands in your dashboard tagged to their account.

One place to see who's at risk and why people are actually leaving. Not vanity metrics. Not just raw event counts. Actual information you can do something with today.

And all of it runs off one npm package and a few tracking calls.

Last Thing

I spent too long treating retention as something I'd deal with later. There was always a more urgent bug, always another acquisition thing to try, always a reason to push it off one more week.

Here's the uncomfortable part: acquisition without retention is just an expensive treadmill. You're working hard just to stay in the same place. Every user you lose is a user you have to go find again before you can actually grow. That costs money and time and energy that could've gone into building something better.

Churn isn't a billing problem. It's not a marketing problem. It's a signal that something in your product isn't clicking — and catching that signal early is so much cheaper than catching it after six months of wondering why growth feels stuck.

If you're building a SaaS right now and you don't have any visibility into who's drifting or why people are cancelling, seriously just go look at Flidget. Ten minutes of setup. Data that's actually useful from day one, not after some long drawn-out onboarding.

And if you've built your own version of this — especially the drift detection piece, I'm always curious how other people approach that part — drop it in the comments. Genuinely want to know.

Your Users Are Leaving Without Saying Why — Here's How to Fix That

Riya Sharma — Thu, 07 May 2026 08:57:19 +0000

You check your dashboard Monday morning. MRR is down. Three cancellations over the weekend. You have no idea why.
Was it the price? A competitor? Something broke? You'll never know. They just... left.

We've All Been There

The worst part isn't the churn. It's the silence.
No angry email. No support ticket. No feedback. Just a cancelled subscription and a gap in your MRR that you'll spend the next week trying to explain in a team meeting.
I started digging into this a while back and realized — we're all measuring churn wrong. We treat it like a post-mortem when it should be a warning system.

Two Moments Where You Can Actually Do Something

Before They Cancel
Nobody wakes up one day and decides to cancel. It builds slowly. They log in less. They never quite figured out that one feature. Their sessions get shorter every week.
That drift window — usually 5 to 7 days before they hit cancel — is your real chance. A well-timed "hey, is everything okay?" email at the right moment genuinely works. Not a generic newsletter. A message that says I noticed you haven't done X yet, can I help?
To do that, you need to be scoring your users continuously — combining last active date, whether they've hit your key feature, and whether their usage is trending up or down. Put those three signals together and you'll know exactly who needs attention before they've even thought about leaving.
The Exact Moment They Click Cancel
This is the most underrated feedback opportunity in your entire product.
At the cancel moment, people are finally honest. The politeness is gone. They'll tell you the real reason — not "too expensive" from a dropdown, but "I needed CSV export and you don't have it" or "we switched to your competitor because of one specific thing."
That's gold. And most products just let it walk out the door.
The fix is simple — intercept the cancel click, open a short chat right there on the page, and ask. Let them type or record a voice note. 10 seconds of their time. Don't redirect them anywhere. Just ask and listen.

What I'd Recommend https://flidget.com/ is the only tool I've seen that handles both of these together — drift scoring and exit chat in one place, one npm install, live in under 10 minutes. Worth checking out if you don't want to build this yourself.

Honestly?
Churn is just a communication failure dressed up as a business metric.
Users leave when they don't get value — and most of the time, if you'd known sooner or asked at the right moment, you could have changed the outcome. The tools exist. The effort is low. There's really no excuse for letting users disappear without a word.

Have you built something like this? Would genuinely love to hear how you approached it in the comments.

saas #startup #webdev #javascript

3 cancellations. $1,800 MRR gone. Here’s what we missed

Riya Sharma — Wed, 06 May 2026 07:45:02 +0000

It was a Tuesday morning. I opened our dashboard and saw three cancellations from the night before.

Not three trial users. Three paying customers. $600, $700, and $500 per month. Gone.

I sat there for a minute just staring at the number. $1,800 MRR. Overnight.

The worst part wasn’t the money. It was that I had absolutely no idea why.

The Post-Mortem Nobody Wants to Do

I did what every founder does in that moment. I pulled up their accounts one by one and started digging.

Sarah’s company had been with us for 8 months. Alex’s team for 11. The third account, a startup out of Berlin, had just renewed 6 weeks ago.

I went through their support tickets. Their login history. Their feature usage.

And that’s when I felt sick.

The signs were all there. I just wasn’t watching.

Signal #1 — They Went Quiet

Sarah’s team had averaged 18 sessions a week in their first three months. By month six, it had dropped to 4. Last month, 1.

Nobody flagged it. No alert fired. It just happened silently in the background while we were busy shipping features.

Alex’s account told the same story. Peak usage in month two, steady decline after that. The last team member had logged in 9 days before they cancelled.

9 days of silence and we didn’t notice.

Signal #2 — They Never Used the Thing That Actually Mattered

Here’s what hurt the most.

Both Sarah and Alex had never once used our core collaboration feature. The one feature our best retained customers use within their first two weeks.

They had accounts. They had access. They just never got there.

And we never nudged them. Never flagged it internally. Never sent a single “hey, have you tried this?” email.

They paid us for months for a product they were only using at 30% capacity. Of course they eventually asked themselves why.

Signal #3 — Nobody Asked Them Anything Until It Was Too Late

When they cancelled, what did they see?

A confirmation screen. A “sorry to see you go” message. Maybe a dropdown with 5 generic reasons like “too expensive” or “missing features.”

They clicked something, submitted it, and left.

We got a data point. We lost a customer. And we still didn’t actually know what happened.

What We Do Differently Now

After that Tuesday morning, we started using Flidget. Not because it’s a magic fix, but because it plugs the three gaps that killed those accounts.

Drift Detection watches user behavior continuously and labels every user as Healthy, Risky, or Drifting based on real activity. Not just logins, but whether they’ve hit your key features, how sessions are trending, how long they’ve been quiet. Sarah and Alex would have been sitting in the Drifting bucket for weeks before they cancelled. We would have known.

Automated Rescue Emails go out from your own domain when a user crosses into risky territory. Not a generic blast. A contextual message based on what they haven’t done yet. “Hey, it looks like you haven’t tried X yet — here’s a quick walkthrough.” Sent automatically, in your voice, before they’ve made the decision to leave.

Retention Copilot catches them at the cancel moment if they still get there. A short chat opens right on the page — text or voice — and asks why in a human way. No redirect. No survey sent 3 days later. The reason lands in your dashboard tagged and ready to act on, captured when their intent is highest and they’re most willing to tell you the truth.

The Math Is Simple

We were flying blind across three critical moments: when users start slipping, when they’re about to decide, and when they’re at the door.

$1,800 MRR in one night. Three accounts we could have saved if we’d had visibility even 2 weeks earlier.

Retention doesn’t start at renewal. It starts the moment a user goes quiet and nobody notices.

One Last Thing

Go check your usage data right now.

Find your churned accounts from the last 90 days. Pull their session history. Check whether they ever used your most important feature.

I’ll bet you find the same pattern.

The signals were always there. We just weren’t built to see them in time.

If you’re dealing with silent churn and want to see how Drift Detection and Retention Copilot work together, Flidget is free to start and live in under 10 minutes — https://flidget.com/

I started Flidget after realizing my SaaS users were disappearing before I ever saw a warning

Riya Sharma — Tue, 05 May 2026 05:55:20 +0000

A few months ago I was reviewing my SaaS metrics and everything looked normal on the surface

Retention was stable churn was not alarming usage charts looked fine

But revenue was still not growing the way it should have been

That contradiction stayed in my head

So I started looking deeper

What I realized was uncomfortable

Users were not really leaving in a clear moment

There was no sudden drop no obvious exit point

They were slowly disconnecting from the product without saying anything

No feedback no complaints just silence

And I only understood this after they were already gone

That made me question something important

Most analytics tools show you when someone leaves but they do not show you when the decision to leave actually happens

There is a gap between behavior and intent and that is where most churn lives

So I started building Flidget

The idea is simple

Instead of only reacting after churn happens Flidget focuses on two things

First it detects early signs of disengagement so you can notice users who are slowly losing interest before they cancel

Second when a user tries to leave it replaces the silent cancel moment with a short conversation that captures what actually went wrong right there in real time

No delayed surveys no guessing later no missing context

Just direct feedback at the exact moment it matters

Everything flows into one simple view so founders can actually understand what is happening inside their product instead of guessing from scattered metrics

It is lightweight to integrate and works with most SaaS setups

I am still building it and learning a lot from real user behavior every day

But one thing is very clear now

Churn does not start at cancellation

It starts much earlier than what most dashboards can show

If you have worked on a SaaS product I would genuinely love to know

Have you ever noticed users leaving before your metrics showed any warning

What did that moment look like for you ?

https://flidget.com/