Mobile apps are becoming incredibly complex. As we ask more of these user experiences, they’re becoming increasingly data-rich and dynamic, which opens up a world of possible failure points, spanning code, device, user, and connectivity variables.

One of the most challenging types of issues to troubleshoot are performance and stability issues that stem from networking. Whether it’s discovering failures that are specific to your mobile apps, understanding a networking issue’s impact across your users, or getting to the root cause of a seemingly unrelated issue that ultimately is a networking one, it’s vital to have visibility into client-side network performance within the context of user experiences.

In this post, we’ll cover several areas where networking issues can degrade app performance and how you can proactively address poor user experiences that stem from networking issues.

Mobile network performance monitoring for surfacing issues

While your backend monitoring only alerts you on 500s, several issues — including login issues, missing product images, and purchase failures — can stem from different network failure types. Poor network connectivity can lead to connection errors and timeouts, while costly 400s can result in abandoned sessions, missed revenue opportunities, and user churn. To reduce issue resolution timelines, you need complete visibility into the health of first- and third-party network calls.

Get immediate visibility into actionable network insights

As your app grows, you will have a large number of endpoints. Your backend team can introduce changes to endpoints that the mobile team may be unaware of. You want a quick way to spot broad failures or unusual behavior in how your mobile devices process network calls.

Bubbling up key insights about network endpoint performance is crucial to eliminating noise. That way, your mobile teams can have at-a-glance visibility into the most significant contributors to slowdowns, failures, and connection errors.

Proactively address network failures that elude backend monitoring

Mobile devices have limited CPU, memory, and network bandwidth. These constraints can result in many types of client-side failures that are not easily captured by backend monitoring solutions. Your app — and, in turn, your users — can run into any number of problems, including:

  • Connection errors and timeouts – Connectivity switches, validation errors, and heavy UI processing can lead to slow or broken user experiences that your backend monitoring won’t catch.
  • Network congestion – First- and third-party SDKs can hog bandwidth, send too much data, and fire excessive network calls due to poor retry logic.
  • Slow or blocking network calls – Bloated startup times and frozen key user moments can lead to user frustration and app abandonment.

Mobile apps run compiled code on various devices, OSs, app versions, and connectivities, creating an infinite amount of variables in production. As such, there are many more ways that network calls can fail besides 400s and 500s. Understanding the exact network conditions that lead to app failures is essential to having client-side visibility.

Debug user complaints by inspecting network response bodies in production

Your mobile teams want a frictionless way to address user complaints about login issues, failed purchases, and the inability to access key app functionality. While reviewing the full technical details and user actions in the affected session is frequently enough to pinpoint the culprit, sometimes troubleshooting the issue requires the full context of the actual network call. Accessing the network request and response bodies can help solve problems like bad tokens, misconfigured payloads, and data mismatches between client and server. Note that since network bodies can easily contain PII, this data should be encrypted, captured for limited periods of time, and deleted immediately after inspection.

Spot any regression with network performance alerts

Your mobile teams need to be the first to know about network errors, but they also don’t want to be inundated with noise. With client-side network monitoring, teams can set thresholds and time windows for 4xxs, 5xxs, and connection errors that communicate when an issue demands immediate attention. With real-time visibility into spikes and vendor outages, your teams can remotely disable vendors to prevent widespread impact across your users.

In addition to failures, it’s vital that your teams get notified about network performance regressions (i.e., when network calls get slower over time). Slow endpoints can be just as bad as failing ones, as users will get frustrated with frozen screens and waiting to interact, view content, and make purchases.

Client-side network monitoring solutions can easily route alerts directly via Slack, email, or webhooks directly to the individuals and teams that can take immediate action. However, relying on backend monitoring systems can result in slower issue discovery times. Without the ability to set distinct thresholds and time windows for specific tenants, a spike in errors for certain clients (e.g. mobile devices) could nevertheless be too small across the total volume of requests to trigger an alert. In other words, the best practice is to configure alerts based on client-level performance and stability needs.

Mobile network performance monitoring for prioritizing issues

For your engineering teams to prioritize and solve issues proactively, you must know the impact that a network failure has across your user segments. For example, an issue that happens to a few users on old app versions is far less urgent than one affecting every single user on the newest version of your app. With complete visibility into every aspect of your app, from failures to slowdowns to key user moments, your teams can better invest engineering resources to solve the issues with the highest business impact.

Monitor individual network endpoints for complete visibility into failures and slowdowns

Your mobile teams can answer many key business questions with complete client-side network monitoring.

Stability regressions:

  • Are certain ad providers failing to load ads properly?
  • Are users unable to login or being unintentionally logged out?
  • Are key product images failing to load?
  • Are there failures processing purchases through certain payment providers?
  • Are users struggling to redeem rewards, coupons, or promotions?

