Learn from app leaders: How Doodle redesigned their app using Fabric & Firebase

By Todd Burner, Developer Advocate

Learn from app leaders header

In this new series, we feature customers that have used our platform in an innovative way. For this installment, we chatted with the app team at Doodle who used the Fabric and Firebase platforms together to redesign their app to be more user-centric. If you want to participate in this series, please email support@fabric.io.

Recently, we sat down with Alexander Thiele who is a senior Android engineer at Doodle, a company that helps you find the best date and time to meet other people. As early adopters of Fabric’s Crashlytics and Firebase Remote Config, his team has expert familiarity with our platforms. The focus of our conversation was on how they redesigned their mobile app using analytics and crash data from their Fabric and Firebase dashboards.

Doodle logo.png


Q. How did you approach the redesign?

“The redesign is a complete overhaul of our app. We started by updating our onboarding flow to help people understand the best ways to use Doodle. We wanted to show users how they can poll each other to quickly find the best meeting time. We divided the redesign into three phases, first improving stability with Fabric’s Crashlytics, then A/B testing our poll creation feature with Firebase Remote Config, and finally measuring the results of our tests and production rollout by monitoring our app metrics in Fabric and Firebase analytics."


Phase 1: Finding tricky crashes

The team at Doodle wanted to understand how stability was impacting their app quality. That’s why they first focused on getting their crash-free user rate as close to 100% as possible.

Fabric’s Crashlytics helped them track crashes and prioritize them so they could improve their crash-free user rate. One feature they found particularly useful is adding logs and keys to crash reports.

Q. How did Fabric’s Crashlytics help you improve your app stability? 

“Crashlytics saved us a ton of time by surfacing crashes and helping us pinpoint their cause. I remember one really rare crash which we couldn't find the source of ourselves. We also don't have many crashes so we were really eager to find it. We then started to log everything that could be related to this crash, like page visits and the current internal database size. We also recorded those instances when our database couldn’t find something. After a few releases with custom logs, we found the bug. It happened in a really rare case where the user went to specific screens and used some specific features. Without custom logs, we wouldn’t have been able to find this bug.”

The team at Doodle also logs all crashes that they manually catch in the code to Crashlytics as non-fatals. This gives them more insight about what's going on in the app. By taking advantage of these unique Crashlytics features, Doodle has been able to move faster and add new features into production with less anxiety.


Phase 2: User-centric design

 The second phase of the app redesign was focused on updating the user experience and design. The goal of this phase was to refresh the look and feel of the app and introduce streamlined flows so users could accomplish their tasks faster (and with fewer screens/steps).

Q. What types of UI changes did you make in the redesign?

“The changes we made during this stage included everything from changing the color palette to introducing new screens and adding new app functionality. By monitoring the 7 day retention metrics in Fabric and Firebase, we saw that some new users didn’t understand the concept of Doodle immediately - so they didn’t return to our app. That’s why we changed the whole onboarding process to make Doodle easier to understand and use from the first time it’s installed.”

doodle app screen.png

Q. How did you test your changes?

“We used Firebase Remote Config. We tested our user onboarding and the flow users go through when creating a poll. We tried 4 different kinds of flows, which we tested using Remote Config. In the end, the data showed that one flow resulted in more polls being created than the others. Our key performance indicator for the A/B test was the numbers of polls created by users, and we tracked this KPI with Google Analytics for Firebase.“

Q. Did you use Remote Config for other things? 

“We also used Remote Config to test feature switches. For example a few months ago, we implemented banner ads on our scheduling screen and enabled them through Remote Config. We noticed that these ads didn’t perform well so we turned them off easily with Remote Config. Then, we tried inserting native ads into a few other places in our app. Through Remote Config, we were able to discover the right placement for ads in our app without disrupting our users or requiring them to update their app to see the changes.”

By tracking crashes and non-fatals with Fabric and deploying changes with Firebase Remote Config, the team at Doodle didn’t have to depend on the app store release cycles to understand their users and update their app accordingly. They could see user behavior change in real-time and make appropriate changes to their app before problems arose.


Phase 3: Measuring and going forward with Firebase and Fabric

