(upbeat music)
- Hi, I’m Kim, a software engineer on Firebase performance monitoring.
- And I'm Nathan, also a software engineer on Firebase.
We are here to talk to you about how critical a fast and snappy user experience is
to the success of your app
and how the latest improvements in Firebase performance
help you identify and fix performance issues.
That way, you can spend less time searching for problems
and more time building great experiences for your users.
Let's jump right in.
As developers, we intuitively understand
that high-performing apps are the successful ones.
Users today are busier than ever, and they demand
high-performing applications and experiences.
In a recent analysis, we found out that 54% of Play Store reviews
with one-star rating mentioned stability and bugs.
Another recent study points out that retail sites
that reduced their mobile load times by just one 10th of a second,
were able to increase their checkout conversions by up to 8%.
For travel sites, the increase in conversions was as high as 10%.
But no matter how important,
these details are easy to lose sight of by developing.
The truth is, improving our performance becomes a daunting post-release exercise,
and a moving target as new features are being developed.
- This is where Firebase performance monitoring
can make tackling performance issues much easier.
We've made a few exciting new updates to Firebase performance,
including real-time performance metrics,
giving you access to your app performance data
within minutes, and a newly redesigned dashboard
providing a comprehensive view
of all of your performance traces and their metrics.
We also make it super convenient for you to add your most important metrics
to a personalized metrics board right at the top of the dashboard,
so all it takes is a quick glance
to understand how your key metrics are performing.
Today, Firebase performance processes
as many as 200 billion daily performance events,
collected from over 3 billion app installs,
supporting apps both large and small, all over the world.
Within minutes, we can start supporting your app too,
using our open source SDKs
without you having to write a single line of code.
Firebase performance monitoring automatically collects data
about your app's network activity, app start duration,
and screen rendering performance.
But it also enables you to easily instrument
custom monitoring of key user journeys specific to your app.
These could be the time between a user tap until they see the product details,
the time taken to load flight search results,
or the time spent entering payment information during checkout.
To instrument custom monitoring,
all you need to do is add a couple lines of code.
Start the custom trace before the user journey.
Let the user journey flow complete, and then stop the custom trace.
Performance monitoring will collect how long it took the trace to complete
and report this metric in the Firebase console.
You can even collect important custom metrics for the user journey,
like the count of items in the cart
or the number of database reads during the journey.
Now, let’s take an example and see how Firebase performance can help
with fixing common performance issues in an app.
Imagine you lead the app development team for a major home furnishing business.
Your team has been hard at work on a newer version of the app
which includes better Cadillac navigation, 3D interactivity,
and a beautiful new checkout experience.
But soon after your big release, you find out that ratings
for your latest Android app versions aren't as great as you expected.
And you're also not seeing
the increased purchase conversions that you were hoping for.
A quick look at the Android vitals dashboard reveals
that your app’s been flagged
as having bad behavior due to long app startup times.
On top of that, your user reviews reveal even more issues.
Users are complaining about your shiny new 3D interactivity features,
and they voice frustration over the clunky checkout experience.
So, you know something is wrong, but you don't understand why.
Don't worry, we got you.
First, let's break down the three main problems for this app.
Slow cold start time, slow screen rendering
during the 3D interactive experience, and slow checkout.
What's great is that Firebase performance monitoring
was designed to help with each of these types of issues.
Right out of the box, Firebase performance
captures your app start time, screen rendering,
and network requests, which will definitely help
with solving some of the identified problems.
But to understand what’s actually happening with this specific app and its user journeys,
you'll also want to instrument some custom monitoring
into your new features, specifically the 3D interactive experience
and the checkout flow.
You’ll then want to add the important metrics from this monitoring to your metrics board
in the Firebase console. This way, you can closely monitor
and understand how those metrics are performing across releases and over time.
Of course, our work isn't done with monitoring alone.
Together, we’ll walk through performance issues we identified, one at a time
to see how Firebase performance monitoring helps with fixing these problems.
And we’ll learn some top tips for using performance monitoring along the way.
- Let's start with problem number one, slow code app start.
First off, let's take a look at the summary
in your personalized metrics board in the Firebase console.
The median app start performance is reasonable,
but it's clearly not what all of your users are experiencing
based on those negative reviews.
The 90th percentile performance is a different story.
Its current value is 6.2 seconds.
This is definitely higher than the five seconds
bad behavior threshold recommended by Play vitals.
This means that more than 10% of our users are experiencing app starts
that take longer than 6.2 seconds.
Now, Android writers flag your app with slow cold start times just recently.
But when you flip between different versions of your app
in the metrics board, you don't see any noticeable increases
in the latest release version.
So you dive deeper into the details page to understand more.
Right away, you notice that there are outliers
for performance across different countries.
The app start performance is considerably slower
for Indonesia and Brazil, where many of your users are based.
During start-up, your app fetches user settings
and the product catalog from your data servers.
And you realize that your data servers are all concentrated
in North America and Europe.
Well, the countries with slower app start times
are far away from those servers.
You decide to rebalance your servers across regions
and move some capacity to Southeast Asia and South America.
You are confident that these changes will lower the app start time for affected users.
You choose to add some capacity to Indonesia first.
And you are correct. You immediately observe
the app start times dropped significantly for users in Indonesia.
And now you can more confidently roll out changes to Brazil
and the rest of the world.
That brings us to our first useful tip,
integrate Firebase performance with your app
to start tracking called startup times.
With data available to you in real time,
you can quickly identify performance issues
and get a headstart on fixing them.
- Next up, let's deal with problem number two,
the frustration users are having with slow screen rendering
while using the 3D interactivity feature.
This brings us to a common performance problem:
excessive frozen frames. This metric captures the percentage
of screen views during which 0.1% of frames took longer than 700 milliseconds to render.
We've all experienced this type of slowness before,
and know firsthand how frustrating it can be as a user.
Back in the Firebase console, it appears that 26% of your product preview screens
experience excessive frozen frames,
which is quite a degradation since you added the 3d interactivity feature.
Your team had thoroughly tested this new feature,
and was happy with it during development. You thought that it was quite delightful.
What happened? Just like we did for app start,
let’s navigate to the detailed performance breakdown for frozen frames.
While looking at the device breakdown, you notice that low memory devices
show a much degraded screen performance.
This gives us at least some direction,
but that app screen handles a lot of different things.
How can we figure out where you should focus on improving?
This is where the custom traces you set up for the 3D interactivity feature come in.
You added one trace to track the time until 3D models are interactive,
another trace covering the time to apply any customization changes
such as furniture pattern or color.
And one more, tracking the time to apply furniture positioning changes.
These three traces give you direct visibility
into what your users are experiencing when interacting with this feature.
In particular, it appears it's taking a long time
for the 3D models to load, render, and become interactive.
The 90th percentile performance is currently 2.6 seconds.
Giventhat frozen frames were highest for lower memory devices,
it seems that your 3D models are simply too large for lower tier devices.
To reduce the size of the 3D models,
you reduce the amount of configurability they support,
and release further compressed models
to optimize device memory as much as you can.
Rolling these changes out, you see solid improvements.
Your custom traces demonstrate reduced wait times
and the frozen frames metric decreases significantly.
With these changes in place,
you're optimistic that you've addressed the bulk of the user frustration
you were seeing in those negative reviews.
And thanks to the convenient dashboard view, it'll be easy
for you to come back and validate these fixes over time.
With that, we have our tip number two:
Use custom instrumentations to get direct visibility
into your key user journeys and to help target debugging.
-That brings us to our third and last problem from user reviews: clunky checkout experience
Now that you have worked hard on improving your app’s startup times
and 3D product interactions, your team is eager to see
how they can improve checkout experience. In your app's business analytics tracking,
you see a clear drop-off
between users initiating the checkout process and ones completing it.
In the Firebase console, you start looking
at the performance data by your network requests.
You see that some of your checkout service calls
are failing, but since performance monitoring
automatically aggregates you out of the patterns,
all of your checkout related API calls are currently being grouped together,
which can sometimes make it hard to understand
the severity of the problem or which calls are failing.
You wish that network performance data
for your checkout service was more fine grain and aggregated at a per API level.
And performance monitoring enables you to do just that.
You can create custom URL patterns to capture specific API end points.
As soon as new custom URL patterns take effect,
you can immediately see how individual API calls
to your checkout service are performing.
You see that your inventory lookup call is quite slow,
with a 90th percentile response time of 1.47 seconds.
This is likely a big factor behind the abandoned checkouts.
Equipped with this data from Firebase console you contact your backend team,
but their server-side monitoring
still shows the very same API taking just 800 milliseconds.
Clearly with all the network delays,
your users are getting a much degraded experience
from what your server monitoring is able to catch.
In fact, many of the four XX client errors
that you see in Firebase console are also missing
from the server monitoring.
You can't do much about the network latencies directly,
but there's light at the end of the tunnel.
Once your backend team learns what users are actually experiencing,
they are motivated to further improve the performance
of inventory lookup calls.
As they make changes and rollout latency improvements on their end,
you can clearly see in the performance dashboard
that the inventory check API is performing much faster.
With that, we have our final tip for you all:
Creating custom URL patterns is a powerful way
to aggregate your network call details at the right level of granularity.
Amazing. All the hard work your team
has put into the improvements has finally paid off.
Your app ratings have improved significantly,
and now you have many happy and engaged users.
- Now you know how Firebase performance can help you fix common performance pitfalls,
and level up your app to bring great experiences to your users.
To summarize all tips and tricks we mentioned,
here are our key takeaways.
You can immediately start tracking
and improving your key performance metrics in real time.
And with the powerful ability to compare trends
across your metrics, you can now zero in
on the biggest changes that need your immediate attention,
all thanks to our newly launched comprehensive trace table.
You can also personalize the dashboard
so that your key metrics are front and center easy to keep an eye on.
And you can get direct visibility into your most critical user journeys
and any other important bits of code by adding custom instrumentation to your app.
And lastly, you can conveniently create custom URL patterns
stay on top of client-side performance
of network calls to the backends that you directly own,
or depend on indirectly through your SDK dependencies.
All of this is in service of helping you catch regressions, validate fixes,
and roll out improvements with confidence.
We can’t wait to see the incredible apps you’ll create,
and the creative ways you’ll use performance monitoring along your journey.
Get started with Firebase performance monitoring today,
and check out all the new capabilities.
Find out how by visiting our docs linked below.
On behalf of our team, thanks for watching.
We'll see you next time. - Goodbye.
(upbeat music)