Short answer. An app that crashes on your customers' phones is stabilised in five steps. Observe: a reporting tool sends, for every crash, the device, the version, the screen and the last actions. Rank: reports are grouped by cause and causes ranked by number of customers affected; a few account for most of it. Reproduce: on the phones your customers really have, low memory, network cut, a full local database. Fix: the cause, with a test that stops it coming back. Release in stages, with a written threshold that halts the release. The public yardstick: Google considers an app to be behaving badly above 1.09 % of daily users affected by a crash.
This guide is for the manager or founder whose app, ordering, delivery, booking or point of sale, is already in customers' hands and closes for part of them, for anyone whose developer answers “I cannot reproduce it”, and for the founder based in France who reads the store reviews without being able to test on the phones used in Algeria. The yardsticks quoted come from the public documentation of Android and Firebase: user-perceived crash rate, application not responding, crash-free users. The numbers in the figures are a constructed example, a wholesaler's ordering app used by 3,800 customers. This guide gives no price.
Where the app crashes: not on the developer's phone
The figure sorts the 3,800 customers by phone memory and Android version, and gives in each cell the share of them who see the app close each day.
What the grid says. Across all customers, 2.9 % see a crash every day, about 112 people. But the average hides everything: the share rises to 12.8 % on 2 GB phones running an old Android version, and falls to 0.1 % on a recent 8 GB phone, the one the developer tests with. Phones with 2 and 3 GB of memory are 40 % of the customers and 89 % of the crashes. “It works for us” is therefore accurate, and says nothing about what four customers in ten experience.
The public yardstick. Android vitals, Google Play's quality dashboard, counts per daily active user. Two bad-behaviour thresholds are published there for user-perceived crashes: 1.09 % across all devices, and 8 % on a single phone model. Beyond them, Google says it may reduce the app's visibility and show a warning on its store listing. The example exceeds the first threshold almost three times over, and three cells of the grid exceed the second. Why modest phones. Each app has a limited amount of memory; if it asks for more, it receives an out-of-memory error and closes, and when the phone itself runs short, the system closes apps left in the background. A catalogue photo displayed without being reduced gets through on 8 GB and not on 2. Add old Android versions, each manufacturer's own settings, storage that is almost full and a network that drops.
«“It works for us” is accurate, and says nothing about what four customers in ten experience.»
From a one-star review to a line of code
The figure shows what a crash report contains and, beside it, causes ranked by number of customers affected.
The report. A review says “it closes when I confirm”. A crash report, sent by the app itself, gives the phone model, the Android version, the app version, the screen, free memory, the last actions and the place in the program where everything stopped. Tools such as Firebase Crashlytics, which its documentation describes as a real-time crash reporter that helps track, prioritise and fix stability issues, group these reports by cause. One precaution: preparing an Android app for publication often renames classes and methods, which makes the trace hard to read; for every published version, keep the file that makes it readable again, and on iPhone the symbol files. Without them you have thousands of reports and not one line.
The ranking. In the example, forty-one distinct causes in two weeks, but three account for 78 % of crashes: a catalogue photo too heavy for the memory, 41 %; an empty server response the program did not expect when the network drops, 23 %; a write to the local database during synchronisation, 14 %. They are fixed in that order, by customers affected and not by ease. The measure. The figure to follow is the share of crash-free users, which the Firebase documentation defines as the percentage of users active over a period who did not have a crash; it is read version by version. In the example, fixing the first three causes brings the share of customers affected each day from 2.9 % to about 0.6 %, from 112 people to 23. Memory and weak networks are covered more broadly in the guide to the slow app and the guide to offline use.
«Without the file that makes each version's traces readable, you have thousands of reports and not one line.»
A stable app, in five layers
The accented layer is ranking: it decides what is fixed first.
Observe. The reporting tool is present in every version; it records crashes, and freezes too. Android declares that an app is not responding when its display thread is blocked for too long, for example when it does not react to a touch within five seconds; the customer then sees the “app isn't responding” window and closes it. The public threshold is 0.47 % of daily users affected. Rank. By cause, by number of customers, by version: a crash that appeared with 2.6 does not have the same story as one that has been there for a year. Reproduce. On a table, the three or four phones the store console shows as the most common among your customers, including a 2 GB one; a network that is cut in the middle of an order; a local database filled with six months of data; storage that is almost full.
Fix. The cause, not the symptom: wrapping a line in “if it fails, do nothing” removes the crash and leaves the customer in front of an empty screen. Each fix comes with an automated test that replays the situation, so the crash does not come back two versions later. Release. In stages, with a threshold written before the release and a halt if the morning figure exceeds it, as in the guide to updating an app; before the release, Google Play installs the version on a set of devices in its test lab and crawls it automatically for a few minutes, which catches crashes at start-up. And someone is warned when the rate rises, as in the guide to monitoring.
Six real situations, and what to do
Each row is a sentence read in a review or heard from a customer, and the answer is a way of working, not a promise.
It works for us, it crashes for customers: the list of test phones is copied from the store console, not from the office. The developer cannot reproduce it: without a report, he guesses; with the device, the screen and the last actions, he replays. It closes when the catalogue opens: images are requested at screen size and the list loads page by page, as in the guide to the slow app.
It crashes when the network drops: every call to the server has three planned outcomes, the response, the failure and the timeout, and the screen knows what to show in all three. It freezes, then Android offers to close it: a calculation, a file read or a query done on the display thread; they are moved off it, and the screen keeps responding. Since the update, the rating has fallen: the version went to every customer on the same day; it now goes to five per cent of them, and the figure decides what follows. Answering one-star reviews with the version that fixes the problem, not with a formula, is part of the work: the customer who wrote the review is the one who can change it.
Stabilising an app in 2027, in weeks
Four weeks in the example, the first with nothing fixed.
Week 1, connect and read: the reporting tool is installed, the files that make traces readable are kept, a version is published; what comes back is read by device, by screen and by version, with nothing fixed yet. Week 2, rank and reproduce: causes are grouped and ranked, the first three reproduced on customers' phones.
Week 3, fix: three causes, one automated test per cause, a trial on a full local database and on modest phones. Week 4, staged release: five per cent, twenty, then a hundred, with the written threshold; reviews get an answer, and the manager gets a crash table by version. Then the cycle starts again with the next causes: stability is not a project, it is a monthly routine. When the original developer is no longer there, the work starts with recovering the code and the accounts, as in the guide to taking over an app.
Six questions to ask your developer
The second is accented: someone who does not know their first three causes cannot say what they will fix this month.
- What the manager sees: the share of crash-free customers by version, the first three causes and their status, the store rating, the phones most affected.
- What the company no longer does: learn about a crash from a review, release a version to every customer on the same day, hear “I cannot reproduce it”.
- What is measured: crash-free users, share of customers affected each day, freezes, causes open and fixed, time between a new crash and its fix.
- What Symloop does: connect reporting to an existing app, read and rank the causes, reproduce on your customers' phones, fix with tests, release in stages, and hand you a monthly table; when the app was built elsewhere, we start with a review of the code.
What is our rate? The share of crash-free customers, by version, and the share affected each day in the store console. What are the first three causes? By number of customers affected. On which phones? Memory, Android version, the most common models among your customers.
What has been reproduced? On which device and in what conditions. Which test stops it coming back? A test that replays the situation at every version. What threshold halts a release? A figure, written beforehand. A developer who answers these six questions is in control of the app; one who answers “it works on mine” to all six needs tools, not blame.
- Why does my app crash for some customers and not for me?
- Because their phones are not yours: less memory, an older Android version, storage that is almost full, a network that drops, and months of data accumulated in the app. A recent, empty phone on Wi-Fi is the most favourable case; it is also the one most often used for testing.
- What crash rate is acceptable?
- The public Android vitals yardstick places bad behaviour above 1.09 % of daily users affected by a crash, and 8 % on a single phone model; for freezes, 0.47 %. These are limits not to cross, not targets: aim well below, and look at the figure by version and by class of phone, not the average.
- How do I find out why the app crashes?
- With a crash reporting tool built into the app, which sends the device, the version, the screen, the last actions and the place in the program. The Google Play console also gives, with nothing to install, crashes and freezes by version and by device. Customer reviews come last: they say it happens, not why.
- My developer says he cannot reproduce it: what should I do?
- Give him what he needs to replay it: the report with the device, the screen and the last actions, a phone of the same class as the customer's, a network that is cut, a full database. If the app sends no reports, that is the first thing to install; without it, everyone is guessing.
- Should the app be rebuilt?
- Rarely. When a few causes account for most of the crashes, fixing them takes far less work than a rewrite, which brings crashes of its own. A rewrite is worth discussing when the code cannot be fixed without breaking something else, or when the technology is no longer maintained; that becomes clear after two or three fixing cycles, not before.
- Do crashes lower the rating and visibility on the store?
- The rating, yes, through reviews. As for visibility, Google says that beyond its thresholds it may reduce the app's visibility on Google Play and show a warning on its store listing. A fixed version and replies to reviews let customers revise their rating.
- And on iPhone?
- The range of devices is more uniform, but the same causes exist: memory, network, unexpected data. Reports are read with the same tools, provided the symbol files of each version are kept. The method is identical: observe, rank, reproduce, fix, release in phases.
- How long does it take to stabilise an app?
- Four weeks in the example for the first three causes: one to connect reporting and read, one to rank and reproduce, one to fix, one to release in stages. The figure falls with the first fixed version; the following causes are handled at the pace of one cycle a month.
- Can you test on every phone?
- No, and there is no need. The store console gives the most common models among your customers; three or four well-chosen phones, including a modest one, plus Google Play's automatic run on its lab devices before release, cover most of it. The rest comes back through the reports.
- The app only crashes after several months of use: why?
- Because data accumulates: a local database that grows, longer lists, images kept and never deleted, storage that fills up. Hence the trial on a database filled with six months of data, not on a fresh install.