Is anyone actually using your SaaS? How to find out who activated and who never came back

To find out whether people are actually using your SaaS, pick the one action that means a user got value, record it from your server, and sort every new user by whether they did it and whether they came back. Logins and page views don't count.

You launched a few weeks ago and you have sign-ups. What you don't know is who got to the thing your product is for, who poked around once, and who signed up and never came back. You can answer that today with one definition, one table and one query. This guide shows the do-it-yourself version first. At the end there's a short section on how Atune automates the same thing.

Step 1: Decide what "using it" meansCopy Anchor Link

Someone can log in every day and get nothing done. Pick the one action that means a user got value from your product:

• an invoicing tool: sent an invoice
• a reporting tool: generated a report
• a scheduling tool: a booking was made through it
• a team tool: invited a teammate, often a better signal than any solo action

Rules of thumb:

1. It happens in your product, not on your marketing site.
2. It's the reason someone would pay. If they did it every week, would you be happy? Then it's the one.
3. One event, not a funnel. You can add steps later.

Write it down. This is your activation event. A user who has done it at least once is activated.

Step 2: Record that event, and when people show upCopy Anchor Link

If you don't have an events table yet, add one. It takes ten minutes and you'll use it for everything else in this guide.

create table events (
  id         bigserial primary key,
  user_id    text not null,
  account_id text,             -- the team/company you bill; null for B2C
  name       text not null,    -- e.g. 'report.generated'
  created_at timestamptz not null default now()
);
create index on events (user_id, created_at);

Insert a row from your server whenever the activation event happens, and one row for any authenticated request you care about (opening the app is enough to count as "showed up"). Don't trust a user or account ID sent from the browser; take it from your server-side session.

No time for this? On Supabase, auth.users.last_sign_in_at gives you a rough "came back" signal for free. It only tells you about sign-ins, not usage, so treat it as a stopgap.

Step 3: Sort every new user into one of four groupsCopy Anchor Link

This query looks at everyone who signed up in the last 30 days:

with signups as (
  select id::text as user_id, created_at::date as signup_day
  from users                                   -- or auth.users on Supabase
  where created_at > now() - interval '30 days'
),
activity as (
  select user_id,
         count(distinct created_at::date)         as active_days,
         max(created_at)                          as last_seen,
         bool_or(name = 'report.generated')       as activated  -- your activation event
  from events
  group by user_id
)
select s.user_id,
       s.signup_day,
       coalesce(a.active_days, 0)   as active_days,
       a.last_seen,
       case
         when a.user_id is null       then 'never used'
         when a.activated             then 'activated'
         when a.active_days <= 1      then 'one and done'
         else                              'exploring'
       end as status
from signups s
left join activity a using (user_id)
order by s.signup_day desc;

What the groups mean:

Two refinements once you have a few weeks of data:

• Give new users time. Someone who signed up yesterday isn't "one and done" yet. Leave anyone younger than about a week out of judgments, or label them "new".
• Coming back matters more than activating once. Add a column for active days in the last 7. Someone who activated three weeks ago and hasn't been seen since is a different person from someone who uses it every weekday.

Step 4: Look at it every week, and talk to peopleCopy Anchor Link

Put 20 minutes in your calendar every Monday:

1. Run the query. Count each group and write the four numbers down, so you can see the trend.
2. Read the one and done list. Pick three people and send each a two-line personal email: what you saw, and one question. "You set up a project but didn't generate a report. Was something in the way?"
3. Read the exploring list for patterns: did they all stop at the same screen?

At this stage, the conversations are worth more than the numbers. The numbers tell you who to talk to.

Where the do-it-yourself version starts to hurtCopy Anchor Link

This works well up to a point. It gets painful when:

• you have teams, and need to judge the account (the company that pays) rather than each person;
• you want "who's slipping" as well as "who never started": someone who was active five days a week and now isn't;
• you're not sure which action really is your activation event, and want to check it against what retained users actually do;
• you have to remember to run it.

The automated route: AtuneCopy Anchor Link

Disclosure: I build Atune.

Atune does the same job without the query. It reads how people use your product and gives you a short list in an Inbox: who is stuck, who is slipping, why, and a drafted message to send. What maps to this guide:

• It works out your value events. Atune infers which actions mean a user got value. On the Users page, filter by Reached value or Not reached value to find people who signed up but never got there.
• Statuses with nothing to configure. Every person gets a user health score from 0 to 100, built from active days, value use, recency and trend, and a status: Healthy, Watch, Risk, Inactive (no events in 14 days) or Learning (first seen less than 7 days ago, so it doesn't judge them yet).
• Accounts, not only people. If you send an account (team, organization or company), Atune scores the account too, on the same thresholds.
• It says when it doesn't know. Every Inbox action explains why and how sure it is.

Ways to connect it: npx atune init in a Next.js app, track() from any Node backend, an HTTP POST from any language, Twilio Segment, or Connect PostHog if you already send events there (it imports your last 90 days). Start with the Quickstart.

What it doesn't do: it doesn't replace talking to your users, and it can't see what you don't send it. It captures server-side only, so a browser-only app needs a backend that sends events.

Availability: Atune is in a closed beta for software teams in the EU and EEA. You apply for access and every request is reviewed. The Build plan is free for up to 25 active customer accounts (pricing).

SummaryCopy Anchor Link

1. Define one activation event: the action that means someone got value.
2. Record it, plus "showed up", server-side.
3. Sort new users into never used, one and done, exploring and activated.
4. Every week: write down the counts, email three stalled users, and look for the shared sticking point.

That answers "is anyone using it?" with names, not a vanity chart.