Performance regressions:

  • Are highly-engaged users running into slowdowns when they access large amounts of content?
  • Are certain features serving unoptimized images and videos that take longer to download?
  • Are purchases taking too long to complete, resulting in canceled orders?
  • Are rideshare requests taking too long to match, causing users to abandon the session?

Instead of an APM that just shows duration or an Apdex score, you want to know the full details of where your endpoints are failing or underperforming and which users are impacted. Your teams need to be able to spot regressions through network performance alerting, so they can proactively address them.

Track key user moments to optimize high-value areas

Tracking key user moments is extremely important so your teams can identify failures and slowdowns that lead to drop-off and churn. For example, if users struggle to send a message, swipe between profiles, add items to cart, or complete purchases, they will spend less time and money within your mobile app.

Your mobile teams also need visibility into the details behind successful user interactions. For example, let’s say that your app’s startup time significantly increases for many of your users. Many of these affected users might stick around to access your mobile app. However, they then decide to use your app less frequently. Your overall usage and engagement could drop with no associated errors to pinpoint the root cause. Setting and tracking performance KPIs throughout your mobile apps allows you to spot regressions before they get out of hand.

After all, your teams want to be the first to know when users are abandoning your key moments so they can limit the revenue impact of slowdowns and failures. By creating moments to cover the steps of key user flows, your mobile team can easily identify problem areas in your funnels.

Create real-time dashboards to monitor mobile app networking performance

With access to custom real-time dashboards, mobile teams can monitor the metrics and segments they care about. For example, monetization teams can see the performance of payment vendors and ad SDKs while monitoring features like daily deals, coupons, or promotions. With this information, they can track their dashboards and easily view which areas users struggle in.

Mobile network performance monitoring for solving issues

Your mobile teams want to get to the root cause of every business-impacting issue, which is frequently impossible without complete visibility into networking. Teams need to know whether slow, failing, or blocking network calls are ultimately responsible for negative user experiences.

Many issues stem from broken endpoints that the mobile team doesn’t know about. For example, the backend team could make undocumented API changes in how payloads are constructed. Or they could deprecate an endpoint without notifying the mobile team. In addition, failing third-party SDKs with poor retry logic can cause network congestion and crashes.

With client-side network monitoring, your mobile teams can collect every network call within every session, track down the cause of any network-related issue, and know its impact on your users and business. Whether it’s a complicated crash stemming from failing network calls, a freeze caused by blocking network calls, or a frustrating user experience from downloading heavy assets, you have the information needed to fix it.

For any crash, your mobile teams want the full context behind every affected user experience, including:

  • User journey (e.g. views/screens/activities)
  • Network calls
  • Logs and breadcrumbs
  • User actions (e.g. taps and button presses)
  • Device details (e.g. CPU, memory, connectivity)

That way, whether the crash is caused by a code exception, exceeding resource limits, failing third-party vendor, or a combination of factors, your mobile team has the data needed to get to the root cause quickly.

The best way to solve any mobile app issue is to have complete session-level visibility. Instead of relying on the performance and stability of individual events, mobile teams can monitor from the perspective of user outcomes. Let’s go over a few examples of how moving from event-based monitoring to session-based monitoring can open up optimization opportunities:

  • Issues that span multiple sessions – In mobile, users frequently background and foreground apps. If the root cause of an issue began in a previous foreground session (e.g. a failed network call), you could then pinpoint why a subsequent “error-free” session resulted in a crash.
  • Solving OOMs – OOMs result from exceeding memory limits. By knowing the full details of the affected user sessions, your team can spot where your app serves heavy images, excessive images, or fails to manage memory-intensive assets like webviews properly.
  • Solving ANRs – Application not responding (ANR) issues are app freezes that ultimately cause the user to terminate the app. Slow and blocking network calls can freeze the UI for many reasons, including data-heavy UI updates, expensive database queries, and heavy processing.

Mobile has so many possible failure points that reviewing complete sessions is crucial for efficiently getting to the root cause. Knowing the behavior of individual endpoints in isolation is not enough to surface every type of negative user outcome.

Address the root cause of user frustration

Your app does not need to crash to have users get frustrated and uninstall it. There are several ways that network failures can lead to negative user outcomes that are difficult to detect with traditional crash and error monitoring:

  • Abandoned startups – Initializing too many SDKs can lead to bottlenecks when loading large amounts of data.
  • Failing third-party SDKs – Vendor outages can prevent users from accessing key functionality within your app.
  • User terminations – Frustrated users force quit mobile apps. Mobile teams can inspect these negative user experiences to see where screen freezes, failed image loads, or broken UI elements resulted in abandons.

