Mobile gaming companies using Unity as a game engine have a big decision when it comes to their monitoring and analytics options: use Unity’s built-in tools, build it themselves, or use a third-party tool?

While there are many criteria with which decision-makers need to consider when it comes to choosing a tool for the engineering team, this piece will discuss one indisputable advantage that Embrace offers over all other observability and monitoring tools: scalability.

Tools Must Scale For Longevity

The ability for a tool to scale with the needs of the company cannot be understated. Any company that is looking for growth is a company that would like to avoid the roadblock of updating their tools: there’s an onboarding period, an integration period, a testing period, and the inevitable push-back of getting internal users to change.

This is why the tools a company chooses from the outset should ideally be capable of scaling with the needs of the company. There is no management debt to contend with in the future, allowing for growth that does not require stalling.

But how does one evaluate whether or not a tool is capable of scaling? And, how can Embrace confidently state that it can out-scale all other tools?

To answer that we will need to take a quick sojourn through the early heydays of mobile apps and the (lack of forward-thinking) philosophy and thought process that engineered the tools that have been passed down to today.

In the beginning, mobile apps were invented. This introduced a by-product of mobile apps crashing, because the smart people had no idea what they were doing and the dumb people thought they already knew everything because “it’s just a mobile computer, what could go wrong?” This meant that in the beginning, the first mobile apps didn’t even report when they crashed. And so the first crash reporter was invented to address this with one mandate: Alert the engineering team when the app crashes.

But obviously that isn’t enough to solve the problem (hindsight is 2020, we know). Today, simply knowing when your app crashes tells you nothing about the experiences your users are having when they aren’t crashing. The discerning reader may recognize that the user experience is everything, yet the original logging systems weren’t tracking this. This use of a singular data point could have terribly misleading results; if you’re seeing a high crash rate approaching 99% you might be sending engineers down a rabbit-hole chasing possible causes for crashes when in reality it was due to 20% of users force quitting your app as a result of freezing.

The original mandate needed to be changed, and more information needed to be collected to avoid coming to the wrong conclusions based on just one data point. The original tools recognized this and over time began adding to their repertoire of “items to track.”

That’s the key to getting “good” session logs, which in turn gives the engineers a better idea of “what happened?” whenever something goes wrong in mobile.  A good engineering team can then take this information and build a system to load and process good sessions alongside the bad sessions, allowing comparison and diagnostics. This is the key failing in traditional crash reporters. Without a series of “good” session logs, the engineering team can’t understand what went wrong in the crash.

Imagine if you brought your broken car to a mechanic who has only ever worked with broken cars. They might believe that cars with less than four wheels is a normal affair — after all, the cars they see are usually after the accident. This is what Unity’s built-in crash reporter and other crash reporters offer — a mechanic who doesn’t know what a working car is supposed to even look like! All because they are working with imperfect information.

So How Can This Scale For Longevity?

You’ll see the trend is that “more information is better” — this comes back to the pain point engineering teams will eternally face and is why Unity and existing tools will all eventually hit an insurmountable ceiling. Our competitor’s tools were designed from the ground up to “add” information they track and learn about the potential issues as they come into existence.

Our competitors built their systems to collect problems when they happen. It is only after the fact that they expand their system to collect more information targeting this new problem.
If your app has a 99% crash-free user rate, this means our competitors only have 1% of your user data (since, that’s all they feel the need to collect). They’ll only ever have 1%, and it will always be data related to the problem. Like your senses alerting you to a pulled muscle after the fact.

Embrace captures the other 99% of data that our competitors overlook, a decision we built our tool to do from Day 1.  For a competitor to catch up they would literally need to expand their systems 100x over in scale to offer you complete visibility into your app’s health.  

Now let’s say you discover a problem and you want to find out how many people are experiencing it — but it isn’t something that Unity captures. You can teach Unity to recognize and capture that data for analysis — or, if you had Embrace, you already have all of that information and you can simply run a query on the data you already have and get the answer.  No building, no waiting, because the tool your engineering team uses is already poised to scale with the team’s needs.

In other words, Embrace comes with all the information you’ll ever need, whereas the competition is continuously awaiting users to tell it what additional data it should incorporate, trying to play catch up.

This is why companies like Unity will never build a crash reporting tool that proactively scales with the needs of your mobile gaming app; it requires an abandonment of their current mindset of “adding as you go” tooling to redesign it from the ground up. If you are waiting and hoping to see if they will expand their toolset, you will only lose to the proactive mobile gaming companies that will utilize good third-party tools for analytics and crash reporting. And as we’ve covered before, being proactive with stability is what keeps gamer retention high.

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!