The team at Doodle plans to keep using both the Fabric and Firebase platforms to monitor and improve their app - and display their metrics throughout every stage! 

Q. Now that the redesign is live, what dashboards do you find yourself using the most?

 “Our most important metrics are how many polls a user creates and how many people participate in a poll. We monitor these in the Fabric events dashboard and in Google Analytics for Firebase by logging events.

I’m also a big fan of the new TV Mode for Fabric, we have a big conference room and we put up our dashboard on the TV during launches so the whole team can see how we’re doing. The new Crashlytics dashboard looks nice too, especially device and OS filtering. We keep an eye on most of the dashboards daily.”

Q. What Fabric and Firebase features do you plan to adopt next?

“Over the next few weeks, we have plans to adopt Firebase Dynamic Links and to set up more in-depth Fabric custom events. By using Dynamic Links, we’ll be able to make it even easier to share polls. For example, our users will be able to invite other people to participate in polls via SMS and deep link right to the relevant app screen (even if the people they are inviting to the poll haven’t installed the app yet). We’ll track more events, like content views, to understand where our users find value in our app.”

Q. What advice do you have for other app teams who are considering redesigning their app?

“Two things: test ideas constantly and put your app users first. By combining Crashlytics’ real-time crash reporting with the ability to deploy remote changes to a subset of users through Firebase Remote Config, you can learn how valuable a new feature is, identify potential issues, and take action immediately.”

Q. Can you share some results of the redesign?

“This redesign greatly improved our in-app poll creation process so users could create polls faster and more easily. We measured the success of this redesign by looking at our daily active users (DAUs) in Fabric and our retention numbers in Firebase/Fabric, which have risen beyond our expectations!”

Migrating to Druid: how we improved the accuracy of our stability metrics

by Max Lord, Software Engineer

Stability metrics are one of the most critical parts of Crashlytics because they show you which issues are having the biggest impact on your apps. We know that you rely on this data to prioritize your time and make key decisions about what to fix, so our job is to ensure these metrics are as accurate as possible.  

In an effort to strengthen the reliability of these numbers, we spent the last few months overhauling the system that gathers and calculates the stability metrics that power Crashlytics. Now, all of our stability metrics are being served out of a system built on Druid. Since the migration has ended, we wanted to step back, reflect on how it went, and share some lessons and learnings with the rest of the engineering community.

Why migrate?

In the very early days of Crashlytics, we simply wrote every crash report we received to a Mongo database. Once we were processing thousands of crashes per second, that database couldn't keep up. We developed a bespoke system based on Apache Storm and Cassandra that served everyone well for the next few years. This system pre-computed all of the metrics that it would ever need to serve, which meant that end-user requests were always very fast. However, its primary disadvantage was that it was cumbersome for us to develop new features, such as new filtering dimensions. Additionally, we occasionally used sampling and estimation techniques to handle the flood of events from our larger customers, but these estimation techniques didn't always work perfectly for everyone.

We wanted to improve the accuracy of metrics for all of our customers, and introduce a richer set of features on our dashboard.  However, we were approaching the limits of what we could build with our current architecture.  Any solution we invented would be restricted to pre-computing metrics and subject to sampling and estimation. This was our cue to explore other options.

Discovering Druid

We learned that the analytics start-up MetaMarkets had found themselves in a similar position and the solution that they open-sourced, Druid, looked like a good fit for us as well. Druid belongs to the column-store family of OLAP databases, purpose-built to efficiently aggregate metrics from a large number of data points. Unlike most other analytics-oriented databases, Druid is optimized for very low latency queries. This characteristic makes it ideally suited for serving data to an exploratory, customer-facing dashboard.

We were doubtful that any column store could compete with the speed of serving pre-computed metrics from Cassandra, but our experimentation demonstrated that Druid's performance is phenomenal. After spending a bit of time tweaking our schema and cluster configuration, we were easily able to achieve latencies comparable to (and sometimes even better than!) our prior system.  We were satisfied that this technology would unlock an immense amount of flexibility and scale, so our next challenge was to swap it in without destabilizing the dashboard for our existing customers.

Migrating safely

