Businesses that depend on a flawless mobile experience traditionally rely on crash reporting and performance 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 sampling 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 observability. This allows you to drill down to every session and know exactly how your mobile app is performing.
In this post, we’ll discuss how a mobile-first solution like Embrace is crucial for improving various aspects of your mobile app's performance.
Startup time measures how long a user has to wait after launching an app before they can interact with it.
Startup time is extremely important because if your app doesn't open quickly enough, users will leave it and go to a different app instead. For example, if you need an Uber but the app is taking too long to open, you'll likely immediately switch to Lyft.
This is also a problem 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.
Ideally, aim for a startup time that is under two seconds.
Unfortunately, achieving this startup time is difficult because there are a number of reasons why your startup time may be slow. With a traditional performance tool, you'll usually know that it's slow, but you won't be able to see why it's slow.
With Embrace, we can show you exactly what is causing the delay.
For example, we 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 performance monitoring tools help with startup time, most of them only show the number of network calls that fired and how long they took to complete. However, they don't show any true duration metrics of when users could begin interacting with the app.
With Embrace, we show the complete technical and behavioral details of the entire session, including startup. For example, you can see if one network call blocks another network call and how many seconds passed before the user tapped a button.
In addition, you can view every single startup and sort by startup duration thresholds (e.g., all startups over four seconds).
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.
To learn more about improving mobile app startup time, check out our eBook, Rev Up Your Mobile App Startup Time.
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 are not able to purchase the item
You've probably experienced the second issue at some point. You add an item to checkout, but when you click purchase, it either stalls or fails. Therefore, you'll either choose to abandon the cart 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 were consistently abandoning about 1% of shopping carts.
With a traditional performance monitoring tool, they'd likely be able to see that their abandoned cart rate is high. However, it wouldn't provide any context to solve the issue.
However, because they use Embrace, they could track every session where a cart was abandoned to look for patterns. They added incremental logs to build up visibility into how the state of abandoned carts differed from those resulting in successful purchases.
Through these logs, they discovered that whenever an item with a quantity of zero 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 that was costing the company thousands of dollars.
Without access to high-fidelity data for every session, identifying root causes through comparing good and bad sessions is incredibly difficult, if not impossible. 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.
New Market Network Conditions
As your mobile app gains popularity, expanding to new regions will be part of your growth. Unfortunately, in addition to planning a launch for an entirely different culture, there will also be plenty of new technical variables that you've never dealt with before.
For example, one of our customers is a dating app that was 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.
Unfortunately, most performance monitoring tools provide only aggregate metrics. Therefore, you can't drill down to understand how the app performs in a specific region. Given that their American user base is much larger than their initial Indian user base, this was a major issue for this particular dating app. For example, their startup time might be 15 seconds for all Indian users, but if Indian users only make up 1% of their total user base, the data in the performance 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).
The mobile team was able to create comparison dashboards for every metric (OOM rate, startup time, crash rate, etc.) between the United States and India.
Armed with this information, they could diagnoses issues based on the different conditions of these two user segments, such as:
- Older devices in the Indian versus American user base
- Worse network infrastructure and connectivity in the Indian versus American user base
In other words, by seeing where app performance is affected across different devices and connectivities, they could make informed decisions surrounding whether to build local infrastructure in India or how to architect the app to account for local resource constraints.
In addition, Embrace provides real-time data so that mobile teams can see errors the instant they occur. This is crucial for monitoring new releases and pausing rollouts when they inadvertently introduce new issues. After all, going wide with a single bad release can compromise adoption in a new region entirely.
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, the e-commerce store Wish had several users complaining about crashes, though their crash rate was very good.
However, when Wish started using Embrace, they realized that their OOM-free rate was between 96 and 97% (very poor). When compared to a crash-free rate of 99%, that means Wish users were actually experiencing 3-4x more crashes than the mobile team knew about.
Embrace helps solve OOMs by surfacing where OOMs are disproportionately affecting certain screens in the mobile app. For example, if a certain 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).
This helped the e-commerce store, Wish, raise their OOM score to 99.6%. If you’d like to learn more, you can check out our Wish case study.
If you scroll through reviews and notice many customers complaining about the screen freezing, stuttering, or even crashing, your issue may be ANRs (application not responding). ANRs occur when the application's main thread is blocked, making the user unable to tap, scroll, or otherwise interact with the app.
Traditional crash reporting tools display ANR data from the Google Play Console. The problem is that Google Play Console doesn’t classify a frozen experience as an ANR until the user is greeted with a prompt to terminate the app. This doesn’t happen until the main thread is blocked for at least 5 seconds.
If users force quit frozen apps before seeing the prompt, mobile teams do not 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.
To uncover every area in the mobile app that is slow or failing, mobile teams need high-fidelity data for individual sessions. That's where mobile observability and Embrace come in. We approach ANRs differently from traditional monitoring solutions in that we begin capturing stack traces as soon as the main thread is blocked for 1 second. This allows you to investigate ANR data along many different criteria:
- Inspect ANR Intervals (where the app eventually recovered) or ANR Exits (where the user force quit the app)
- Group by the first sample (i.e. stack trace) or the last sample collected for a given ANR
- Filter 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.
One of our customers, Kumu, is an excellent example of why observability is essential to improving mobile app performance.
They are a social media platform with a large user base in The Philippines, and while they knew that they had an issue with ANRs, their previous tool (Crashlytics) didn't provide data on what caused the ANR. For example, the mobile team wouldn't know if the problem stemmed from poor internet connection or an error with the application itself. Without this knowledge, they struggled to fix these issues.
Therefore, they switched to Embrace. With access to each session and detailed ANR data, it was easy to see which ANRs they were responsible for and should therefore fix, as well as which ANRs were out of their control.
As Andrew Pineda, their Cofounder and Chief Architect, says, "When we look up a user in the Embrace dashboard, we can see if the problem is out of our control. If a user had no network connectivity, we don't need to investigate further. But if there is an issue that needs further attention, the developer can immediately reproduce the session and diagnose the problem."
If you’d like to learn more, you can check out our Kumu case study.
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 median startup time ballooning from 1.9 to 3.2 seconds.
By inspecting individual user sessions, the mobile team realized these new ANRs were happening during app launch. By reviewing that part of the codebase, they discovered blocking code that caused delays in completing startup.
The company experienced a 13% decrease in mobile app revenue during the affected period of time. With Embrace, they were able to quickly identify and fix the regression, reclaiming millions of dollars in lost revenue.
POS Memory Issues
While we already discussed how e-commerce platforms struggle with OOMs, POS systems struggle with a different type of memory issue.
Rather than dealing with large media files, they typically contend with long session durations. For example, POS systems at sporting or entertainment venues must run flawlessly for several hours, if not days.
Unfortunately, most performance 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 issues with the POS system. These issues can range from slowdowns and freezes to crashes.
Embrace recognized this as a major issue and built a solution that allows you to manually end sessions at a given time. For example, one of our clients (a POS system) ends each session after a purchase is made. This allows Embrace to collect and send data in smaller batches, so instead of a single six-hour session, there might be 400 individual sessions.
These shorter sessions limit the app’s exposure to memory leaks that build up over time. As Embrace is purpose-built for mobile, our platform collects data efficiently and responsibly, creating the absolute minimum impact on the mobile app's performance.
Webviews are essentially pages from your website loaded within the mobile app. Therefore, because they aren't natively coded into the app, it's very difficult for performance monitoring tools to address issues.
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 otherwise 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 to 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.
Embrace helps mobile teams by detecting webview failures and automatically reloading them when appropriate. That way, the user can pick up easily where they left off with minimal disruption.
For example, one of our clients is a coupon company that offers deals on various products. The mobile app loads individual products inside separate webviews. If a webview fails, the user is faced with a white box, and it would be highly unlikely that the user would purchase anything.
So using Embrace, they turned on the feature to automatically reload webviews, and their customers can now seamlessly shop despite temporary webview failures.
User Flow Dropoff
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, bad UI/UX).
For example, one of our clients is a contractor app. Within the mobile app, contractors can accept a job, provide status updates, and file for payment.
With a traditional performance monitoring tool, it would be very difficult to track and diagnose user flow dropoff 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 is not going to 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 step, the mobile team lacked visibility into previous foreground sessions. In other words, they could not determine if the problem stemmed during 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.
When the mobile team in question started working with Embrace, the dropoff rate in the app was 60%. With Embrace, they were able to drill down into individual experiences in the app and discover failure points. They uncovered the reasons why contractors struggled to complete certain steps (e.g. bad network connectivity, difficult UI) and provided fixes to alleviate these poor user experiences. In addition, they discovered that contractors were able to 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.
Improve Your Mobile App’s Performance Today
Mobile tooling has come a long way in the past few years. For mobile teams that rely on traditional crash reporting and performance monitoring solutions, there is a ceiling to the visibility and insights they can provide.
That’s why the founders of Embrace set out to build a more powerful platform for mobile teams.
Embrace is a mobile data platform that provides observability, debugging, and proactive alerting for mobile teams. We are a comprehensive solution that fully reproduces every user experience from every single session. Your team gets the data it needs to proactively identify, prioritize, and solve any issue that’s costing you users or revenue.