App Performance Optimization: Faster Startup and Scrolling

People judge an app within seconds. A slow launch, a stuttering list or a screen that freezes while loading makes the product feel unreliable, and users uninstall quickly. Performance is not a technical luxury. It is a core part of user experience, and it influences ratings, retention and revenue.

This guide covers where mobile apps typically lose speed and how to fix it.

Measure before you optimise

Guessing wastes time. Use the profiling tools built for each platform.

• iOS: Xcode Instruments (Time Profiler, Allocations, Energy Log) and MetricKit for real-user data
• Android: Android Studio Profiler, systrace/Perfetto, and Android vitals in the Play Console
• Cross-platform frameworks: their own performance overlays and DevTools, plus the native profilers

Always test on real, mid-range or older devices, not just the latest flagship, because your users’ phones are likely slower than yours.

Key metrics to watch

Metric	What it tells you
Cold start time	How long from tapping the icon to a usable screen
Frame rate / jank	Smoothness of scrolling and animation. Aim for consistent 60 frames per second (about 16 ms per frame), or higher on faster displays.
Time to interactive per screen	How soon each screen responds
Memory use	Risk of slowdowns and crashes
Battery and thermal impact	Hidden cost to users
App size	Download and install friction
Crash and ANR rates	Stability, which Google and Apple both surface

1. Speed up app startup

Startup is the first impression.

• Do less on launch. Defer anything not needed for the first screen, including analytics setup, large data loads and optional SDKs.
• Avoid heavy work on the main thread during startup
• Lazy-initialise services when first used
• Show a lightweight first screen or skeleton quickly, then fill in content
• Reduce the number of third-party SDKs that initialise at launch

2. Keep the main thread free

The main (UI) thread draws the interface and handles input. Anything slow on it causes dropped frames and unresponsive taps.

• Move networking, disk access, parsing and image decoding to background threads
• Break up long tasks
• Avoid synchronous waiting for results
• Watch for expensive layout calculations and overdraw

3. Make lists and scrolling smooth

Lists are where jank usually appears.

• Use recycling/virtualised lists (RecyclerView, UICollectionView, FlatList or equivalent) that render only visible items
• Keep cell layouts simple and avoid deep view hierarchies
• Pre-compute expensive values instead of calculating them while scrolling
• Load images asynchronously with placeholders
• Paginate data so you do not load thousands of rows at once

4. Handle images efficiently

• Request correctly sized images from the server, not full-size originals
• Use modern formats where supported
• Cache decoded images in memory and on disk
• Cancel loads for images that scroll off-screen
• Compress assets bundled with the app

5. Optimise networking

Network delays are often the biggest source of waiting.

• Reduce number of requests and payload sizes. See API design for mobile.
• Use HTTP caching and local caching of data
• Prefetch what users are likely to need next
• Show cached content immediately and refresh in the background
• Handle slow and offline conditions gracefully. See offline-first apps.
• Use compression and efficient formats

6. Manage memory

Excessive memory use slows the app and can cause the OS to terminate it.

• Fix leaks (objects that are never released), especially in listeners, closures and singletons
• Release large resources when screens close
• Avoid keeping big collections or bitmaps in memory
• Respond to memory warnings

7. Be kind to the battery

Users notice apps that drain power.

• Minimise background work, polling and location updates
• Batch network requests and use push instead of constant polling
• Use platform scheduling APIs for deferred tasks
• Avoid wake locks and unnecessary sensors

8. Reduce app size

Smaller apps download faster, install more often on constrained devices and update more smoothly.

• Remove unused code and resources
• Compress assets and use vector graphics where suitable
• Use platform features that deliver only the resources a device needs (App Thinning on iOS, Android App Bundles)
• Audit dependencies, since a single large library can add megabytes

9. Test performance continuously

• Add performance tests and benchmarks to your pipeline for startup and key screens
• Set budgets (for example, maximum startup time) and fail builds that exceed them
• Test on slow networks and low-end devices. See how to test a mobile app.
• Review performance for every release

10. Monitor real users

Lab tests cannot cover every device and condition. Collect real-world data on crashes, ANRs, slow starts and frame drops using crash reporting and performance monitoring tools, and track them by device model, OS version and app version. Prioritise the issues affecting the most users. Better performance also supports retention.

Common mistakes

• Optimising without profiling
• Testing only on high-end phones
• Doing network and disk work on the main thread
• Loading everything at startup
• Ignoring memory leaks
• Adding SDKs without measuring their cost

Checklist

• Baseline measured on real mid-range devices
• Startup work minimised and deferred
• Heavy work moved off the main thread
• Lists virtualised; images sized and cached
• Network requests reduced and cached
• Memory leaks fixed
• Battery impact reviewed
• App size audited
• Performance tests and real-user monitoring in place

Final thoughts

Fast apps feel trustworthy. Measure first, fix the biggest bottleneck and verify the improvement on real devices. For help building high-performance apps, see our app development service or contact us.