As with all major migrations, we had to come up with a plan to keep the firehose of crash reports running while still serving up all of our existing dashboard requests. We didn’t want errors or discrepancies to impact our customers so we enlisted a tool by Github called Scientist. With Scientist, we were able to run all of the metrics requests that support our dashboard through Druid, issuing the exact same query to both the old system and the new system, and comparing the results.  We expected to see a few discrepancies, but we were excited to see that when there were differences, Druid generally produced more accurate results. This gave us the confidence that Druid would provide the functionality we needed, but we still needed to scale it up to support all of our dashboard traffic.  

To insulate our customers from a potential failure as we tuned it to support all of our traffic, we implemented a library called Trial.  This gave us an automatic fallback to the old system. After running this for a few weeks we were able to gradually scale up and cut over all of our traffic to the new system.

How we use Druid for Crashlytics

On busy days, Crashlytics can receive well over a billion crash reports from mobile devices all over the world. Our crash processing pipeline processes most crashes within seconds, and developers love that they can see those events on their dashboards in very close to real time.

To introduce a minimum of additional processing time, we make extensive use of Druid's real-time ingestion capabilities. Our pipeline publishes every processed crash event to a Kafka cluster that facilitates fanout to a number of other systems in Fabric that consume crash events. We use a Heron topology to stream events to Druid through a library called Tranquility. Part of the Druid cluster called the "indexing service" receives each event and can immediately service queries over that data. This path enables us to serve an accurate, minute by minute picture of events for each app for the last few hours.  

However, calculating metrics over a week or months of data requires a different approach. To accomplish this, Druid periodically moves data from its indexing service to another part of the cluster made up of "historical" nodes. Historical nodes store immutable chunks of highly compressed, indexed data called "segments" in Druid parlance and are optimized to service and cache queries against them. In our cluster, we move data to the historical nodes every six hours. Druid knows how to combine data from both types of nodes, so a query for a week of data may scan 27 of these segments plus the very latest one currently being built in the indexing service.

The results

Our Druid based system now allows us to ingest 100% of the events we receive, so we are happy to report that we are no longer sampling crash data from any of our customers.  The result is more accurate metrics that you can trust to triage stability issues, no matter how widely installed your app is.

While nothing is more important to us than working to ensure you have the most reliable information possible, we also strive to iterate and improve the Crashlytics experience. In addition to helping us improve accuracy, Druid has unlocked an unprecedented degree of flexibility and richness in what we can show you about the stability issues impacting your users. Since the migration, you may have noticed a steady stream of design tweaks, new features, and performance enhancements on our dashboard. For example, here are a few heavily-requested features that we’ve recently rolled out:  

  • You can now view issues across multiple versions of your app at the same time
  • You can view individual issue metrics for any time range
  • You can now filter your issues by device model and operating system

This is just the beginning. We're looking forward to what else we can build to help developers ship stable apps to their customers.

P.S. We're building a mobile platform to help teams create bold new app experiences. Want to join us? Check out our open positions!

Get Crashlytics

Filter crashes by activity segments: improve stability for your most valuable users

by Jason St. Pierre, Product Manager

Here’s the conundrum mobile app teams face: all apps crash, but it’s impossible to fix every single stability issue. In a world with limited time and resources, the million dollar question is – which crashes should you tackle first? Our mission is to help you identify and prioritize issues that have the biggest impact on your app quality.

Since launch, Crashlytics has given you visibility into the downstream effects crashes have on your business by highlighting their severity and prevalence. Today, we’re unveiling an additional lens to show you how stability varies among different user activity segments.

Want to know which crashes are preventing new users from turning into loyal, engaged ones? Want to resolve crashes that are blocking active users from completing key in-app actions? The combined power of Crashlytics and activity segments will show you which crashes are affecting your most valuable users.

Deliver a fantastic new user experience

New users have low tolerance for buggy apps – and a glitchy session can deter them from ever coming back. In fact, 1 out of 4 mobile apps are abandoned after just one use and one of the top reasons for abandonment is technical flaws. Crashlytics will help you make a great first impression by isolating stability issues impacting new users so you can fix them, fast. To see these issues, just select “New Users” on the User Activity tab on your dashboard:

Keep active users happy and engaged

