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:
- Where do new users come from? Which channel, which campaign, which post.
- What share of new users reach the core moment? And how long does it take them?
- Where do the others drop off? Which screen, which step.
- Do they come back? After a day, a week, a month.
- Who pays, and when in their journey?
- 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:
- It is one event, fired at one place. Ideally on the backend, at the moment the value is actually delivered, so it cannot fire on a failed attempt.
- It reflects value received, not effort spent. "Uploaded a file" is effort. "Got a result" is value.
- It is agreed in writing with the founder. If the team argues about what activation means after launch, the number is useless for the first month.
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:
- Acquisition:
app_installedorsigned_up, with the source attached (campaign, referrer, or the store's attribution where available). - Onboarding steps: one event per meaningful step, such as
onboarding_step_completedwith a step name, so you can see the drop-off screen by screen. - Activation: the one event defined above.
- Core usage: the repeatable version of the core action, such as
summary_generatedorsession_completed, which is what retention is measured on. - Paywall:
paywall_viewedwith where it was shown, andcheckout_started. - Revenue:
subscription_started,subscription_renewed,subscription_cancelled,refund_issued, sent from the backend. - Key failures:
generation_failedorpermission_deniedon the critical path, because a step that fails silently looks exactly like a user who lost interest.
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:
object_actionin snake case, past tense.summary_generated,paywall_viewed,onboarding_step_completed. Every platform uses the same names.- Properties carry the detail, names stay few. One
onboarding_step_completedevent with astepproperty, not twelve separate events. - Every event gets the same base properties: platform, app version, an anonymous user ID, and the environment. App version matters more than people expect, because old app versions never fully leave and a funnel drop that only exists on one build is a bug, not a trend.
- A written tracking plan. A plain table with event name, when it fires, where it fires (app or backend), and its properties. It lives next to the code and changes in the same pull request as the tracking call.
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:
- Anonymous IDs, not emails or names, in event properties.
- No content. Never send the text of a note, a transcript or a chat message as an event property. Send its length or type if you need something.
- Consent where the law requires it, which depends on where your users are. A UK or EU audience changes what you can track before consent.
- Respect platform rules. Mobile platforms have their own requirements for tracking disclosures and permissions, and they change, so check the current ones before launch.
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:
- New users this week, by source.
- Activation rate for that cohort, and median time to activate.
- Week-one retention for last week's cohort.
- 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:
- Write the five or six questions the founder needs answered in the first three months.
- Define the activation event precisely, in writing, and fire it where the value is delivered.
- Track the short event list above with one naming convention and shared base properties.
- Send revenue events, and server-side activation, from the backend.
- Attach usage units to core events if the product has per-use costs.
- Keep personal data and content out of events, and handle consent per region.
- 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.