Your mobile data is vast, dynamic, and key to creating a harmonious user experience. While crash reporting and error monitoring are important parts of understanding the user experience, they’re far from the be-all and end-all of the information needed to make informed decisions. It’s difficult to solve the toughest issues in mobile without all the pertinent information. Even still, some issues will elude detection unless you have complete visibility into the entire user experience.

Mobile app user experiences frequently span multiple foreground sessions. Tracking down the source of issues requires visibility far beyond individual app launches, or the data that is provided to developers when an app is being actively used. Mobile teams need to review complex technical interactions that occur over time and within different sessions — like when an app is inactive, but running in the background — in order to understand complete user experiences. This is where a stitched session can make all the difference.

In this post, we’ll cover:

  • What is a stitched session?
  • What issues can you solve with stitched sessions?
  • Why do mobile teams need stitched sessions?

What is a stitched session?

A stitched session is a clear view of multiple user sessions, “stitched” together for easier analysis. This includes the moments where the app is in the foreground — but also the moments where the app is backgrounded by a user before coming back to the foreground. At Embrace, we stitch together sessions that are within five minutes of one another to represent the entirety of a user experience, thus creating a “stitched session.”

Stitched sessions are valuable because they show you the entirety of a user journey and make you aware of problems that occurred outside of the current session. This gives your mobile team the power to problem solve at a faster pace with better accuracy. More importantly, it allows you to be proactive, propelling you ahead of user-facing issues.

The flag in the second session indicates an issue. The session above shows four foreground user sessions stitched together. The flag shown in one of the sessions indicates an issue. Embrace’s tooling allows your mobile team to delve in further using the session details. These session details include the following key items:

  • Issues
  • User ID
  • App version

The session details also include other vital information, as shown under “Selected Session Details” in the image above.

Your team also has the ability to filter based on these attributes in the Embrace dashboard. Just this information alone empowers your mobile team to analyze the various factors at play throughout different user sessions, how they connect, and how sessions impact each other. This leads to faster problem-solving for your mobile teams.

What issues can you solve with stitched sessions?

A stitched session allows you to solve a new set of complex problems your users might face. Below, we will discuss a few problems that you can solve by utilizing the power of a stitched session:

Previous failures resulting in dead-ends or crashes

It’s common for a user to use your app, experience a failure, background the app, open it again, and have the previous failure result in a dead-end or crash in the current session. If your mobile team can’t get the full session context through the power of a stitched session, then they’ll likely waste valuable time searching for answers in the present session when the solution lies in the previous one.


The session above shows a fifteen-part stitched session that includes two issues. Having the full session context allows your mobile team to understand the frustrations that led to the user termination and the issues that caused the crash. Your team can analyze even further with the details of the session timeline.

The session timeline provides rich information including error logs like the one above (shown by the vertical red lines) alongside showing the slow network calls (shown by the horizontal yellow lines). You can also track behavioral indicators like screen taps and get insight into other valuable information like connectivity switches and low memory warnings. All these factors help your team discover the source of a crash.

You can delve even further into the details of the session timeline to view stack traces. These stack traces are key in determining the source of errors that result in disastrous user experiences, like crashes.

Debugging issues that span multiple sessions

Sometimes the issue your mobile team is attempting to debug is elusive because the team is tirelessly searching for the answer in the current session while it actually lies in a previous one. It’s all too common for issues that require debugging to span multiple sessions. When this occurs, a stitched session is the ally your mobile team needs.

Stitched sessions align all the sessions your user has experienced so that you can easily detect persistent issues and running themes. This eliminates the time sink of hunting through multiple sessions just to find the source of a common issue.

the session timeline and details of session one of four in a stitched session.

The photo above shows four distinct foreground user sessions stitched together. The flag in two of the segments denotes an issue and the furthest phone symbol highlighted below under the “Issues” heading indicates that the issue encountered is an ANR.

