Nothing destroys the user experience faster than a crash. In fact, researchers found that 62% of people uninstall an app after they experience a crash, freeze, or any errors. As a result, most experts recommend a crash rate of less than 1% per user, less than 0.1% per session, and less than 0.01% per screen.
Let’s look at mobile crashes and strategies you can use to identify and fix them quickly before they impact many users.
62% of people uninstall an app after experiencing a crash – here’s how you can lower your crash rate and keep users happier!
Mobile crashes occur when an error or exception causes an app to become unresponsive or unexpectedly close. Often, these performance issues cause bad reviews, uninstalls, or abandoned transactions that can negatively impact the bottom line. As a result, it’s essential to diagnose and fix the causes of mobile crashes quickly.
The most common user-facing symptoms include:
Under the hood, many different factors can lead to mobile crashes. For instance, a third-party API may suddenly change, or you may forget to handle a specific exception type.
Some common causes of mobile crashes include:
Fortunately, there are several strategies that you can use to minimize the chances of a mobile crash affecting your users.
Most smartphone users have seen popups asking if they want to share crash reports and diagnostics. As a developer, you can see detailed crash reports from users agreeing to share them. You can also collect crash data using third-party libraries bundled with your app binary, such as BugSnag’s CocoaPods or Carthage libraries for iOS.
Most crash reports contain exception information showing how the app crashed (e.g., a particular line of code or error type) and a backtrace that shows what code the thread was executing at the time of the crash. However, third-party libraries make searching and filtering crash data easier and provide broader coverage.
Developers can use the exception and backtrace to identify the root cause of a crash. For example, a frame in a backtrace of an iOS app suggests a particular feature was in use, so you can determine how the exception type relates to that feature. Or, you can look at what parts of the app use the thread and functions in the backtrace.
Most software businesses offer iOS and Android apps, making it challenging to aggregate errors in one location and route them to the correct team members. After all, sending every error to the entire team is a quick way to induce notification fatigue. And consolidated error tracking makes it easier for leaders to see the big picture.
BugSnag offers native integrations with Android and iOS, collecting crash data from across your organization. In addition, the platform has a React Native library for cross-platform development. That way, the entire team can access error reporting from the same source, and leaders can track aggregate quality and performance statistics.
But, unlike other platforms providing these capabilities, BugSnag offers a personalized view of app errors. Developers can easily search and segment by error source (e.g., iOS and Android) and error attribute. Then, they can configure custom alerts to avoid spamming the entire team with every error and deliver actionable items to each team member.
Many software organizations struggle to balance bug fixing with new feature development – and mobile apps are no exception. While you should always fix an error that impacts every user, it’s less obvious when to step in and fix errors that only affect a handful of users.
A simple metric can help solve these problems and simplify your decisions: The percentage of crash-free user sessions. If most users aren’t having issues, you’re better off developing new features to keep them happy and engaged. But, if too many users are having problems, it’s often worth a look under the hood.
BugSnag’s Stability Center incorporates this metric – the Stability Score – into a single dashboard, enabling your team to make fast, data-driven decisions. You can even create different Stability Scores for different releases and set custom targets based on Service Level Agreements or other guidelines relevant to your business.
Most developers recognize that every error isn’t worth fixing. Without prioritizing errors, it’s impossible to efficiently balance troubleshooting bugs with developing new features.
The most common way to prioritize bugs involves using a simple prioritization matrix with effort on the X-axis and impact on the Y-axis. Developers estimate effort and customer-facing teams determine impact. Plotting bugs on the matrix makes it easier to differentiate quick wins from thankless tasks that won’t generate value.
Error monitoring solutions like BugSnag can leverage real-time data to drive these decisions. For example, BugSnag sorts errors by the number of occurrences and the number of users impacted, enabling development teams to focus on the problems with the most significant impact on application stability and customer success.
In addition, BugSnag lets you define VIP users or other error segments where a small number of errors could have a disproportionately severe impact. Then, by creating alerts for these errors, you can quickly fix them and cover essential use cases that you might miss otherwise.
Mobile crashes occur for many reasons and may negatively impact the user experience significantly. Fortunately, BugSnag can help proactively monitor for crashes, enabling you to fix them before they affect a large number of users. At the same time, you can efficiently balance fixing bugs with new feature development.