How to Set Up Crash Reporting and Release Health Monitoring for a Mobile App

A hand holding a smartphone with an app open on the screen

A web team that ships a bad build can roll it back in a few minutes. A mobile team cannot. Once a release is on thousands of phones, the broken version stays there until each user updates, and some of them never will. That one fact changes how you should think about monitoring, because the cost of finding out late is much higher than it is on the web.

Plenty of teams install a crash reporting library, glance at the dashboard once a week, and call it monitoring. That catches the loud failures eventually, but it misses the question that matters most on release day: is this version healthier or sicker than the last one? This guide walks through setting up crash reporting and release health monitoring so you can answer that question within hours, not weeks.

hand holding a smartphone with an app open
Photo by Sound On on Pexels

Why Mobile Monitoring Is Different From Web Monitoring

On the web, you control the code that runs. A deploy replaces the old version for everyone at once, and a bad deploy can be reversed just as fast. On a phone, the code lives on the device, and your release is one of several versions in use at the same time. You may have users on the current build, the previous two builds, and a handful on something a year old.

This has two consequences. First, every metric needs to be split by app version, because an aggregate crash rate hides a regression in the newest release behind the stable behavior of the older ones. Second, your fix has to travel through a review process and an update cycle before it reaches anyone, so the window between spotting a problem and resolving it is measured in days.

The right response is to move your detection as early as you can and to limit how many people a bad build can reach. Everything else in this guide supports one of those two goals.

Choose What to Capture Before You Choose a Tool

It is tempting to pick a vendor first and let its defaults decide what you collect. Do the opposite. Decide what you need to answer, then check that a tool supports it.

At a minimum you need fatal crashes with a full stack trace, the app version and build number, the operating system version, and the device model. You also want a short trail of breadcrumbs, meaning the last handful of screens visited and network calls made before the crash. A stack trace tells you where the app died. Breadcrumbs tell you how the user got there, and that is often the difference between reproducing a bug in ten minutes and not reproducing it at all.

Beyond fatal crashes, capture non-fatal errors that you handle yourself but still want to count, such as a failed sync or a parsing error that falls back to a default. These rarely show up in store dashboards, yet they are often the early warning that precedes a crash spike.

Pick a Crash Reporting Setup That Fits Your Team

You have a few reasonable options. The platform stores give you basic crash data for free through the Android vitals tooling documented at developer.android.com and the crash reports available through Apple's developer portal. These are a good baseline and cost nothing to enable, but they lag behind real time and offer limited context.

Dedicated crash reporting services add real-time alerts, grouping of similar crashes, breadcrumbs, and release tracking. Firebase Crashlytics and Sentry are two widely used examples. The choice usually comes down to how much you want to pay, whether you need self-hosting for data reasons, and how well the tool fits the rest of your stack.

Whichever you pick, test the integration on purpose. Force a crash in a debug build and in a release build, then confirm it appears with a readable stack trace. Release builds are where symbolication goes wrong, because minified or stripped code produces traces full of meaningless addresses unless the right mapping files were uploaded. Make uploading those files a mandatory step in your build pipeline, not something a person remembers to do.

Define Release Health in Numbers

Release health means measuring the stability of each version relative to its users, rather than counting raw crash events. Two numbers carry most of the weight.

The first is the crash-free sessions rate: the percentage of sessions that ended without a crash. The second is the crash-free users rate: the percentage of users who did not experience a crash at all in the period. Sessions tell you how often things break. Users tell you how many people were affected. A crash loop on a small group of devices can wreck the session rate while barely touching the user rate, and the reverse can also happen.

Record these per version. When you release a new build, compare it to the previous one at the same stage of adoption. A raw count of crashes is misleading in the first hours, because only a small slice of users has the new build and the totals are tiny. The rate normalizes for that and lets you compare fairly even when adoption is still low.

Set Thresholds That Mean Something

A number without a threshold is just a chart. Decide in advance what counts as acceptable, and write it down where the team can see it.