Having all these sessions stitched together gives your mobile team the full picture. From here, they can see that this user runs into two consecutive ANRs. Stitched sessions differentiate between several causes of an ANR. This includes scenarios like:

  • The user has a long session that resulted in a frozen screen. Then they relaunch the app and head to that screen only to get the same outcome. On subsequent launches, they simply ignore that screen. This is how your team can discover a technical failure in a feature.
  • The user has a great experience only to lose connectivity at the end of a long session. The poor connectivity is not handled by the app well, causing it to freeze. The user quits the app and relaunches only to encounter the frozen screen again. The user instead waits until they have Wi-Fi to use the app. This could highlight that your app doesn’t provide a good offline experience.

Further filtering through these factors alongside an in-depth view of the session timeline results in faster resolutions to ANR issues that would otherwise turn users away, potentially tanking your Google Play Store rating.

Login issues

The insight that a stitched session provides is great for one-time password (OTP) login issues. This is because login issues inherently require the user to exit and re-enter the app to fetch the OTP from their email.

If there is an issue with this process, it will drastically affect your user retention, so solving it quickly is integral. A few examples might include:

  • When the user requests an OTP, the app isn’t successfully sending the request to your backend.
  • When the user enters the OTP into the mobile app, they end up in a stuck state and cannot access the app.
  • When the user enters the proper OTP the app becomes stuck on the login screen erroneously informing the user that the login information is incorrect.

A stitched session allows your mobile team the full insight they need to spot the login issue, understand the prior session context, and solve the problem with ease.

Logout issues

Logout issues are detrimental to any app. In practice, these issues look like this:

  • A user getting kicked out of the app due to a crash, the app logging the user out, the user opening the app again to find themselves unable to log back in.
  • A user becoming frustrated and churning due to an unexpected logout that removes them from their spot in a queue on an e-commerce app.
  • A user backgrounding the app, coming back into their user session, seeing they’re logged out, and abandoning the user session.

If problems like these occur, then your mobile team will need the previous session’s context to pinpoint the larger problem that led to the logout issue. This is where a stitched session is useful.

Downloading excess data that results in crashes later

A stitched session can quickly point you to the cause of a crash (i.e. excess data downloads) rather than forcing your mobile team to waste time problem solving in sessions that provide them no answers.

three part stitched session including an issue in the third session.

The image above illustrates a user’s experience with an app across three foreground sessions. The first session is short and error-free and leads to a backgrounding of the app, which is depicted by the first gray portion of the timeline. The second blue section represents the user returning to the app for a second, longer, error-free session. Another gray area represents a second time backgrounding the app, before returning to the final session (blue) which results in an OOM issue, shown with a flag.

A different monitoring solution would merely provide you with information as simple as “the user launched the app, loaded the product details screen, and it crashed.” Embrace shows you what happened in the previous session.

a stitched session timeline showing a multitude of slow network calls and an error.

You can see here that the app downloaded too many images in the second session and the OS couldn’t process them. When the app started to slow down, the user backgrounded it only to reopen it shortly thereafter and experience a crash. This knowledge allows your mobile team to get to the root of an issue faster.

Why do mobile teams need stitched sessions?

Stitched sessions are vital to your mobile team and can help them:

  • Remove the guesswork involved in triaging errors. Mobile exists across foreground sessions, meaning you need to understand the entirety of user experiences to solve every issue. Stitched sessions give you the full breadth of data needed to eliminate wasted developer hours.
  • Uncover device or user-specific issues. For example, you might notice an individual user experience several sessions in a row that all end in crashes. When this occurs, there is probably a device or OS factor causing this issue.
  • Surface issues that stem from multiple causes. In many instances, a slow startup time might occur because the app has initialized too many SDKs. As a result, the user backgrounds the app out of frustration just to launch it again and have it crash. You now have two ways to uncover the root cause of the issue — by analyzing sessions with bloated startup times or through investigating crashes.

How Embrace helps mobile teams

Embrace is a data driven toolset to help mobile engineers build better experiences. With actionable data and insights derived from 100% of mobile user experiences, engineering and data science teams proactively uncover, prioritize, and instantly solve issues before they affect a business’ bottom line.

Request a demo and see how we help teams set and exceed the KPIs that matter for their business!