NNabeel Hassan

Blog · November 15, 2026 · 8 min read

Product Analytics for a Small App: The 15 Events Worth Tracking and the One That Matters Most

By Nabeel Hassan — AI Engineer · ICPC World Finalist

TL;DR: A small app does not need a hundred tracked events. It needs about ten to fifteen, each one answering a question you will actually ask: did people reach the core moment, did they come back, and did they pay. My approach: write the questions first, name one activation event that means "this user got the value", track the funnel from signup to that event to payment, send revenue events from the backend instead of the app, keep a written event list with one naming convention, and look at the numbers on a fixed schedule. Most analytics setups I inherit fail the same way: lots of data, and nobody can say what percentage of new users got to the thing the product is for.

The most expensive lesson from LectureNotes AI, the note-taking app I co-founded with Benjamin Rhodes, was about the funnel, not the code. Around 15 million organic Instagram views turned into nearly 10,000 users and roughly $1k MRR. Those are real numbers, and the ratio between them is the whole education. Every step from view to download to first good set of notes to paid subscriber loses people, and you can only fix the step you can see.

This post is how I set up product analytics on small apps now, for my own products and for clients, so that every step is visible from the first release.

Start with questions, not events

The usual approach is to install an analytics SDK, sprinkle track() calls on every button, and hope insight falls out later. It does not. You end up with a dashboard full of button_clicked events and no answer to the question that matters this week.

Before I name a single event, I write down the questions the founder needs answered in the first three months. On almost every small product they are some version of:

  1. Where do new users come from? Which channel, which campaign, which post.
  2. What share of new users reach the core moment? And how long does it take them?
  3. Where do the others drop off? Which screen, which step.
  4. Do they come back? After a day, a week, a month.
  5. Who pays, and when in their journey?
  6. What does each active user cost us? On an AI product this one is not optional.

Every event on the list has to help answer one of these. If it does not, it does not get tracked yet. That rule alone cuts a typical tracking plan by more than half, the same way cutting an MVP down to the core loop makes it shippable.

Define activation before you launch

The single most useful number on a small app is the activation rate: the share of new users who reach the moment where the product delivers its value at least once. Signups are vanity. Activation is the first real signal.

The work is deciding what that moment is, precisely enough to track as one event. For a note-taking app like LectureNotes AI, it is not "opened the app" or "started a recording". It is closer to "received a finished summary and outline", because that is the thing the student came for. For a sports-tech app like the ones I lead at RAQTS, it might be a player completing a first session or seeing their name on a live leaderboard. For a self-improvement app, it is a first personalized plan generated and opened, not a finished signup form.

A few rules I use for the activation event:

Once it exists, the most important chart in the product is: of the users who signed up this week, how many activated, and how long did it take.

The core event list for a small app

With the questions and the activation event settled, the list for a typical small consumer or B2B app is short:

That is ten to fifteen events. Everything else waits until a real question needs it.

Naming and properties: decide once

Analytics data rots fastest through inconsistent names. Three months in, there is SignUp, sign_up, user_signed_up and signupComplete, half from the iOS app and half from Android, and no chart is trustworthy.

My conventions, set on day one:

The tracking plan sounds like overhead. It is the cheapest way I know to keep three developers on two platforms sending the same data, and it is the first document I ask for when inheriting a codebase.

Revenue events belong on the backend

Client-side tracking is lossy. Ad blockers drop it, users go offline, apps get killed mid-request, and some events fire twice. For clicks and screen views, that noise is acceptable. For money, it is not.

On any paid app, I send revenue events from the server, from the same place that maintains the subscription record. I covered that plumbing in in-app subscriptions and entitlements: the backend hears about purchases, renewals and refunds from the stores directly, so it is also the right place to emit subscription_started or refund_issued. The app can still send paywall_viewed and checkout_started, because those are behavior, not money.

The same goes for the activation event when the value is produced server-side, like an AI summary. The server knows the summary actually came back. The app only knows it asked.

Two things to keep out of revenue numbers: sandbox purchases and internal test accounts. Tag both and filter them, or your first week will look better than it was.

Cost per active user, on AI products

On an AI product, the analytics plan has one line most templates miss: what each user costs. Model calls, transcription minutes and voice minutes are per-use costs, so a feature that drives engagement can also drive a loss.

I attach usage units to the core usage event (minutes transcribed, tokens or calls used) so cost can be grouped by user, by plan and by feature. Then the question "are free users costing more than paid users pay us?" is a query, not a guess. I wrote about why that matters in the unit economics of an AI app.

Privacy: track behavior, not people

Analytics is a data pipeline to a third party, so it gets the same caution as logs:

The same habit applies to voice products. When I report on voice agents, the metrics are call outcomes and durations, not what the caller said, which I wrote about in the voice agent metrics that matter.

Read the numbers on a schedule

The last failure mode is the most common: everything is tracked correctly and nobody looks. A dashboard nobody opens is a cost with no return.

What works on small teams is a fixed weekly review of four numbers, and only four:

  1. New users this week, by source.
  2. Activation rate for that cohort, and median time to activate.
  3. Week-one retention for last week's cohort.
  4. New paying users and revenue, from backend events.

If one moves, you dig into the funnel steps. If none move, the review takes ten minutes. Anything that needs a faster reaction, like activation dropping to zero because onboarding broke on one platform, belongs in alerts, not in a weekly review. I covered that side in error monitoring and alerting for a small product: a sudden silence in a core event is often the earliest sign of a broken release.

When an experiment is running, such as a new onboarding or a moved paywall behind a feature flag, the flag value goes onto events as a property so the comparison is clean.

What I would set up on day one

If I were adding analytics to a new app tomorrow:

  1. Write the five or six questions the founder needs answered in the first three months.
  2. Define the activation event precisely, in writing, and fire it where the value is delivered.
  3. Track the short event list above with one naming convention and shared base properties.
  4. Send revenue events, and server-side activation, from the backend.
  5. Attach usage units to core events if the product has per-use costs.
  6. Keep personal data and content out of events, and handle consent per region.
  7. Put a weekly four-number review on the calendar and an alert on a silent core event.

None of this needs a data team. It is a day of thinking and a day of wiring, and it turns "the launch went well, I think" into a funnel you can actually fix.


I build mobile apps, AI products and the backends behind them for startups in the US, UK and Europe, including the analytics that tell founders where their users actually drop off. If you are launching an app and want the tracking right from day one, or your current numbers do not answer your real questions, read more about my background or book a call.

FAQ

How many analytics events should a small app track?

Usually ten to fifteen at launch: signup with source, onboarding steps, one activation event, the core repeated action, paywall views and checkout starts, revenue events from the backend, and failures on the critical path. Every event should answer a question the team will actually ask; everything else can wait.

What is an activation event?

The single event that means a new user got the product's core value at least once, such as receiving a finished summary rather than just opening the app. It should reflect value received, not effort spent, fire in one place (ideally the backend), and be agreed in writing before launch.

Should revenue events be tracked in the app or on the server?

On the server. Client-side tracking is lost to ad blockers, offline users and killed apps, and can double-fire. The backend that maintains subscription state hears about purchases, renewals and refunds from the stores directly, so it should emit the revenue events, with sandbox and internal test accounts filtered out.

Can I send user content or emails to my analytics tool?

Avoid it. Use anonymous IDs, never send note text, transcripts or chat messages as event properties, handle consent where your users' region requires it, and check the current platform rules on tracking disclosures before launch.

Building something in this space?

I take on AI-agent, automation and product work directly — scoped fast, shipped fast.

Book a discovery call →

Keep reading