You can also use this filter to improve stability for people that interact with your app on a daily basis. By clicking on “Active Users” or “Highly Active Users," you’ll be able to see which crashes are affecting your most engaged users. These people love your app and keep coming back to it, so reward them with a stellar, stable experience!

Make smarter stability decisions

Crashes by activity segments combines the power of crash reporting with user engagement to surface issues affecting your most valuable users. Now, you’ll be able to see if certain issues are especially prevalent in a specific segment and better prioritize your time.

To see it in action, just hop over to the Crashlytics dashboard and give it a try. We can’t wait to hear what you think!

Get Crashlytics

Supercharge Beta by Crashlytics with fastlane: automate app testing to save more time

By Hemal Shah, Product Manager

Supercharge beta by Crashlytics with fastlane

Feedback that comes early and often is the best way to improve your app experience. Your users are your greatest source of learning (what can I do better?) and inspiration (what should I build next?), which is why it’s such a shame that beta testing is a tedious, tiring, and hair-pulling process.

We built Beta by Crashlytics to fix this by making it easy and straightforward to distribute beta builds to your users. Simplified beta distribution is awesome, but imagine how much more time you’d save if you could also automate it in seconds. Now, all iOS apps using Beta by Crashlytics can harness the power of fastlane to automate beta deployment with a simple, guided setup process!

 

Less tedious work, more time to innovate

A successful beta release involves a lot of steps – you have to bump version numbers, compile the build, append the release notes, distribute it to your testers, alert your team that a build went out, and the list goes on and on. And if that wasn’t enough, sometimes only one person knows how to distribute a beta build, which means you’re tied to their schedule and there is a bottleneck for delivering value to your app users.

Beta by Crashlytics takes the pain out of this process and makes it intuitive and efficient. By installing fastlane, an award-winning mobile deployment toolset, you can automate the tedious tasks that slow down your app development. Say “goodbye” to manual work and spend more time innovating, while still getting a healthy stream of user feedback.

Beta distribution takes only seconds using fastlane:

Beta distribution with fastlane

 

Instant access to all the power and benefits of fastlane

As an added bonus, with fastlane, you’ll also unlock new tools to help you customize your build process and effortlessly release your app to the App Store. Plus, fastlane is fully extensible so you can create and consume actions that automate all aspects of your mobile development – whether it’s working with Git, posting to Slack, etc. – there are 170 built-in actions and 50 third-party plugins to choose from!

Here’s an example of fastlane’s extensibility: We noticed that developers are increasingly forced to use multiple beta distribution services to address different needs. With fastlane, you can use the same process to automate beta deployment to Beta by Crashlytics and stage your build on iTunes Connect. fastlane integrates with the services you already use and love, so everything will still work exactly as you designed it – it’ll just be light years faster and you’ll have more flexibility and control.


lane :beta do
 increment_build_number
 gym                  # Build your app
 testflight           # Upload to TestFlight
end

lane :appstore do
 snapshot             # Generate screenshots for the App Store
 gym                  # Build your app
 deliver              # Upload the screenshots and the binary to iTunes
 slack                # Let your team-mates know the new version is live
end

 

The fastest set-up process, ever

We know that one of the biggest hesitations to adopting a new tool, no matter how incredible it looks, is the fear of a terrible and time-consuming onboarding experience. Nobody wants to spend days connecting everything and making sure it’s set up properly. That’s why we worked hard to make it easy as pie to enhance Beta by Crashlytics with fastlane. This will be the smoothest onboarding process you’ve ever seen.

Want to see for yourself? All you need to do is open up the Fabric Mac app and click on the “fastlane” tab in the top menu. Then, click the “Automate your beta” link and we’ll use existing information about your app to auto-generate your single instruction file (called a Fastfile). From there, just build your app and you’re good to go.

You can even use the same Fastfile to automate taking screenshots and deploying to app stores. And once fastlane is setup, everyone on your team can use it out of the box (no extra knowledge transfer needed!) and it seamlessly works with your CI server.

fastlane + beta onboarding process

 

A better beta experience awaits

