Smart mobile teams know that delivering a 5-star app is more than just finding a good business use-case and designing an app with wow experience; it’s also about ensuring amazing app performance. Apps that perform well will engage the customer — poor app performance is a sure fire way to lose the customer and their business.
To deliver a first-rate app performance, mobile teams have to master the many variables which affect performance:
- Mobile OS/devices: The various OS-es (Android, iOS, etc.) and device form-factors (smartphone, tablets, IoT devices, etc.) have unique performance characteristics that will affect app performance. A good mobile team optimizes for the OS and the platform
- Mobile networks (WiFi, 2G/3G/4G) that provide the data connectivity: The average mobile app can be used on 10-20 networks (from various service providers and in various geographies) and it’s critical to ensure performance across all these networks.
- API’s and services: API’s provide the core functionality of the app. Hence, the performance of the app is very dependent on the performance of third-party APIs. On average, a mobile app uses 5-10 API’s to provide its functionality.
- Modern applications: The API’s are powered by back-end applications. These modern applications are complex with microservice architecture and abstractions like containers, virtualization, and cloud. It’s not uncommon for an application to have hundreds of components.
With so many failure points (millions if you do the math!), it’s no wonder mobile teams focus more on the mobile ecosystem challenges and pay less attention to (or ignore) the back-end applications that supports the API. After all, “doesn’t the IT Ops manage the application?” is the constant reprise from most mobile teams.
But with the stakes of app performance so high, is this the right approach? In this blog, let me highlight three challenges with this approach and explain why end-to-end application-to-app performance management is critical for entire app experience.
1. Mobile transaction = app-application transaction
Mobile transactions are built on API’s powered by the application. So in effect, mobile transactions and their performance are tied to the performance of the back-end application. Mobile teams need to thoroughly understand these dependencies to manage the customer interactions in a more holistic manner. Only with an end-to-end app-to-application transaction visibility can mobile teams address questions such as:
- What services and components (app servers, DB, servers, etc.) support the order processing transaction in the mobile app? What components should we focus on when the transaction performance has degraded?
- What will be the effect of upgrading or changing a particular application component? What mobile transactions would it affect?
2. Proactive performance management and faster root cause analysis
With end-to-end visibility comes better monitoring and management. Now Ops and mobile teams can proactively identify app issues before it affects the end-user and quickly get to the root cause of issues after issues have been identified. For example, it now becomes easy to triage performance issues in these situations:
- We made a change to the API servers. Is it improving or hurting the app performance?
- We are seeing more app crashes in the order processing transaction. What services/components should we focus on?
- Why is the checkout transaction slow? Which supporting components have performance issues?
3. Isolate effects of change and releases faster
In the mobile world, change happens all the time; in fact, 2-week app release have
become the norm now. To support the new app functionality, the back-end applications are also changing at a very rapid rate. With different teams managing the app and the application tiers, the change and release management process may seem a bit chaotic and may cause performance issues (after all, changes are responsible for 80% of all application health issues). So it is even more imperative to track all the changes across the application and the app tier. The app-application dependency needs to be tracked and mapped dynamically. The teams also need an integrated approach for change and performance management that makes it more effective to collaborate and identify change-related issues faster. Having an end-to-end app-to-application view will ensure this view and help address questions like:
- The app performance has degraded. Is it because of the app or the application release?
- How has the latest upgrade of the app/application affected the app performance.
In summary, app performance is extremely critical. 86% of users will delete an app after one poor experience. With such a high bar, it is vital that mobile teams focus on end-to-end app performance management to leave nothing to chance.
AppDynamics provides comprehensive end-to-end mobile app performance management. Not only does it monitor app issues like crashes, slowness, latencies, etc., but it also correlates these app issues to back-end application health. With this comprehensive visibility, customers can proactively manage performance and quickly identify the root cause of issues, thus ensuring amazing mobile experience.
If you want to try out the AppDynamics mobile solution, click here.