As a successful mobile game developer,
one of the most important things you can continue to do
is update your game with new content, bug fixes,
and daily offers to keep your players engaged
and entertained.
But sadly, updating your game packages incorrectly
can lead to a horrible burden of updates for your users.
My name is Colt McAnlis, and there's an easier way
to push out data updates and keep your applications in sync.
It's called Google Tag Manager.
See, everything in your game is driven by data.
Everything that makes up your game-- like levels, animations,
textures, localizations, sounds, even layouts-- it's all data.
And updating that data can become a problem.
When you push a new version of your app,
users are now caught in an application update cycle.
That is, they can be notified that there's a newer version
but can decide to ignore it.
As such, it's a common situation to have multiple versions
of your game out in the wild, each one
at different states of updates.
In order to keep all your users on the same page
and keep them from having to constantly download
new versions of the game, you need a better way
to distribute updates to your users.
And this is where Google Tag Manager comes in.
Tag Manager is a cloud-based service
to deliver various types of text-based data
to devices around the world.
It prides itself on removing the curse of the upgrade cycle
and keeping all of your users' devices
in sync with the latest data.
It does this by relying on a key principle.
Different data in your game should
be updated at different frequencies.
See, there's a huge separation between fast-changing and
slow-changing data in your app.
Changing strings or translations may
happen about once a week, while small tweaks
to play balance, A/B testing, or offers may happen daily,
while art or binaries may only change about once every
two months or so.
So how does Tag Manager actually help?
In a typical world, when you want to change your data,
you do so locally, sign your package,
re-upload it to the Google Play Store.
And after some processing, your existing users
will be notified that an update is available
and they can download the whole application update.
But with Tag Manager, you can bypass most of this chaos.
Since your data has been separated out
from your code and binary assets,
you push only the updated data to the cloud
using Google Tag Manager console.
The next time the user starts your app,
it'll check if there's new data available
and sync only the new information to the device.
And rather than just sending out the same updated information
to everyone, Tag Manager allows you
to define a specific set of rules
to help segment your user base and send them
different content.
See, users' devices will submit some sort of device info
to Tag Manager when they check for updates.
This is then tested against the set
of rules dictating what types of updates they should receive,
which then returns the properly updated data to the right user.
These rules for data allow you to target specific segments
of your user base and give them the data that
doesn't influence everybody else.
The best part is that all of this logic for syncing
and keeping clients up to date is
handled under the hood for you.
Working with Tag Manager is as simple as interfacing
with a few sets of APIs to fetch your data.
And check this out.
You can further extend the rules model in Tag Manager
to create automated A/B testing for your app.
Simply create an experiment in the Tag Manager console
which comprises of two things.
Firstly, you need a rule set, which basically
states what variables to change and what
sets of users to test it on.
For example, you might want to update the text on your offer
screens for users who tend to buy
in-game power-ups differently than those
who buy vanity items.
You'll also need to specify a desired action, which
is the result of some user action on the device,
like clicking a button, accepting a quest,
buying an item, or killing an NPC.
Once the experiment is set up, Tag Manager
will do all the heavy lifting to roll out variable updates
to subsets of your users on your behalf.
You don't even need to think about it.
And as users submit actions back to Tag Manager
for your experiment, it's all collected and reported back
to the console using the power of Google Analytics.
So with Tag Manager, you get the best of your efforts-- a way
to distribute a high frequency changing data
without users having to download the whole package again.
You also get a set of rules, which
you can use to send specific updates to specific segments
of your user base, and you get powerful experiments,
which you can create dynamic scalable A/B testing
frameworks to improve your game with dynamic feedback
over time, which is a lot of usefulness
in a little bit of code.
To get started with Google Tag Manager,
head on over to the Tag Manager home page
and sign up for an account.
This will give you access to the console,
doc sets, as well as the library files
to include in your client-side packages.
Building a scalable game for millions of users
is a monumental task to undertake,
but with Google Tag Manager, you can ignore all that
and focus on the real problems-- zombies.
Thanks for watching.