App data, Note 03

Analytics for a small app: four questions and a dozen events.

What our apps actually collect today, and how we'd decide what to add.

Most advice about mobile analytics assumes you'll install an SDK, define a few dozen events and build dashboards. Before writing about what a small app should measure, it's worth being plain about what ours actually do, because the answer is "less than you'd expect", and that was a reasonable place to start.

What's actually in our apps

Checked against the current source of each app:

  • Sudoku: Color (iOS, native version). No analytics SDK. The app links Firebase, but only Firebase Core and Realtime Database, which run online multiplayer rooms. Google Mobile Ads is there for ads; Game Center handles leaderboards.
  • Drag Tree Simulator. Firebase Analytics is linked and initialised at launch. There are no custom events in the code, so what it collects is the SDK's automatic data — installs, sessions, screen and device information — rather than anything specific to the app.
  • ColorPair. No analytics SDK. Google Mobile Ads only.

On top of that, every app gets the store's own reporting: App Store Connect for iOS and Play Console for Android, plus AdMob's reporting for ad revenue. For a small catalog, that combination already answers the first questions anyone asks — are people installing it, which versions and devices, does it crash, does it earn anything.

Write the questions before the events

The trap with analytics is adding tracking because you can, then owning a pile of events nobody reads. The fix is old and boring: write down the decisions you'd make differently depending on the answer, and only instrument those.

For a puzzle game, the useful questions are usually few:

  • Do new players finish a first game? If not, the first session is the problem, not the content.
  • Where do players quit? Which difficulty, which screen, how far into a puzzle.
  • Do people come back? Day 1, 7 and 30 return rates — the store dashboards give rough versions of these already.
  • Which features get used? Daily challenge, multiplayer, notes, hints — worth knowing before spending a month on one of them.

If a proposed event doesn't change what you'd do about one of those, leave it out. Every event has to be named consistently, kept working through refactors and explained later to someone who has forgotten why it exists — often yourself.

If you add events, a dozen is enough

For a game shaped like Sudoku: Color, these twelve events would answer all four questions. This is a starting list, not something the app sends today:

  1. onboarding_complete, with whether it was skipped
  2. game_start, with difficulty and mode (single, daily, multiplayer)
  3. game_end, with result, duration, mistakes, hints and undos used
  4. game_abandon, with how many cells were filled
  5. notes_mode_used, first use per game
  6. hint_used
  7. daily_start, with the day's modifier
  8. daily_complete, with the current streak
  9. mp_room_created
  10. mp_match_start, with how the match was found (code, search or bot)
  11. mp_match_end, with result and whether a rematch followed
  12. store_opened, with which screen it was opened from

Put the context in parameters rather than inventing a new event name for every variation; game_end with a result parameter beats separate game_won and game_lost events.

A practical detail for SwiftUI apps: route every event through one small wrapper rather than calling the SDK from views. It keeps names in one file, makes events testable, and means swapping or removing the vendor later is a one-file change.

Privacy is part of the stack

Anything you collect has to be declared in the App Store privacy label and, since 2024, accounted for in the app's privacy manifest. Sudoku: Color already ships a privacy manifest and asks for App Tracking Transparency permission before starting the ads SDK. Adding an analytics SDK changes what those declarations must say, and that's a real cost: the label is on the store page every potential player sees.

That cost is a good reason to lean on data you already have — store dashboards, crash reports, ad reporting, leaderboard activity — before adding a new collector.

Logs are not analytics, but they help

Not every measurement needs a vendor. The contact form on this website keeps a small server log for each request: the first eight characters of a SHA-256 hash of the sender's IP address, and a one-line outcome — sent (with the inquiry type), dropped by the spam checks, or rate limited. The full address and the message text aren't written to that log; the message goes only to our inbox. To enforce the rate limit, the function also holds recent IP addresses in memory while it's running, and that memory is discarded when the function shuts down.

A shortened hash isn't anonymous. It isn't salted, and the number of possible IP addresses is small enough that someone with the log could test candidates against it. So we treat those log lines as personal data: they're used only to check that spam protection and rate limiting work, and they're deleted automatically after 30 days. The same principle applies inside apps — record the minimum that answers the question, and be clear about what that record still reveals.

The honest summary

We don't have retention curves or funnel charts to share, because our apps don't collect the events that would produce them. That's a deliberate starting point rather than an oversight: store reporting covers the basics, and custom events come in only when there's a specific decision waiting on the answer. If you're building a small app, that order — questions, then events, then dashboards — is the one we'd recommend.

Note details

SectionApp data
Reading time4 min
UpdatedOctober 18, 2026
RelatedPrivacy

Questions about something in this note?

Send a message. If you're weighing a similar decision in your own app or tool, a short description of the problem is enough to start.