It's been a long time since the sentence "Android devs, we are blind" had come to us. But that was before we started developing FlowUp, a real-time app performance monitoring platform.

For years developing and deploying Android apps to Google Play has been a ritual and a routine. First, we develop the code, then we prepare the version and right after we deploy it. Once the app is live, we would wait for users to update to finally be able to check the crash reporter and begin to find out what's going on.

But other than gaining awareness about the amount of crashes or events related to the product usage, we have absolutely no clue about the state of our application in production. We had no idea about our application performance in terms of some key aspects like:

Frames per second of every activity.

The time needed to execute the activity lifecycle.

CPU consumption.

Memory consumption and the amount of bytes allocated.

Network traffic.

Database usage or shared preferences usage.

Of course, all filtered with a breakdown information by:

Application version name.

Device model.

Android OS version.

Screen name.

Screen size or density.

Network quality.

Whenever you are able to, go ahead and ask your developer for such information filtered by every single device model or Android OS version where the app could possibly be executed. Ask if the current version consumes more CPU or less memory, if the network usage has increased or decreased in the last release over the previous ones. If you are an Android developer, then ask yourself right away.

We were completely blind! We had no idea about what's the CPU/Memory average consumption of the app we are developing, or the size of the database or the shared preferences we use everyday. I'm afraid most of us has no idea. In the best case scenario, if we don’t have a really big/try catch, we could know the number of instances our application is crashing. But don't worry, we all have been there and it’s ok. We had no tools to know what's going on with our app other than the Android Studio monitor or some tools like systrace. These tools are meant to evaluate the usage of an application installed in a device controlled by the developer. However, that's not the scenario where our application is going to be executed everyday. Most of the time, our application is not going to be executed in a Pixel with a single running process at a time. Our app is going to be executed in more than 15.000 different devices with different hardware capabilities and Android OS versions by a vast amount of radically different users.

Given all these different scenarios related to hardware configuration, Android OS versions and users, we decided to throw some light to the Android development world. We decided to develop a platform where an Android developer would easily know if the application is performing better than the previous version in production for every single device for every single user. We could know what's the Activity with the worst frame time, or the memory consumption in terms of bytes allocated by device model or the network data consumed by the app. If our new application version is draining the app user battery. Now you can offer all this priceless information to the user by adding one line of code to your Application class.

FlowUp.Builder.with(this).start("<YOUR_FLOW_UP_API_KEY>");

This is just a temporary home dashboard we used during the development stage.

FlowUp is still under development, but we will release the first beta version soon. We strongly recommend you to register into our private beta program to be among the early birds with access to our first release. We have a very limited number of API keys for our private beta program.

From developers to developers, we are working really hard to bring you FlowUp, a real-time app performance monitoring platform. Our mission is to empower developers with a powerful world-class tool to help you develop and maintain Rock-Solid applications. Stay tuned!