User feedback can reveal app issues and opportunities that even the most astute development team may miss – it is the key to meaningful iteration. We care about your success, which is why we invested time and resources to drastically improve the beta testing process. With the combined power of Beta by Crashlytics and fastlane, you can get all the feedback you need in a fraction of the time and effort. And it only takes a few seconds to save precious hours. Upgrade to fastlane today and let us know what you’re building with all of your extra time!

For more information about doing beta deployment through fastlane, check out our quick setup guide.

Introducing OOM reporting: a new dimension to app quality

by Sean Curran, Software Engineer

Stability issues can derail the success of even the best apps – glitchy software repels people. We know that app quality is one of your top priorities and crashes are your worst nightmare, which is why Crashlytics will always alert you when issues arise. We’ll even help you pinpoint their root cause so you can fix issues fast – we’ve got your back!

Today, we’re extending our crash coverage to include out-of-memory (OOM) reporting on iOS. Now, you can see stability from a whole new angle by understanding the impact OOM events have on your app experience.

What’s an OOM event and when does it occur?

Unexpected app terminations degrade your app experience and interrupt your user’s session. One type of app termination you’re probably familiar with is crashes, but there’s another unexpected termination that warrants your attention called an OOM event.

An OOM event is an app termination that occurs when a mobile device runs out of memory. All apps need memory to work, but there is only a finite amount available on each device. When an app needs more memory and there isn’t any available, the operating system terminates the app session. To your users, this looks like any other crash, however in reality, this is an OOM event.

Our approach to solving a hard problem: intelligent heuristics

OOM events are difficult to report because iOS doesn’t provide any direct mechanism to detect them and they can be caused by factors beyond your app environment and control, such as your app’s memory usage. But because of how important it is to understand your rate of OOM events, we took on this challenge and added OOM reporting to Crashlytics for iOS devices.

Here’s how it works: When you enable the Crashlytics and Answers Kits available on Fabric, we get a stream of live data about your app’s performance. Then, we apply a server-side process of elimination to this data stream to detect OOM events in your app. This detection is based on an intelligent heuristic, inspired by the work of two talented engineers. In other words, we analyze your app’s event stream to come up with an explanation of why it terminated and if we can’t match it up it to a known reason for termination, we count it as an OOM event. And, since no changes to the Answers SDK were required, you will automatically get OOM reporting without needing to do any work (as long as you have both Crashlytics and Answers installed).

This is an example of how your app analytics and stability kits can work together to unlock powerful new insight – something neither kit could do alone.

At Pinterest, we're shipping iOS app updates every two weeks to millions of people. Using the new OOM insights, we've been able to track our memory optimizations and have confidence in the stability of each release.

- Scott Goodson, Head of Core Experience


New line of sight into the impact of OOM events on app quality

Our new OOM reporting dashboard will help you understand if OOM events are a problem for your app. Now, you’ll be able to see the overall percentage of app sessions that were unaffected by OOM events across your builds. You can even drill down and see the percentage of OOM-free sessions for individual builds. This will help you answer important questions like, “Is my app being terminated more on one build than another?” and “Is my app seeing more or less OOM-free sessions over the last week?”

We’ll also give you a sortable, daily device breakdown so you can compare the raw OOM counts and the percent of OOM-free sessions across different iOS devices. Once you know which iOS device experiences the most OOM events, you can better triage and spend your time investigating problems on your most used devices. After you roll out a fix, you can monitor the number of OOM events on that device to see if your solution helped reduce them. You may even learn that there are some low-end devices that you simply can’t support.

This additional information paints a clearer picture of your app stability across devices and provides clues for troubleshooting.

Finally, we’ll show you the total number (i.e., the raw counts) of OOM events across all of your builds versus your top three builds. Use this graph to understand the prevalence and magnitude of OOM events.

Don’t let OOM events crash your app party 🎉

Our mission is to ensure that there are no more sad, unstable apps. By adding OOM reporting into Crashlytics, we’re giving you even more insight into the quality of your app. Don’t be blindsided by OOM issues that disrupt your users’ app experiences (and maybe even cause them to flee!). Monitor your OOM-free sessions, promptly identify when OOM events become a problem, and get valuable direction on where to start your troubleshooting by going to the OOMs page from your Crashlytics dashboard. Check it out and let us know what you think!

Get Crashlytics Now