Skip to content
Mobile Apps13 min read

Why Is Your App Crashing or Running Slowly? A Founder's Diagnostic Guide

Turn crash and slowness complaints into evidence: a symptom table with where to look and who owns it, Android vitals thresholds, iOS hangs and watchdog kills.

01

Why is your app crashing or slow, and how do you find out?

Most crashes and slowdowns come from a short list of causes: unhandled errors in the code, the main thread being blocked by work that should run in the background, memory pressure on lower-end devices, a bad release or SDK update, or a slow backend. You find out which by matching what users report to the right dashboard (crash reports, Google Play's Android vitals, Xcode Organizer or your API monitoring), then breaking the numbers down by app version and device. The symptom table below does that matching for you and says who should own the fix.

This guide is for founders and product owners who cannot read a stack trace but own the consequences: one-star reviews, churn and, on Google Play, reduced visibility once the vitals thresholds are crossed. It is the diagnostic step. For the engineering fixes once you know the bottleneck, see mobile app performance optimisation.

02

Key takeaways

  • Start from the symptom, not the tool. Each complaint points to a specific report.
  • Google Play publishes thresholds: user-perceived crash rate 1.09% and ANR rate 0.47% overall, 8% per phone model. Above them, Play may reduce visibility and show a warning on the listing.
  • Only 'Input dispatching timed out' ANRs count towards Play's user-perceived ANR rate. The input timeout is 5 seconds.
  • On iOS, watchdog kills show the code 0x8badf00d, Organizer counts hangs longer than 250 ms, and MetricKit delivers diagnostics as they happen on iOS 15 and later.
  • Apple publishes no ranking penalty for crashes. App Review does reject builds that crash.
  • Crashlytics, Play and Apple count different things, so their numbers will not match.
03

Symptom triage: where to look and who owns it

Take the words from the review or support ticket, find the closest row, and ask the owner for the evidence in the 'where to look' column before anyone starts changing code.

Symptom (what users say)Where to lookLikely causeOwner
"It closes by itself"Crashlytics (or your crash tool) fatal issues; Play Console Android vitals crashes; Xcode Organizer CrashesAn unhandled exception or signal, often from unexpected dataApp developer
"It freezes, then Android asks to close it"Android vitals ANRs (only 'Input dispatching timed out' counts as user-perceived)Main thread blocked for 5 seconds or more by disk, network, locks or heavy workApp developer
"It freezes for a moment" (iPhone)Xcode Organizer Hangs; MetricKit hang diagnosticsWork on the main thread; Organizer counts unresponsive periods over 250 msApp developer
"It takes ages to open" or "closes on launch" (iPhone)Organizer Launch Time (p50 and p90); crash reports with termination code 0x8badf00dToo much work at launch; the system watchdog ending an unresponsive launchApp developer
"It stutters when I scroll"Android vitals slow and frozen frames; profiling on a lower-end deviceFrames taking longer than the display allows (16 ms at 60 fps); long lists, large imagesApp developer
"It restarts when I come back to it"MetricKit memory diagnostics; Android process death reproduced in testingMemory pressure; screen state not saved and restoredApp developer
"Only happens on my phone"Vitals per device model; crash tool filtered by device and OS versionA manufacturer- or OS-specific bug; low-RAM devicesApp developer with QA
"Started after the update"Crash-free users by app version; staged rollout data; recent SDK changesA regression in the release or an updated SDKRelease owner
"Loads forever" or "says something went wrong"API latency and error rates by endpoint; non-fatal errors in the appSlow or failing backend, timeouts, expired certificatesBackend developer
04

How bad is it? Google Play's thresholds

Google is the only platform that publishes numeric quality bars. Android vitals has two core stability metrics, user-perceived crash rate and user-perceived ANR rate, each with a bad-behaviour threshold.

MetricOverall thresholdPer phone modelWhat 'user-perceived' means
User-perceived crash rate1.09% of daily users8%Share of daily active users who had at least one crash while actively using the app (an activity showing or a foreground service running)
User-perceived ANR rate0.47% of daily users8%Currently only ANRs of type 'Input dispatching timed out'

Worth noting

Google's wording: if an app exceeds a bad-behaviour threshold, "Play may reduce the visibility of your title" and "may also show users a warning on your store listing". Above the per-device threshold, Play steers users on those devices towards other titles. Play generally evaluates the last 28 days but may act sooner after a spike.

05

What Android counts as an ANR

An ANR is triggered when an app's main (UI) thread is blocked for too long. The main trigger is not responding to an input event, such as a tap, within 5 seconds. Others include a service not finishing its start-up within a few seconds and a foreground service not calling startForeground within 5 seconds. Only the 'Input dispatching timed out' type counts towards the user-perceived ANR rate that Play uses for its threshold, although Play Console also reports the rate for all ANR types.

Slowness short of an ANR also has a definition. To render at 60 frames per second each frame must take under 16 ms. Google calls frames of 16 to 700 ms slow and 700 ms to 5 seconds frozen, and says no frame should ever take longer than 700 ms.

06

What iOS shows instead

Apple does not publish thresholds or a visibility penalty for crashes or hangs, so none should be assumed. App Review guideline 2.1 does say Apple will reject binaries that crash. For diagnosis, three sources matter.

  • Watchdog terminations. iOS runs a watchdog that monitors launch time and responsiveness and ends unresponsive apps. These terminations carry the code 0x8badf00d in the crash report's termination reason. Apple does not publish one fixed time limit, so do not rely on a number.
  • Xcode Organizer. Its hang rate is the seconds per hour the app is unresponsive, counting only periods longer than 250 ms; backtraces are captured when the main thread is unresponsive for 1 second or more. Data comes only from users who consent to share it, hang reports cover iOS and iPadOS, and low-volume apps may see 'insufficient usage data'. Launch Time shows p50 and p90 from tap to first screen.
  • MetricKit. Your app can receive the same data directly. Apple says metric reports about the previous 24 hours arrive at most once a day, and diagnostic reports (crashes, hangs, launch, CPU, memory and disk-write problems) arrive immediately on iOS 15 and later.
07

Why the numbers disagree

Firebase Crashlytics counts crash-free users as installations of the app that did not have a fatal crash over the selected period. Google Play normalises by daily users and counts only crashes during active use. Apple's data comes only from users who agreed to share it. So 99% crash-free users in Crashlytics and a crash rate near Play's threshold can both be true. Pick one source per question, and use Play's figure when the question is 'are we at risk on the store?'.

08

Crash Reporting vs Application Monitoring

Crash reportingMonitoring
CapturesFatal crashes and logged non-fatal errorsPerformance, ANRs, hangs, errors, network, release health
AnswersWhat broke and where in the code?How healthy is the app right now?
Used forDebugging specific failuresDetecting regressions and trends
SignalsStack traces, breadcrumbs, device infoCrash-free users, startup time, API latency
09

Fatal and Non-Fatal Errors

Fatal errors close the app. Non-fatal errors are caught and handled, such as a failed request with a retry message. Log important non-fatal errors too: a payment step failing gracefully for many users is as serious as a crash, and it won't show up in crash counts.

10

Stack Traces, Logs and Symbolication

A stack trace shows the sequence of calls leading to the failure. Release builds are optimised and often obfuscated, so upload dSYM files for iOS and mapping files for Android with each build to turn traces into readable code locations. Breadcrumbs, a short log of recent actions and screens, help explain how the user got there. Keep sensitive data out of logs.

11

Prioritising and Reproducing

Start from the symbolicated trace, breadcrumbs and device details. Reproduce on the same OS version and device class, using the same app build. Replicate network conditions and data states where the trace suggests them. Write a regression test once reproduced, so it stays fixed; see mobile app testing.

  • How many users and sessions are affected?
  • Does it block a core flow, signup, or payment?
  • Is it new in the latest release or growing?
  • Is it limited to specific devices, OS versions or regions, and does any device model approach Play's 8% threshold?
  • Is there a workaround users can take?
12

Release Monitoring and Staged Rollouts

Use Google Play staged rollouts and Apple phased releases for updates to release gradually. Watch crash-free rates, ANRs and key flows for the new version, and pause if metrics degrade. Feature flags let you disable a faulty feature without shipping a new build. The release management guide covers using these signals as rollout gates.

Many app problems start on the server: slow endpoints, error spikes, expired certificates. Monitor API latency and error rates alongside app metrics, and correlate them. Alert on new crash types, sudden changes in crash-free rates and API error spikes, routed to someone who can act. See mobile app API integration for client-side error handling.

13

A first-week rescue checklist

If reviews are already bad, work through this in order before commissioning a rewrite.

  • Confirm you have admin access to Play Console, App Store Connect and the crash tool in your own name.
  • Check that dSYM and mapping files are uploaded, so traces are readable.
  • Read Android vitals: overall and per-device crash and ANR rates against Google's thresholds.
  • Read Xcode Organizer: crashes, hangs and launch time for the latest versions.
  • List the top five issues by users affected, with the app version where each first appeared.
  • Pause or halt any staged rollout that introduced a new top issue.
  • Check API error rates for the same period, to separate app problems from backend ones.
  • Agree a fix order with the developer and the evidence that will show each one worked.

Not sure what your dashboards are telling you?

ZSpace Labs can review your crash, vitals and Organizer data with you and turn it into a prioritised fix list.

Start a Project
14

Hypothetical example: 'it crashes all the time'

Hypothetical example: a founder of a field-service app gets a run of one-star reviews saying the app 'crashes all the time'. The developer reports 99% crash-free users in Crashlytics and cannot reproduce the problem. Using the symptom table, the founder asks for Android vitals by device model. Overall rates are under Google's thresholds, but the user-perceived ANR rate on two older phone models is far higher, and the ANRs began with the release that moved photo uploads into the job-completion screen. The users were describing freezes, not crashes, and Crashlytics was not counting them. The fix belongs on the performance side: move the upload off the main thread. The example is illustrative and does not describe a real client.

15

Limits of This Guide

The triage table points to likely causes, not certain ones; only the evidence in the 'where to look' column confirms a diagnosis. Small apps may not have enough users for Organizer or vitals to show data, in which case reproduction on real devices and direct user reports carry more weight. Games, apps built on game engines and apps for watches, TVs or cars have different thresholds or tools (Play's watch thresholds, for example, are 4% for crashes and 5% for ANRs) and need their own checks. And if crashes are a symptom of a codebase nobody can change safely, diagnosis will keep finding new problems; at that point see mobile app maintenance and consider whether the app needs modernising.

16

Common Mistakes

  • No symbol or mapping files uploaded, so traces are unreadable
  • Treating Crashlytics crash-free users as the same number as Play's crash rate
  • Ignoring ANRs and hangs because crash counts look fine
  • Ignoring non-fatal errors in critical flows
  • Alert fatigue from noisy, unprioritised alerts
  • Releasing to everyone at once with no rollout plan
  • Personal data captured in logs and crash reports
  • No regression tests after fixing a crash
17

Beyond Crashes: Performance and Failed User Journeys

Crash-free rates miss many problems users feel: slow start-up, frozen screens, failed network requests and journeys that never complete. Mobile observability adds performance monitoring and journey tracking so teams see where users actually fail.

  • Track app start time, screen render times and frozen frames on real devices.
  • Monitor ANRs on Android and hangs on iOS.
  • Record network request failures and latency by endpoint and app version.
  • Define key journeys (sign-in, search, checkout, booking) and track completion and failure points.
  • Correlate client-side failures with backend traces where possible.
  • Break metrics down by app version, OS version, device and network type.
  • Keep personal information out of logs and traces.
18

Conclusion and Next Steps

Crashes and slowness become manageable once each complaint is tied to a dashboard, a likely cause and an owner. Start with the symptom table, check Google Play's thresholds and Xcode Organizer for your latest versions, and agree with your developer what evidence will show each fix worked. Send the performance fixes to the performance optimisation guide, make the weekly review part of ongoing app maintenance, and track the effect on retention in mobile app analytics.

Want a second opinion on your app's stability?

ZSpace Labs is a remote-first technology studio that works with clients globally on mobile app development. If useful, we can talk through a stability and performance review of your crash, vitals and Organizer data.

Start a Project
19

Sources

Google: Android vitals (updated 9 October 2026); Play Console Help: monitor your app's technical quality with Android vitals; Play Console: crash rate; Play Console: ANR rate; Android Developers: ANRs; Android Developers: slow rendering.

Apple: Addressing watchdog terminations; Analyzing responsiveness issues in your shipping app; Reducing your app's launch time; MetricKit; App Review Guidelines.

Vendor documentation: Firebase Crashlytics: crash-free metrics.

Accessed 15 October 2026. Thresholds, console reports and policies change; check the current pages before relying on a figure.

FAQ

Common questions.

Common causes include unhandled exceptions, null or unexpected data from APIs, memory pressure, threading issues, OS version differences, device-specific behaviour and bugs in third-party SDKs.

Crash reporting captures details when the app fails. Monitoring tracks broader health continuously: performance, errors, API latency, ANRs and release quality.

An error the app catches and recovers from, such as a failed API call handled gracefully. Logging these reveals problems that don't crash the app but still hurt users.

Converting machine addresses or obfuscated names in a crash stack trace back into readable file names, functions and line numbers, using dSYM files on iOS and mapping files on Android.

The share of users who didn't experience a crash in a period. In Firebase Crashlytics a 'user' is an installation of the app on a device and only fatal crashes count, so the figure will not match Google Play's crash rate, which is based on daily users. Crash-free sessions measures the same thing per session.

Application Not Responding: on Android, an error triggered when the app's main thread is blocked for too long, for example when it does not respond to an input event within 5 seconds. Google Play's user-perceived ANR rate currently counts only ANRs of the type 'Input dispatching timed out'.

By the number of users affected, severity (does it block a core flow or payment?), trend (new or growing), and which app versions and devices are involved.

Releasing to a small percentage of users first lets you spot new crashes before everyone is affected, then pause or fix before expanding.

Only what's needed to debug, and no sensitive personal data. Review what your crash SDK captures and disclose it in store privacy declarations.

Start-up time, slow and frozen screens, Android ANRs and iOS hangs, network failures and latency by endpoint, and completion of key journeys such as sign-in and checkout, broken down by app version, OS, device and network. These catch problems users feel that crash reports miss.

Apple publishes no ranking or visibility penalty for crashes or hangs, so we do not assume one. What Apple does state is that App Review rejects binaries that crash. Google is different: Play says it may reduce the visibility of apps that exceed its Android vitals thresholds.

Because it probably does. Many crashes and freezes depend on a specific device model, OS version, low memory, a slow network or data that only exists in production. The answer is production data broken down by device and version, not a test on one phone.

Get in touch

Have a project in mind?

Whether you're building a new digital product, improving an existing website, or looking to automate part of your business — let's talk.