Traditional error reporting tools for mobile games focus on logs and crashes, which severely limits both the scope of issues they can uncover as well as the actionability of the data itself. In other words, mobile teams might know an issue exists but still lack the information to efficiently reproduce and solve it.

In this post, we’ll go over why modern mobile game developers need to invest in tooling that’s built for their needs — identifying and solving every problem that prevents users from having a good in-game experience. As the mobile game ecosystem continues to experience tremendous growth, the competition only gets tougher. If you won’t provide users a game with the performance and stability they deserve, someone else will.

In Games, the User Experience Is Everything

Users aren’t playing a mobile game as a mechanism to accomplish a separate task. In other words, an e-commerce app is a vehicle for a user to make a purchase. If the e-commerce app freezes a bit or runs a bit slow, as long as a user is able to buy the product, they might tolerate a less than stellar experience.

But in mobile games, your game is the experience.

The user showed up to play your game. If your game consistently freezes or has agonizingly slow load times, your game is directly sabotaging a user’s enjoyment. And they will leave bad reviews before uninstalling your game. This decreases your revenue and hurts your brand.

How serious a problem is this?

  • 90% of apps are used once and then deleted.[1]
  • 94% of users churn only 28 days after downloading a mobile game.[2]
  • 79% of users will only retry an app once or twice if it failed to work the first time.[3]
  • 70% of users will abandon an app because it takes too long to load.[4]
  • 71% of app uninstalls are because of crashes.[5]
  • 18% of users will delete an app immediately if it freezes for just five seconds.[6]

As you can see, it’s very important to deliver an exceptional experience to users or risk a swift exit.

Sampling Doesn’t Show You Every Problem

But what do we mean by sampling exactly? Well, it means you aren’t collecting comprehensive data about your user experiences, opting instead to select only specific segments of data. The classic example would be setting logs when certain conditions occur.

  • If an in-app purchase fails, send a log.
  • If the game crashes, send a log.
  • If a certain game screen doesn’t load, send a log.

The problem is that if the conditions aren’t met, you don’t receive any data. In other words, you have to decide ahead of time what issues you care about. But in mobile games, you simply cannot predict every issue. That means, at a minimum, when you discover a new issue (through testing or a user complaint) you need to add logs to cover it, release a new version, and hope your solution fixed it.

In essence, you’re always on the back foot, waiting to hear that something broke, instead of proactively identifying and solving issues with the data you need automatically collected and reported to you.

Let’s say a user reported that after completing Level 4 the game crashed. That’s all the information you have.

Can your mobile team quickly diagnose the issue without additional information? For example:

  • What if the crash only affects certain devices and OSs?
  • What if the crash occurs because of a failed ad load?
  • What if the crash occurs because of a memory leak introduced in Level 4?
  • What if the crash occurs only when the device is in low power mode?
  • What if the crash happens when the user loses network connectivity?
  • What if the crash happens as a result of network calls firing out of order?
  • What if the crash is a huge edge case that only affects five users?

The less information you have, the more your time to resolution skyrockets. And this example is about a crash, where you at least have a stack trace to reference.

What about issues that users complain about that don’t result in a log or a crash? For example:

  • The game stutters or freezes.
  • The screen is blank due to missing content.
  • Certain parts of the game are slow.
  • Screen taps and buttons aren’t registering.
  • The user loses their progress after backgrounding the app.

These types of issues are very difficult to debug because mobile teams often won’t have enough information to reliably reproduce the issue.

User Feedback Is Faster Than Ever Before

As soon as a user has a bad experience, they will immediately complain about it. They’ll write a blog post, leave a bad app store review, or blast you on social media. A company that cannot effectively identify and solve the issues that users bring up is a company that will quickly erode its reputation and userbase.

Every year, the world moves faster and faster. Users simply won’t tolerate bad game experiences. They are not patient. They expect problems to be investigated and fixed. There’s no “set it and forget it” with mobile games. It’s a constant challenge to deliver engaging material that’s also performant. With so many variables being completely out of the mobile team’s control, it’s important to have monitoring in place that gives them the data they need.

Because users won’t be able to provide all the diagnostic information you need.

  • They frequently won’t be able to fully explain the issue (e.g. “It doesn’t work” or “It’s buggy”).
  • They won’t be able to recount the exact steps they took in the game.
  • They won’t know the technical details of what went on under the hood.

In other words, even if every user who made an app store review wholeheartedly gave you every detail they knew about, you’d still be missing a substantial amount of data that would help with troubleshooting.

Backend Monitoring Solutions Aren’t Enough

You cannot rely on your backend monitoring to diagnose every issue. Your server could deliver 200s for every network call and your game could still be broken.

  • The calls could fire out of order, leading to crashes.
  • The sheer number of calls the device is trying to process could lead to timeouts.
  • Some calls might never make it to your servers if there are connection errors.
  • Failures or slowdowns in third-party network calls could be the culprit.
  • The amount of data processing from successful network calls could cause freezes and crashes.

These are just a few illustrative examples to express the notion that you cannot have full visibility without device-side monitoring. After all, would you judge the health of your backend systems by what the device monitoring registered? Of course not, so why would you trust your backend systems to reliably measure what’s going on in the device?

Your mobile game is in the user’s hand, not in your server.

Sampling Only Catches Known Unknowns

A good mobile team can write logs to cover the cases they know about. The problem is that no matter how much coverage you think about ahead of time, you cannot predict every issue in mobile games. If you could, then games with 99.99% crash-free sessions wouldn’t get user complaints.

However, as anyone working in mobile games knows, the gaps are real:

  • Traditional logging and crash reporting tools provide limited data.
  • Users expect perfection but cannot provide needed troubleshooting data themselves.
  • Your backend monitoring can only illuminate certain issues.

The problem with all three is that they are not comprehensive solutions. And that’s what your mobile game team needs to succeed — all the data out of the box.

  • Comprehensive data from every user session in the game, including user actions and technical details (taps, button presses, screens, network calls, logs, crashes, memory, CPU, etc.)
  • Ability to look up a user and instantly reproduce their individual experience
  • Distributed tracing of any network call from the device throughout your backend

In other words, mobile game teams are inadvertently debugging on hard mode by not empowering themselves with the data they need to efficiently troubleshoot every user-impacting issue.

You got into mobile games so you could build games, not go bug hunting.

With Embrace, you can spend more time on the fun stuff. Lots more.

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. 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!

Want to see how Embrace can help your team grow your non-game 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!

References

  1. https://www.inc.com/rahul-varshneya/7-reasons-why-users-delete-your-mobile-app.html
  2. https://www.openback.com/blog/mobile-game-retention/
  3. https://techcrunch.com/2013/03/12/users-have-low-tolerance-for-buggy-apps-only-16-will-try-a-failing-app-more-than-twice/
  4. https://clearbridgemobile.com/stats-for-mobile-app-growth-and-success/
  5. https://clearbridgemobile.com/stats-for-mobile-app-growth-and-success/
  6. https://www.codeproject.com/Articles/734535/Why-Users-Uninstall-Apps