SUMIT CHANDEL: So I heard that you
wanted to start showing some ads to your users.
But you had some questions, like if I
start showing ads to my users, will they stick around my app?
And if showing ads is OK, how many ads is too many ads,
so that I can balance earnings and revenue while keeping
my users happy?
Well, I have some good news for you.
There's a way to solve these questions once and for all.
But first, we'll need a framework.
[MUSIC PLAYING]
So figuring out that you need to show ads to your users
in order to monetize your app and earn some revenue
isn't hard.
What is hard is figuring out things
like how often you should show ads to your users.
Because probably much like yourself,
your users would rather see less ads than more ads
when using your app.
Unless viewing ads is kind of your thing, and hey,
I can't blame you.
There's some pretty good ones out there.
But the problem can get much more complicated than just how
often to show ads to your users because you
have different kinds of users who
have different levels of tolerance or desire
for viewing ads.
For example, some might only use your app
for a few minutes a day, while others might spend hours on it,
and others might only like that new cat meme generator
you added in but not much else.
Well, these kinds of complex problems
are exactly why we created the "Optimize Your App Revenue"
series.
In our first season, we'll be focusing
on using Firebase and AdMob.
Each episode in the series will focus on a specific ad
experiment, where we'll be answering questions
like the one on ad frequency, but go even further to things
like experimenting to find the right balance
between in-app purchase revenue and ad revenue,
to optimizing ad reward amounts with in-game currency,
and many other topics.
You'll learn how to design the experiment
and how to implement it in your platform of choice,
whether that's Unity, Android, or iOS,
and then learn how to analyze the experiment results to see
if you've discovered a new way to optimize your app revenue.
But before we get into answering those questions,
we'll need an experimentation methodology
we can use to solve them, and a framework
of products we can use to implement some solutions.
Now, if you're coming to this video from the AdMob YouTube
channel and just finished watching the first episode
on using AdMob in Firebase, you're
already familiar with the experimentation methodology
part of this video.
So feel free to skip ahead to the Framework section
using the chapters on the video timeline.
And if you're coming from the "Optimize Your App Revenue"
video from our last Firebase Summit,
you're already familiar with both the experimentation
methodology and the framework, and even
how to solve a few questions at a high level.
So move on to the next video to start testing some new ad
experiments.
The links to both of these videos are in the description.
They're by no means a prerequisite to following along
with the rest of this series, though,
so stick around as we cover the basics
you need to know to implement some ad strategies.
OK, so let's talk about the experimentation methodology
we're going to use to design and solve our ad experiment
questions.
In our case, we're going to use A/B testing.
If you're unfamiliar with A/B testing,
it essentially amounts to exposing different variants
or experiences to a subset of users
and figuring out which one works better based on some goals
or metrics that we care about.
The general name for those two variants,
supposing we have two of them, are variant A and variant
B, hence the term A/B testing.
That being said, there are times when
using A/B testing to solve question is appropriate
and other times when it is not.
A/B testing is most effective when
you can hypothesize that there is
some variant or a way of achieving a goal that
can outperform another.
For example, if I'm making a game,
I can hypothesize that making the game too hard
could discourage players from sticking with it,
while making it too easy could make the game too boring
and lead them to quitting it altogether.
There's probably a middle ground that
is the best option to keep users engaged,
and if I pose the question "What game difficulty keeps my users
the most engaged?"
I can use A/B testing to find out if there is a difficulty
sweet spot for my game.
Coming back to our ad experimentation questions,
I can use A/B testing to answer questions like,
how frequently should I show ads to my users,
with the goal of optimizing my ad revenue
and also tracking secondary goals, like user retention
and engagement, to check if any of the variants
are having any negative impacts on my user experience.
Now, there are also times when A/B testing isn't
the right approach to figure out an ad
strategy, such as figuring out if I should show ads
in my app in the first place or not.
We're not going to cover that here, but stay
tuned for episode number 3, where
we tackle that exact topic.
So that lays out the experimentation methodology
we're going to use to solve most of the ad strategies
we'll explore in this series.
The next thing we need is a framework
of products that will allow us to implement these ad
strategies into our apps.
Let's get into what products we'll need
to make all of this happen.
First up, we'll need Google AdMob,
because that's how we're going to add some ads into our apps.
Next, we're going to use Google Analytics, because that
is what will allow us to measure the impact of our ad
experiments via metrics like user retention,
ad revenue, purchase revenue, and so forth.
And finally, we're going to use Firebase Remote
Config and A/B testing, because that's
what will allow us to create different ad
variants in our experiments and deploy them
to our target users.
Now let's walk through how to add
all the products in this framework
to your Firebase project.
Now, I'm assuming you already have a Firebase project
with an app configured on it.
But if you don't, check out the link in the description
on getting started with Firebase, and come on back.
OK, now let's start adding some SDKs.
We're going to start with Google Analytics.
So first, to enable Google Analytics on your project,
if you haven't already, just go into the Firebase Console
to the Analytics section and click on the Enable Google
Analytics button, and then create or select
your Google Analytics account that you
want to use for your project.
Click on Enable Google Analytics one more time,
and you're all set to go.
To add the Google Analytics SDK to your Android project,
just add the firebase-analytics library
in your build.gradle file and it'll be added to your project.
On iOS, just add and install the Firebase/Analytics pod.
And for Unity, just add the FirebaseAnalytics.unitypackage
to your project.
Now let's add the Google AdMob SDKs into the mix.
So here, I'm assuming that you've already
created a Google AdMob account and your AdMob app.
But if not, check out the links on the Getting
Started with AdMob in the description
to create and set them both up.
It's all very straightforward, and will probably
be faster for you to just go ahead and create that
directly rather than walk through it here.
So go ahead if you haven't created that yet.
I'll be waiting.
One important thing I did want to call out here,
though, is that after creating your Google AdMob account
and AdMob app, you'll need to enable a user metrics
and link your AdMob app to your Firebase project.
To do that, just navigate to your app in the AdMob Console,
click on the User Metrics section,
and click on the checkbox to enable user metrics
and save your settings.
Note that this process can take a while,
so you may have to come back to the page after some time
before user metrics are fully enabled,
and you can go on to link your app to Firebase.
Once it is ready, just click on the Link
to Firebase button, check out and confirm the policy,
select your Firebase project, and hit Continue and finally,
Done.
This link is what enables the flow of Google Analytics
and AdMob metrics back and forth,
and it's also what allows Firebase Remote Config
and A/B testing to implement all the neat ad experiments that we
want to try.
By the way, if you haven't created ads
using Google AdMob before, one cool thing to know about them
is that they're pretty configurable.
You can set things like how frequently you
want an ad to show up in your app for your users,
how much reward or virtual coins or in-game currency
you want to award when someone finishes viewing an ad,
and a bunch of other stuff.
We're going to play around with a lot of these settings
when we get to implementing our ad strategies and A/B
tests in each episode.
So I wanted to mention them here for now.
Now, to add AdMob into your application,
you'll just need to add the AdMob SDK
and specify your AdMob app ID so that the SDK can reference it
in your application code.
If you already configured this when creating your AdMob
account and linking to Firebase, skip to the Remote Config setup
chapter using the video timeline right here.
Otherwise, let's configure the AdMob SDK into our projects.
So on Android, that means adding the com.google.android.gms:play
services ads SDK in your app-level build.gradle file
and updating your AndroidManifest file to include
your AdMob app ID.
On iOS, you would add the Google-Mobile-Ads-SDK target
to your product's pod file and install it via the pod install
--repo-update command, as well as add your AdMob app ID
to your app's Info.plist file.
And for Unity, you'll need to download and import
the Mobile Ads Unity plugin.
For Android, you'll also need to include the Mobile Ads
SDK in the Unity Android Resolver,
and you'll also need to add your AdMob app
ID by visiting the Assets, Google Mobile Ads, Settings
page.
The links to all the AdMob Getting Started guides
for each platform are linked in the description,
so if you want to set those up now, please go ahead
and take a minute to do so.
Next we're going to add Remote Config and A/B testing
into our project.
In case you haven't used Remote Config before,
you can think of it as a set of key value pairs
that live in the cloud and that can change the look
and feel of your app based on user-specific conditions
that you can configure on the fly.
In the case of our ad experiments,
we'll be able to use Remote Config to create different ad
experiment variants and choose specific audiences that we want
to expose those variants to.
The A/B testing part of the framework
is what allows us to create and run our experience
and analyze the experiment results as we start deploying
variants to our users.
To add both of these products to your application project,
you just need to add the Remote Config SDK.
Firebase A/B testing is built on top of Remote Config,
so you can get both products enabled just
by adding the Remote Config SDK.
So for Android, just add the com.google.firebase.firebase
config library to your app-level build.gradle file.
On iOS, just add and install the Firebase/RemoteConfig pod
to your pod file.
And for Unity, just add the FirebaseRemoteCo
nfig.unitypackage to your project.
OK, and now that you've added all the necessary SDKs
to your project, your app is now set up with the framework.
Trademark pending.
You're now ready to start implementing some ad
experiments.
Why don't we start with our first one-- how often
should you show ads to your users?
Would you like to know?
Well, check out the next episode.
Oh, and if you like this series and all the new content
we produce on the Firebase channel, please give us a like
or subscribe.
See you in the next episode.
[MUSIC PLAYING]