Solving crashes that stem from networking issues is difficult, but it’s even harder to detect app abandons that stem from them. When your monitoring is user-focused instead of service-focused, you can surface every source of negative user experience.

Improve perceived performance under poor network conditions

Mobile teams must test for connectivity switches and architect their apps to handle these transitions seamlessly. Failure to notify users of adverse conditions and present an excellent offline user experience is a recipe for them to abandon your app as opposed to sticking around. For example, let’s say your app is a rideshare app that requires a heavy map download before users can request a ride. If the user loses connectivity during app startup, display a helpful dialog instead of showing them a blank screen, so the user understands the issue and will wait for better connectivity instead of jumping to a competitor’s app.

Your teams also want to limit heavy queries or data uploads/downloads when under specific connectivities. This comes down to testing what the real-world conditions of your users are. While your backend could easily respond to every request, if the client cannot process them, it’s the same outcome as if the calls were outright failing.

Summarizing the benefits of client-side network monitoring in mobile with Embrace

By monitoring your client-side network performance on mobile, you can take a proactive approach to improve response times and get ahead of issues before they affect users. With Embrace, mobile teams have complete visibility into your network calls with the ability to:

  • Trace any network calls between the user’s device and your backend.
  • See the order and timing of network calls in a session and the views in which they occurred.
  • Visualize simultaneous, parallel network calls as if from the user’s perspective and discover freezes or OOMs stemming from self-induced network congestion.
  • Review every call whether good (2xx), bad (4xx, 5xx), or really bad (a client-side error that is undetected by traditional mobile tooling).
  • Monitor network endpoints through alerts and real-time dashboards for immediate visibility into any regression.

Your mobile teams can track the health of your network and solve the most complicated crashes your app faces.

App performance can also suffer from slow or failing calls, which can directly lead to user churn and lost revenue. You need client-side network monitoring to understand many issue types that error monitoring alone cannot surface. For example, do you know everything that happens during app startup? You might have old or failing SDKs, excessive SDKs, etc. Optimize startup time and see which SDKs are firing slow or excessive network calls.

Review the complete session timeline for every user experience to understand where users get frustrated and abandon your app.

Mobile teams can eliminate guesswork and solve a much broader range of issues by understanding the user impact of failing network calls. Check out the following example of how powerful Embrace’s network monitoring is for building resilient mobile experiences.

With Embrace, you can reduce the time you spend on network problems by 100%

One of Embrace’s customers, Farm Dog, uses Embrace to eliminate crashes caused by poor network connections.

Farmers and agronomists use the Farm Dog mobile app in areas that lack good network connectivity. The Farm Dog mobile team — before using Embrace — lacked visibility into the network conditions of their users and under which circumstances those conditions caused app failures.

With the help of Embrace, Farm Dog no longer spends time debugging crashes caused by network conditions. Our network monitoring allowed Farm Dog to look up their users and see how particular network problems affected app performance. The mobile team could then simulate and reproduce these network conditions to build and test offline functionality so that loss of connectivity would not lead to app failures.

Mobile teams can use Embrace’s best-in-class client-side network monitoring to:

  • Get proactively alerted to any issues.
  • Gain visibility into users’ network conditions and the effects on the app.
  • Reproduce network conditions to build features to allow the app to function in poor network conditions.

“Embrace helped us reduce developer time spent on networking problems by 100%. We have completely eliminated user complaints and support tickets to fix broken experiences stemming from poor network connections.” Liron Brish, CEO of Farm Dog

Final thoughts

Mobile apps are increasingly delivering dynamic, data-rich experiences that must be seamless to ensure continued customer loyalty. However, the most difficult types of mobile app issues to uncover and solve are those involving slow, blocking, excessive, or failing network calls.

With Embrace’s client-side network monitoring solution, your mobile teams have complete visibility into all first- and third-party network calls. Teams can surface connection errors and timeouts, network congestion, and slow or blocking network calls. Moreover, your mobile teams can get proactively alerted to performance and stability regressions so they can be the first to know when something’s wrong.

Far beyond crashes and errors, Embrace provides the full technical details and user actions for every user session. Teams can inspect the order and timing of network calls, visualize parallel network calls, review network bodies in production, monitor the overall health of network endpoints, and so much more!

Delivering compelling mobile user experiences requires complete visibility into the impact and outcome of network failures. That way, your team can quickly identify the root cause of issues, prioritize them based on their business impact, and solve them with complete data.

If you’d like to see how complete mobile visibility can revolutionize how you deliver incredible mobile experiences, get started with a free trial today.