A useful way to frame this is as a service level objective for stability. For example, you might commit to a crash-free sessions rate of at least 99.5 percent for any version in production, with a stricter bar for critical flows such as sign-in and checkout. Pick numbers based on your own history rather than copying someone else's, because a gaming app and a banking app live in very different worlds.

Then define two kinds of reaction. A warning threshold prompts someone to look at the data. A halt threshold stops the rollout automatically or prompts a person to halt it. Having both avoids the common failure where everyone sees a dip, assumes someone else is handling it, and nothing happens for a day.

"A monitoring dashboard nobody has agreed how to react to is decoration. Decide the halt threshold before the release, while everyone is calm." - Dennis Traina, founder of 137Foundry

Use Staged Rollouts to Limit the Blast Radius

Monitoring tells you a release is bad. A staged rollout limits how many people find out the hard way. Both major stores let you release to a percentage of users and increase it over time, and this is the single most effective safety net a mobile team has.

A typical schedule starts at one to five percent, waits long enough to collect meaningful data, then moves to twenty, fifty, and finally everyone. The wait at each step should be tied to data, not to the calendar. If you have too few users in the first stage to reach a stable crash rate, hold longer or widen the first step.

Pair the schedule with your thresholds. At each stage, someone checks the release health numbers against the objective before widening the rollout. If you can, automate the check and have it post a summary to the team channel, so the decision to proceed is a deliberate act and not a default. For releases that need extra care, our work in app development often includes wiring this gate into the release pipeline so it cannot be skipped on a busy day.

Build Alerts That People Do Not Learn to Ignore

Alert fatigue kills monitoring programs faster than any technical limitation. If every new crash group pings the whole team, people mute the channel within a week, and the alert that matters gets lost with the rest.

Keep alerts tied to change and impact. Notify on a new crash group that first appears in the latest version, on a regression where a previously fixed crash returns, and on a crash that affects more than a set share of users or hits a critical flow. Route these to the person on call for the release rather than to everyone.

Everything else belongs in a regular review. A weekly triage of the top crash groups by users affected, with a named owner for each, keeps the long tail from growing while keeping the day-to-day quiet. The rule of thumb is simple: if an alert did not lead to a decision, change or remove it.

Close the Loop From Crash to Fix

Detection only pays off when it leads to a fix that actually ships. Treat each crash group as a work item with an owner, a severity, and a status, and link it to the ticket tracking the fix. Without that link, crash lists turn into a graveyard that nobody reads.

When you fix a crash, tag the fix with the version it landed in and watch whether the group stops appearing in that version. Many crash reporting tools can mark a group as resolved in a given release and flag it automatically if it returns, which catches the case where the fix only covered one of several causes.

Be honest about prioritization too. A crash that affects half a percent of users on a rarely used screen may not deserve a hotfix, while one that blocks sign-in for a small group might. Weigh the share of users affected, the importance of the flow, and whether there is a workaround. Keeping that reasoning visible makes it easier to defend the decision later.

Respect Privacy While You Collect

Crash data can contain more than you expect. Stack traces and breadcrumbs may include user identifiers, email addresses in URLs, or fragments of form input. Review what your tool captures by default and scrub anything sensitive before it leaves the device.

Use an opaque user ID rather than an email address, strip query strings from logged URLs, and never log the contents of password or payment fields. If your app serves users in regions with strict data rules, check that your vendor's storage location and retention settings match your obligations. It is far easier to configure this at the start than to explain a leak afterward.

Putting It Together

Good mobile monitoring is a short chain of decisions made ahead of time. Capture the right data, measure stability per version, set thresholds you agreed on in advance, release in stages, and route alerts to someone who owns the response. None of these steps is exotic, but skipping any of them leaves a gap that a bad release will find.

If you want help setting this up across a real release pipeline, our team builds this kind of tooling as part of larger web development and mobile projects, and you can learn more about how we work on the about page. Start small: get symbolicated crashes flowing, publish your first crash-free rate per version, and agree on one halt threshold. That alone puts you ahead of most teams shipping to phones today.

Need help with Web Development?

137Foundry builds custom software, AI integrations, and automation systems for businesses that need real solutions.

Book a Free Consultation View Services