Editor’s Note: This post was originally published on Aug. 2, 2021, and updated on Dec. 6, 2022, to ensure all content and links are up to date and accurate.
According to a recent report by Dimensional Research, 49% of users expect apps to start in two seconds or less, and 80% would give a poorly performing app three or fewer chances before uninstalling it. Researchers also found that 69% of users said that poor app experiences lower their opinions of the company that created it.
Businesses that depend on a flawless mobile experience traditionally rely on crash reporting and mobile app monitoring tools. However, despite many improvements in these tools, mobile teams still frequently encounter issues that leave them mystified.
The problem stems from a lack of data. For example, most performance monitoring tools only show a sample of data, so you can’t drill down to inspect high-fidelity data from individual user sessions.
That’s why we built a mobile data platform that provides application observability. This allows you to drill down to every session and know exactly how your mobile app performs.
In this post, we’ll discuss how mobile-first solutions like Embrace — ones that can provide full observability — are crucial to improving your app’s performance. To do that, we’ll touch on seven different areas of your app that can be significantly improved with the data provided by a mobile observability platform, including:
- Startup time
- User drop-off
- Memory management
- Rendering time
- Webview issues
- User flows
Startup time measures how long a user has to wait after launching an app before they can interact with it.
Issues that delay your app’s startup time can significantly impact your engagement and business metrics. This problem is exasperated because about 25% of users abandon mobile apps after the initial experience. That means you frequently have one shot to dazzle them or risk losing them as a customer forever.
Startup time is a crucial moment in user engagement, it’s their first interaction with your app, and many users will leave if it takes too long to launch. Mobile app users tend to be impatient, with 49% expecting apps to launch in two seconds or less.
Unfortunately, achieving this startup time is difficult because there are several reasons why your startup time may be slow. With a traditional mobile app monitoring tool, you’ll usually know that it’s slow, but you won’t be able to see why it’s slow.
With tools that provide mobile observability you can see precisely what is causing the delay.
Embrace, for example, helped a banking app learn that they had an abysmal startup time of 16 seconds. But even better, we helped them uncover the culprit. They were initializing an excessive number of ads and analytics SDKs at startup that were blocking first-party network calls. In other words, users couldn’t interact with the app because third-party SDKs were blocking resources that the mobile app needed to finish loading.
The company was able to remove unneeded SDKs and delay the initialization of others until later, allowing users to interact with the app faster.
While some mobile application monitoring tools help with startup time, most only show the number of network calls that fired and how long they took to complete. Unfortunately, they don’t offer any true duration metrics of when users could begin interacting with the app, which is a key piece of information needed when resolving these sorts of issues.
Mobile observability solutions, on the other hand, are capable of showing an entire session’s technical and behavioral details, including startup time. For example, with Embrace, you can see if one network call blocks another network call and how many seconds passed before the user tapped a button.
With this data, you’ll have a much more accurate overview of the app’s performance from the user’s perspective, and the mobile team can quickly and easily diagnose the issue.
In addition to monitoring how your app performs for users, it’s also essential to understand how they are actually using it. By capturing user action data — such as taps, scrolls, inputs, and viewing transitions — you can begin to understand user behavior and observe which workflows might be causing users to drop-off. This is especially helpful in e-commerce apps, where users may abandon carts for numerous reasons.
There are two main reasons why someone might abandon their cart:
- They decide they no longer want to purchase the item.
- The app stalls, and they cannot purchase the item.
You’ve probably experienced the second issue at some point. You add an item to checkout, but it either stalls or fails when you click to purchase. Therefore, you’ll either choose to, or are forced to, abandon the cart.
So if the company sees a spike in abandoned carts, the mobile team needs to jump in and investigate.
For example, one of our customers is a grocery shopping app. Their mobile team noticed that users consistently abandoned about 1% of shopping carts.
With a traditional mobile app monitoring tool, they’d likely be able to see that their abandoned cart rate is high. That said, it wouldn’t provide any context to help solve the issue.
However, because they use Embrace to get in-depth insights, they could track every session where a cart was abandoned, helping them identify patterns in the behavior. They added incremental logs to determine how the state of abandoned carts differed from those resulting in successful purchases.
Through these logs, they discovered that whenever an item with zero quantity was added to the cart, the entire cart was emptied. The QA team could then easily reproduce the issue and prove that it was indeed causing the abandoned carts. Mobile engineers located the bad logic in the code and put out a fix. This removed an ongoing source of lost revenue, saving the company thousands of dollars.
With that in mind, identifying root causes of an issue by comparing good and bad sessions is incredibly difficult, if not impossible, without access to high-fidelity data like this, for every session. As illustrated above, an abandoned cart is a user action that can result from a technical error that isn’t immediately obvious. Without the ability to dive in and investigate the technical details of every session, mobile teams frequently resort to guessing at the source of issues.
With Embrace, mobile teams can track the performance of key user flows and see the speed, failure, and abandonment of each step in the process. This opens up avenues for optimization that traditional error monitoring solutions cannot tap into.
The ability to segment user experiences along dimensions like timing and abandonment empowers mobile teams to identify and solve a broader range of revenue-impacting issues.
As mobile apps gain popularity, expanding to new regions is a logical part of growth. Unfortunately, in addition to planning a launch for an entirely different culture, there will also be plenty of new technical variables you’ve likely never dealt with before. You need insight into how your app performs from your users’ point of view with a breakdown of trace and network data into dimensions like:
- App version.
- Network type.
This data is tremendously helpful if your mobile app monitoring tool can provide it. Unfortunately, most mobile application monitoring tools provide only aggregate metrics.
As an example of what can be achieved with higher-fidelity data, consider one of Embrace’s customers, a dating app, planning an expansion into India. While the app performed well in the United States, they weren’t sure how it would perform in India as all of their servers are located in the United States.
Given that their American userbase is much larger than their initial Indian userbase, this was a significant issue for this dating app. For example, their startup time might be 15 seconds for all Indian users. Still, if Indian users only make up 1% of their total userbase, the data in the monitoring tool wouldn’t reveal this cross-regional difference.
This is where Embrace differs as we allow you to track and compare metrics (like startup time) based on the user segments you care about (e.g., country, device, OS, custom groupings).
In the example above, our customer’s mobile team created comparison dashboards for every metric (OOM rate, startup time, crash rate, etc.) between their United States and Indian userbases.
Armed with this information, they could diagnose issues based on the different conditions of these two user segments, such as:
- Older devices in the Indian versus American userbase.
- Worse network infrastructure and connectivity in the Indian versus American userbase.
In other words, by seeing where app performance is affected across different devices and regions, they could make informed decisions surrounding whether or not to build local infrastructure in India and how to architect their app to account for local resource constraints.
There are two major memory management issues a mobile observability platform like Embrace can help provide better data on: out-of-memory (OOM) issues and memory leaks.
If you’ve ever had an issue where customers complain that your app is crashing, yet your crash rate is nearly perfect, you might have a poor out-of-memory (OOM) rate. An OOM is when the app crashes due to exceeding OS limits for memory usage. To a user, an OOM is the same experience as a crash, yet most crash reporting tools pay little attention to them.
For example, a customer of ours had several users complaining about crashes, though their crash rate was excellent.
However, when this customer started using Embrace, they realized that their OOM-free rate was between 96%-97% (very poor). Compared to a crash-free rate of 99%, users were experiencing 3-4x more crashes than the mobile team knew about.
Platforms that provide mobile observability, like Embrace, help solve OOMs by surfacing where OOMs disproportionately affect certain mobile app screens. For example, if a particular product screen has 50% of the OOMs yet is only the final screen on 5% of all sessions, the mobile team can investigate that screen to look for heavy system resource usage (e.g., loading or processing too many images, videos, or webviews).
While e-commerce platforms struggle with OOMs, point-of-service (POS) systems struggle with what are known as memory leaks.
Rather than dealing with large media files, they typically contend with long session durations. For example, entertainment-venue POS systems must run flawlessly for several hours, if not days, at a time.
Unfortunately, most mobile app monitoring tools run into issues with memory leaks. For example, if a session is six hours long and a memory leak occurs, that will eventually cause problems with the POS system. These issues can range from slowdowns and freezes to crashes.
Mobile observability platforms have the benefit of these sorts of insights and have been able to engineer built-in solutions to common problems like these.
For example, Embrace recognized the POS memory leak problem as a significant issue and built a solution allowing users to end a session manually, at a given time. For example, one of our clients (a POS system) ends each session after making a purchase. This allows Embrace to collect and send data in smaller batches, so instead of a single six-hour session, there might be 400 individual, and significantly shorter, sessions.
These shorter sessions limit the app’s exposure to memory leaks that build up over time. Embrace is purpose-built for mobile, so our platform collects data efficiently and responsibly, creating the absolute minimum impact on the mobile app’s performance.
If you scroll through app store reviews and notice many customers complaining about the screen freezing, stuttering, or even crashing, your issue may be Application Not Responding issues, better known as ANRs. ANRs occur when the application’s main thread is blocked, making the user unable to tap, scroll, or interact with the app.
Both Android and iOS detect excessively slow rendering frames. Google defines a frozen frame as a UI frame that takes longer than 700 ms to render. If a frozen frame extends beyond five seconds, Android will flag it as an ANR error, and a dialog box will pop up, allowing users to kill the app. According to Google, app developers should try to make their apps exhibit ANRs in less than 0.47 percent of daily sessions.
Unlike Android, rather than triggering an ANR for even longer freezes, iOS will crash your app. Thus, it’s essential to make sure your iOS apps lag as little as possible.
Unfortunately, if users force quit frozen apps before seeing the prompt, mobile teams using lesser mobile app monitoring tools won’t have visibility into poor experiences that lead to churn. The same goes for when users abandon mobile apps that frequently stutter for a few seconds.
Mobile teams need high-fidelity data for individual sessions to uncover every area in the mobile app that is slow or failing. That’s where mobile app observability platforms like Embrace come in. For example, Embrace approaches ANRs differently from traditional monitoring solutions in that we capture stack traces as soon as the main thread is blocked for 1 second. This allows you to investigate ANR data along many different criteria, such as:
- Inspecting ANR Intervals (where the app eventually recovered) or ANR Exits (where the user force quit the app).
- Grouping by the first sample (i.e., stack trace) or the last sample collected for a given ANR.
- Filtering for specific ANR durations.
Embrace provides a more holistic approach to identifying ANRs, which allows you to uncover and solve a broader range of issues that leave users unable to interact within the mobile app.
Access to a tool with robust ANR data is also crucial for monitoring new releases. For example, one of our customers is a Fortune 500 e-commerce company, and they had an issue with ANRs spiking in a new release. This resulted in the median startup time ballooning from 1.9 to 3.2 seconds, a 68% increase.
By inspecting individual user sessions, the mobile team realized these new ANRs were happening during the app launch. Reviewing that part of the codebase, they discovered blocking code that caused delays in completing the startup.
The company experienced a 13% decrease in mobile app revenue during the affected period of time. With Embrace, they quickly identified and fixed the regression, reclaiming millions of dollars in lost revenue.
Webviews are essentially pages from your website loaded within the mobile app. Therefore, it’s challenging for mobile application monitoring tools to address issues because they aren’t natively coded into the app.
What’s worse, failing webviews provide a very frustrating user experience. The user is presented with a blank screen with no way to reload or take action. If an e-commerce platform loads products inside individual webviews, a user could face a screen with actual product images interspersed with blank boxes. If the checkout and purchase flows are contained within webviews, a user could go through the trouble of adding items to a cart before ending up at a blank screen. Faced with the decision of force quitting and starting the process over, they may very well switch to a competitor’s app.
Platforms that provide high-fidelity observability data help mobile teams detect webview failures and automatically reload them when appropriate. That way, the user can easily pick up where they left off with minimal disruption.
For example, customers using Embrace were facing an Android System Webview issue. They were alerted of a crash spike, and were able to inspect the user sessions to immediately pinpoint the root cause as a failing webview. Being able to immediately reproduce every user session on-demand empowers mobile teams to detect and fix a much larger range of issues than traditional monitoring solutions.
So while webviews have traditionally been a black box in mobile applications, mobile application monitoring tools are here to change that, built to provide you with the data to uncover and solve every user-impacting issue.
Another issue you might encounter with your app is that users start an interaction but don’t complete it. Unfortunately, the mobile team won’t know whether it is because of a technical error or product issue (e.g., users don’t like the feature or bad UI/UX).
For example, one of our clients is a contractor app. The mobile app allows contractors to accept jobs, provide status updates, and file for payment.
With a traditional mobile app monitoring tool, it would be very difficult to track and diagnose user flow drop-off for two reasons:
- Traditional tooling collects individual events instead of complete sessions.
- The user flow in question has several steps that span several foreground sessions.
A contractor will not keep the mobile app in the foreground for several hours at a time. They will launch the app only to complete individual steps. When an issue occurred during a later stage, the mobile team lacked visibility into previous foreground sessions. In other words, they could not determine if the problem stemmed from an earlier part of the user flow.
However, Embrace provides high-fidelity data from every user session and stitches together sessions into unified experiences. That way, mobile teams can examine the steps a user took in a given user flow, regardless of how many foreground sessions it spans — data that would be impossible to provide through more traditional tooling.
When the mobile team started working with Embrace, they had a 60% dropoff rate. With Embrace, they could drill down into individual experiences in the app and discover failure points. They uncovered why contractors struggled to complete certain steps (e.g., bad network connectivity, complicated UI) and provided fixes to alleviate these poor user experiences. In addition, they discovered that contractors could complete the steps out of order, which led to odd bugs. They refactored the code to prevent these scenarios and streamline the overall mobile experience, which would never have been possible without mobile observability data.
Observability is crucial
As mobile apps become more sophisticated, the tools we use to monitor and improve their performance need to keep pace. For app developers that care about growth, customer experience, efficiency, and risk management, it’s not enough to continue to rely on free tools or a patchwork of cheaper solutions that only get you part of the information you need to solve your problems.
The truth of the matter is, traditional app performance monitoring tools can only provide a partial insight on your app’s most important vitals, from startup time to user flows.
On the other hand, platforms that can provide high-fidelity observability data, can give developers all the information they need to identify, prioritize, and quickly solve any issue their app might face.
Embrace provides these capabilities in a single platform, empowering your organization to remediate issues before they wreak havoc. Learn how Embrace can help you improve your mobile app by requesting a demo, today.