Your mobile teams want to focus on feature creation. That’s why you hired them, and it’s what they’re good at. And, it’s what creates value. It’s what ensures your app is relevant for your users, which drives engagement and revenue. Ideally, your mobile developers could develop new features full-time.

But in the real world, their attention is regularly pulled away to deal with app issues. Whenever your team has to deal with outages, crashes, bug fixes, or performance issues, they shift their attention away from new development until issues are resolved.

You need to proactively identify, prioritize, and solve issues as quickly as possible so you can ensure your users don’t have a bad experience and your developers can focus on moving the product forward. And, you need this process to be seamless and efficient.

It sounds simple in theory. For any issue, you just need to:

  1. Identify it: Understand what’s happening in your app, as it happens.
  2. Prioritize it: Understand whether it’s impacting enough users that you need to take immediate action.
  3. Solve it: Figure out how to fix it, and how much time that will take.

Why is this so difficult and unpredictable for mobile teams?

Improper tooling makes mobile issue identification and resolution challenging

The tooling landscape is fractured, and many teams aren’t using tools specifically built for mobile. This results in difficulties identifying, prioritizing, and solving issues.

1. It’s hard to identify issues

Teams that aren’t using tools purpose-built for mobile can’t get a complete picture of an issue. This makes it harder to understand what’s causing the problem. For example, companies using Firebase will be alerted when their apps crash. But crashes represent only 5-10% of the issues you need to be aware of and respond to quickly.

If your mobile team relies on user reports or app store reviews for issue discovery, you won’t have enough information to identify the root cause. Do any of these reviews look familiar?

  • “The app is slow.”
  • “The app freezes.”
  • “The app logged me out.”

Mobile developers trying to pinpoint the source of the issue need more context from users:

  • What app version, OS, and device were you running?
  • What view/activity did the issue occur on?
  • What actions had you taken in the app before this happened?
  • Did you lose network connectivity?

And, your mobile teams need tooling that provides coverage for every type of user-impacting issue:

  • Slow startups.
  • Abandoned or failing key user flows like video uploads, add to carts, and purchases.
  • Broken web views leading to blank screens.
  • Network calls firing out of order leading to missing content or freezes.
  • Too much memory usage leading to OOMs and system kills.

You need tooling that identifies every type of issue. Otherwise, you’ll lack visibility into areas of your app that are costing you users and revenue.

2. It’s hard to prioritize issues

Without proper tooling, it’s also hard to know exactly how many of your users are impacted by an issue, and whether it’s a big enough issue to merit pulling your developers away from feature creation. For example, it may be an issue that only impacts users on an older app version, or on old hardware devices. If they represent a sufficiently small percentage of your app userbase, it may not be worth your team’s time and efforts to focus on a fix. Here are some questions your tooling should be able to answer:

  • What is the count and percentage of users affected by the issue?
  • How does the issue affect users across different app versions?
  • What is the business impact of the issue (e.g. loss in revenue or engagement)?

There are only so many developer hours in the day, and you need to properly allocate your resources to solve issues that most impact your KPIs.

3. It’s hard to solve issues

Tools that aren’t designed specifically for mobile apps aren’t going to give you the information you need to quickly reproduce an issue. The tools might only provide you with a stack trace. You’ll need to pull in logs from elsewhere, and manually recreate a user session to trigger the issue through trial and error.

When you think you’ve identified the issue and figured out a solution, you can cut a new release and cross your fingers. If the issue is still there, you need to add more logs, then rinse and repeat.

You’ll struggle to know whether any fix will work even with testing, because it’s impossible to recreate all the possible combinations of hardware, operating systems, versions, and network conditions. You need a way to get as close to the user experience as possible without having to watch over a user’s shoulder. That way, you can see exactly what happened from both the user and the device perspective.

  • What did the user do and see before the issue occurred?
  • What technical events happened in the app (e.g. network calls, logs, view/activities)?

The result of fractured tooling is a lack of visibility into user-impacting issues, and a lack of comprehensive, actionable data needed to quickly fix issues.

Embrace provides a single source of truth for rapid identification, prioritization, and resolution

Embrace is the best-in-class observability, monitoring, and debugging platform for mobile. Mobile teams can troubleshoot issues completely within our comprehensive platform.

Faster identification of issues

With Embrace, your mobile engineers are the first to know about issues. You no longer have to rely on user reports, app store reviews, or tickets from customer support teams to know when something’s wrong.

  • With hyper-targeted alerts, you define the metric or error, the user segment, the device environment, and the properties (e.g. A/B test id, method of purchase, social login type) to create completely configurable alerts for your app.
  • With proactive alerting, you are notified of errors you wouldn’t (or couldn’t) know about. You’ll be alerted on errors you haven’t come across yet, and for bad actor third party SDKs negatively affecting your app’s performance.

Immediate prioritization of issues

With Embrace, observe how any issue affects your users and your business.

  • Get the count and percentage of users affected for any issue. Go from an individual user session or an aggregated graph of an error to see the complete list of every single user impacted.
  • Observe a release and feature by any metric, SLA, or KPI.
  • Set up Crashlytics-style dashboards to easily visualize any metric.

Solve issues faster with full session replay

With Embrace, understand exactly what led up to the issue by immediately reproducing the entire user experience.

  • We don’t sample. With access to 100% of sessions, you can reproduce any issue, even ones that affect a single user.
  • We give you all the data in one place. View user actions and technical events including network calls, views/activities, logs, taps and button presses, CPU usage, and memory.
  • We provide powerful, time-based visualizations. See the order and duration of all events so you can pinpoint the source of performance and stability issues.

Embrace simplifies the troubleshooting process with a comprehensive, predictable, and efficient workflow. This allows your mobile teams to get back to building features, driving your product forward, and creating value for your app.

How Embrace helps mobile teams

When a mobile e-commerce company struggled to solve issues using their existing tooling, they knew they needed a more comprehensive platform to help them identify, prioritize, and solve the issues affecting their users. They had a large crash that went unsolved for years — since the app’s first submission — because they lacked enough context to isolate the root cause of it. And as any engineering team knows, if you cannot identify the root cause, you cannot begin to solve it.

With Embrace, the company’s engineering team was able to:

  • Identify the root cause of the crash as a failing network call earlier in the session.
  • Prioritize it as their second-biggest crash, affecting 1% of users.
  • Solve it using Embrace’s session replay.

Without access to the technical events and user actions of individual user sessions, the mobile e-commerce company would not have been able to link the cause of the crash to a seemingly unrelated network call that happened earlier in the session. By focusing on user experiences, Embrace allows mobile teams to identify issues that reach beyond a single code exception.

Want to see how Embrace can change your mobile team’s efficiency? Request a demo and see a path to improvement immediately!