No one thinks about how good the app performance is until it loads slowly. And if it happens, a person might consider looking for alternatives. Especially with a modern-day variety of solutions available: roughly 5.7 million apps in Google Play and Apple App Store as of Q1 2021. Actually, 70% of users leave an app if it takes longer to load. Furthermore, unsatisfied users tend to express their opinion via rating which directly impacts app downloads. Jumping from a two to a four-star average rating can increase app store conversion by as much as 680%! So, it’s quite difficult to underestimate the app performance — the capability to load on various events.
What makes an app effective?As mobile application performance is more comprehensive than just an app speed, you need to keep track of more parameters: • Fast app loading time — up to 2 seconds; • The app is compatible with the devices it is used by (system requirements, screen resolution and so on); • Reasonable memory and battery consumption; • UI and UX make the app easy to navigate and use; • While in the background state, the app doesn’t lose user data and progress; • It is natively and smoothly integrated with the required third-party apps and device services like camera, Bluetooth, calendar, etc.
What causes app performance problems?The common reasons why your application may be far from optimized include those connected to server-side, application main thread and interface.
Server side• Getting large amounts of useless and heavy data from server, frequent HTTP request calls. • API latency, errors, and compression of data.
Main thread• Heavy operations are carried out on the app’s main thread. • Database operations on the main thread of the app, as well inaccurate design of database and data retrieval techniques.
Interface• Incorrect techniques of rendering shadows on the interface elements. Briefly, these are the most frequent and common reasons that cause issues with app performance or why the app may be slow. Often, there are cases unique to every solution.
Mobile app performance optimization check-listBelow you’ll find the list of methods, which work universally to improve your app performance and thus enhance the user experience.
1. Cache data effectivelyTo speed up the application, it is necessary to define files and computations that can be cached. Storing resources and operations in the device hard drive ensures instant access to the app data and eliminates performance issues in case of a network interruption. Define periods for adequate caching. For example, it’s reasonable to cache a product catalogue until its next update by admin while a user profile should be cached for a single user session. At the same time, it is important to maintain a balance between data caching and data loading not to display outdated data to the user. As well, you should not cache everything while there is limited space to store the information.
2. Optimize imagesIt may seem that the bigger the image is the better it for a user. In reality, it makes no sense to use an image of a size larger than it is displayed on the screen. Optimized images and graphic elements help eliminate lags while using the app and improve content loading time on the screen. So, you should better leverage image resizing and compression. Compression allows lowering an image weight without decreasing the resolution. Resizing, on the contrary, means changing the size of a picture to appropriately accommodate it in the app. However, it doesn’t mean choosing the smallest size possible, look for a balance. When a picture is shown in different sizes (profile images, news feed images) — it is better to choose the bigger one so that it is displayed properly everywhere.
3. Reduce mobile app loading time up to 2 secondsBeing the first user-app interaction app launch interval creates a strong impression and impacts greatly user experience. According to various studies and benchmarks, you should be targeting your app launch time of 1,5-2 seconds. To make it happen, it is necessary to monitor whether there are any resource-intensive tasks that are performed at the start of the application. For instance, deleting outdated data from the cache. • Delay any heavy activity not needed for the app to launch until the first screen is rendered. • Load data not at the start of the application, but when opening the required screen (e.g. user profile). • Load data gradually by defining the most important elements to show first and use placeholders for less critical content. ⭐ Go the extra mile — use splash (loading) screens. Such screens don’t improve your app load time, but they give the impression that it is fast and responsive. In cases when an app can’t load fast enough, the user won’t think it is frozen. Plus, they maintain your brand integrity and in some cases create wow-effect.
Uber splash screen by Bryant Jow for Uber
4. Maintain the high quality of the code• Keep the code up to date and remove unused frameworks. Outdated and extraneous code adds to your app launch duration. • Monitor memory leaks and eliminate them at the earliest opportunity. Otherwise, if unnecessary objects cannot be removed from RAM (random access memory), the system shuts an application down due to lack of memory. Use a memory profiler to track objects’ lifecycle and optimize memory usage. • Render shadows properly. This means calculating the size of the shadow and its characteristics once instead of drawing multiple times when moving around the screen. As the techniques differ for each platform, we recommend looking for best practices on your specific platform. • Prioritize operations and minimize heavy activity initialization which can create bottlenecks. Remove blocking work from the main thread to background threads to be performed asynchronously. • Monitor app energy consumption on various operation stages: while the app is operating or in the background mode. • Create offline mode to maintain data access in the case of loss of network connection. It ensures information security, reliability, and user comfort. Some of the best practices include delivering the content and functionality users need offline by analyzing user behaviour, saving users’ in-app progress, indicating if the network state is offline, designing an empty state for offline usage. Also, it is beneficial for music players and maps to allow users to download content to work offline. • For iOS apps: Minimize the number of offscreen calculations. It may happen when you add some visual effects (e.g. shadows, rounded corners or masks) in your app. In such cases, performance might be harmed by offscreen rendering.
5. Optimize client-server interaction• Design client-server API in the way that a user doesn’t get unnecessary data. Divide content and objects by purpose and request them when appropriate. This approach helps to reduce data amount loading, which results in faster app load. • When designing and developing the API, always keep in mind that people use not only 4G connection, but also 3G and even slower and less stable connections. To adapt to such cases, divide complicated requests into smaller ones to perform gradually and test your app on a poor network. • Use CDN (content delivery network) to reduce data load time by decreasing the distance between a user and data source.
• Implement a pagination mechanism for large amounts of data. For example, instead of loading a hundred items in the news feed simultaneously, display the first ten and then load as the user scrolls down or switches pages. • Avoid redirects while app launching as it increases the time of delivering data to end-user.