Embrace was founded by one of the co-founders of Scopely to deal with the core pain points of debugging: Scopely’s engineering team was tired of being unable to quickly identify errors in mobile games. At first, Scopely attempted to string together multiple 3rd party tools alongside homegrown tools to streamline the debugging process. Unfortunately, all attempts to simplify debugging so that the process itself isn’t a pain point were met with failure.

Embrace was born with one goal in mind: the engineering team should be able to receive a complaint, search up the affected session, and immediately know what went wrong and how.

Debugging mobile apps is already a difficult process but mobile gaming suffers more from not having tools built to address the needs of gaming development. When we launched Unity support we wanted to directly upgrade tools available to developers. Part of the benefits includes session replay, a powerful feature that has already proven to be extremely popular with non-gaming developers.

In this blog post, we’ll discuss how session replay will prove to be even more beneficial to game developers through:

  • Why traditional debugging techniques are inefficient and inadequate
  • Why mobile game developers need session replay
  • How Embrace’s session replay is the ideal solution for mobile game development
  • How Embrace’s session replay empowers developers to revisit old problems

Why Traditional Debugging Techniques are Inefficient and Inadequate

Traditionally, engineering teams use a combination of crash reporters and logging to catch issues.

  • Crash reporters generate reports whenever the app crashes
  • Logging keeps track of data to be queried

The idea is that between crash reporters and logging, the engineering team either catches the stack trace leading up to the crash or can query the logs for reported issues that did not result in a crash.

If only this method worked, apps would run flawlessly and issues should always be resolved by the next patch.

Even if the methods and tooling worked (and they don’t), mobile games are more complex than non-gaming apps. State machines alone are far more complicated to log and track in mobile games and the methods and tools will fail unless they are designed to tackle gaming-specific problems.

As mobile gaming largely incorporates the use of state machines, the crash reporters and logging methods are struggling to keep up.

Why Mobile Game Developers Need Session Replay

If you’re a game dev, you know the nightmare that is debugging state machines. The composition of the transition in and out of all the state machines in the game needs to be tracked. This is complicated yet necessary for an engineering team that wants to solve all the bugs and issues in their game.

This is a monumental problem to log and query. In fact, most engineering teams don’t even bother due to the scale of resources required to do so.

This logging hell requires some poor engineer(s) to build a good SQL query for going through the logs in the database. Keep in mind: just because you have all the data does not mean you have usable data, and it’s the process of turning data into usable data where traditional methods fail.

However, what if the querying and stitching together of these different state machines was done for you? What if it was presented in a single visualization so you could scroll through and immediately track the user’s experience? What if it showed you exactly when and where the issue occurred in the game?

In other words: What if you had the information you needed without the hassle of putting it together yourself?

How Embrace’s Session Replay Is The Ideal Solution For Mobile Game Development

There is a tremendous gap between logging and making use of that data. Increasing the amount of data available to the engineering team is not the same as increasing their understanding of the data. Think of how many people have access to the internet yet don’t have a good understanding of specific topics!

The problem is that all programs, but especially games, are simply too complex for a human to visualize mentally — there’s a reason we built computers to do complex processing. We cannot know or understand everything happening inside the program simply by reading through the logs. To make sense of it, we rely on tools to organize the data so we can make sense of it.

That’s where Embrace’s session replay comes in to address these core issues with logging state machines:

  • Someone needs to sift through all the data
  • Someone needs to piece data together

Embrace collects 100% of user sessions to provide comprehensive session data with a time-based visualization of the entire user experience. For any moment within the user session, the developer knows exactly what happened within the app and under what conditions.

Perhaps you want to look up a specific user and replay a problematic session instantly, a useful function that would aid any engineering team. Or perhaps you’re debugging a new release and want to query the entire database for instances of character models T-posing — all of this is easily done through Embrace’s session replay.

Ultimately, the distillation of data into a usable form is Embrace’s specialty. This is why we have Session Replay as a core feature of our dashboard: to not only streamline the sifting of data, but also visualizing it in a digestible manner so engineers can immediately understand what it all means.

How Embrace’s Session Replay Empowers Developers To Revisit Old Problems

There are many bugs and issues that plague apps because the company made the decision to “live with them.” Generally speaking, it’s because the payoff of fixing said issues is not worth the cost in time and engineering resources.

Over time, many companies have bucketed these issues into “things we just live with” and accept that there’s no point revisiting them. Taking a step back to view this holistically, any company that makes this decision is actively deciding that any user churn as a result of technical issues is acceptable.

This problem of “acceptable losses” can be mitigated with Embrace’s session replay feature. Developers no longer need to worry about the costs of sifting through data and piecing it together. They get the diagnostic data they need to fix an issue right out of the box.

If you know of issues in your gaming app that you’ve simply “accepted and moved on,” then try out Embrace’s session replay. Perhaps your engineering team isn’t completely helpless about it after all!

How Embrace Helps Mobile Gaming Teams

Embrace is an observability and debugging platform built for mobile teams. We are a comprehensive solution that fully reproduces every user experience from every single session. There is no sampling: if a user has a session in your game, you can look up everything that happened and see what went wrong. Your team gets the data it needs to proactively identify, prioritize, and solve any issue that’s costing you users or revenue.

Need help improving the performance and stability of your Unity games? Take our SDK for a spin!

Request a demo

Want to see how Embrace can help your team grow your non-gaming app with best-in-class tooling and world-class support? Request a customized demo and see how we help teams set and exceed the KPIs that matter for their business!

Request a demo
Free Trial