Is slow loading time of your mobile app leading to more than 30% of your users abandoning the app even before reaching the ‘aha’ moment?
Do you hear from engineering that there are multiple API or back-end calls causing this ‘slowness’?
If you are a non-technical PM, are you confused on where to start discussing the next-steps with engineering?
Many PMs console themselves that they are non-technical and should not be bothered to go under the hood to find the underlying reasons. They completely depend upon engineering to tell them the cause and impact of the action. These reasons are then relayed back to leadership / management with an abstraction of the engineering team’s understanding of the reason & actions.
However if you are among those PMs who are curious about tech and want to have a more informed-conversation with your engineering counterparts, here is a framework to look at the 4 key areas that might be contributing to the delays in app launch:
Front-end Analysis:
Analyze what happens on the mobile device itself when the app is launched.
Tools: For iOS, you can use Xcode's Instruments and for Android, Android Profiler in Android Studio can be helpful. These tools can monitor CPU usage, memory, network activity, and more, allowing you to see the impact of API calls on the performance of the app.
Possible Actions: Depending on the results, you could look into optimizing API calls. This might include batching requests together, prefetching data, or implementing a cache to store data locally so it doesn't need to be fetched every time. Also consider making API calls on a background thread to avoid blocking the UI thread.
Network Analysis:
Check the impact of network latency and the size of the responses from your API calls.
Tools: You can use Wireshark, Charles Proxy, or the networking tools provided by the Android Profiler or iOS Instruments to monitor your app's network usage and latency. Firebase Performance Monitoring also has network performance features.
Possible Actions: If network latency is high, consider optimizing your API calls by making them more efficient, reducing payload size, or implementing compression techniques. If the size of the API responses is causing issues, consider ways to reduce this, for instance by returning less data, using more efficient data formats, or implementing pagination.
Also, if you have a multi-country or global app, consider the use of Content Delivery Networks (CDNs) or regional servers to bring data closer to your users.
Back-End Analysis:
Understand the performance of your server-side operations that handle the API requests.
Tools: You can use Application Performance Management (APM) tools like New Relic, AppDynamics, Dynatrace, or even some cloud-provided tools like AWS X-Ray or Google Cloud's Stackdriver can provide detailed insights into server-side processing times.
Possible Actions: If the server-side operations are slow, consider optimizing your server code, database queries, or potentially upgrading your server hardware. If your backend is designed with a microservices architecture, ensure that the communication between services is efficient.
API Design and Management:
Evaluating the API design and its overall management can also be beneficial for impact on the loading times for the mobile app.
Tools: Postman, Swagger, or Apigee can be used to evaluate, test, and manage your APIs.
Possible Actions: f your API design is causing inefficiencies, consider optimizing the API endpoints. Rather than fetching data in multiple small requests, can you fetch the data in one or two larger requests? Consider designing your API for specific views or screens in your app.
What Next: The goal is to identify bottlenecks and focus on the improvements that will provide the most significant performance gains. Hence, align with engineering to put a measure on the effort-impact and stack-rank the actions.