Contents
App performance optimisation starts with four metrics: startup time, UI smoothness, battery consumption and memory usage. Slow or power-hungry apps receive worse ratings and get uninstalled more often, usually without users telling you why. The golden rule: measure first, then optimise – on real devices, including older ones.
The four dimensions of app performance
"The app is slow" is common feedback that, on closer inspection, breaks down into very different causes. A clear classification helps:
| Dimension | What users notice | Typical causes | Measuring tools (examples) |
|---|---|---|---|
| Startup time | Long white screen or splash screen | Too much initialisation at launch, synchronous network calls, heavy SDKs | Xcode Instruments, Android Studio Profiler, startup metrics in Play Console |
| Rendering | Janky scrolling, delayed animations | Work on the main thread, overly complex layouts, unnecessary redraws | Frame analysis, Flutter DevTools, React Native Performance Monitor |
| Network | Long spinners, empty lists | Many round trips, large payloads, missing caching | Network profilers, proxy tools, server-side tracing |
| Battery and memory | Device gets warm, app crashes in the background | Continuous GPS, frequent polling, memory leaks, large images in RAM | Energy profilers, Android Vitals, memory graph |
Set a budget for each dimension, such as "start screen in under two seconds on a three-year-old mid-range device". That turns performance into a testable requirement instead of a gut feeling.
Shortening startup time: first impressions count
Startup is the moment users decide whether an app feels "fast". Proven measures:
- Clean up initialisation: check which SDKs load at launch. Analytics, advertising or chat widgets can often be initialised later.
- Nothing blocking on the main thread: database access, file operations and network calls belong on background threads or in asynchronous tasks.
- Show first, then load: display cached data or placeholders (skeleton screens) immediately and refresh in the background.
- Use platform optimisations: on Android, Baseline Profiles help apps start faster; on iOS, review dynamic frameworks and work done before the first frame.
- Watch the app size: remove unused resources and libraries. Smaller apps install faster and often start faster too.
A smooth UI: rendering and lists
For smooth visuals the app must finish each frame within a few milliseconds, and devices with higher refresh rates leave even less time. The most common causes of jank and their fixes:
- Long lists: always use virtualised lists (e.g.
LazyColumnin Jetpack Compose,Listin SwiftUI,ListView.builderin Flutter,FlatListor faster alternatives in React Native) so only visible items are rendered. - Images: deliver images at the right size from the server in modern formats such as WebP or AVIF, decode them in the background and cache them.
- Unnecessary redraws: in declarative frameworks, unstable state or oversized components cause more recomputation than needed. Keep state as local as possible.
- Bridge and thread switches: in cross-platform apps, animations should run on the native or UI thread wherever possible.
Which technology offers which performance headroom is discussed in native vs. cross-platform apps. For most business apps both approaches are fast enough when implemented well.
Network and data: fewer round trips, more caching
Much of the perceived slowness is not created on the device but between device and server. The most effective levers are therefore often in the backend:
- Design endpoints so a screen needs one or only a few requests.
- Compress responses and return only the fields that are needed.
- Use HTTP caching and ETags; distribute static content via a CDN.
- Keep data locally so the app doesn't reload everything on every launch.
- Track down slow database queries (such as N+1 problems) with server-side tracing.
More detail is available in API design for mobile apps and our article on offline-first apps – a local database makes apps not only offline-capable but also noticeably more responsive.
Saving battery and memory
iOS and Android show battery usage per app in the system settings, so users quickly see which app drains their battery. The most important measures:
- Use location sparingly: only as precise and as often as necessary. Significant location changes or geofences are enough for many use cases instead of continuous GPS.
- Push instead of polling: rather than asking the server every few seconds, use push notifications or batched background tasks.
- Batch background work: WorkManager on Android and Background Tasks on iOS let the system schedule work energy-efficiently.
- Find memory leaks: unreleased listeners, reference cycles and oversized image caches cause crashes, particularly on devices with little RAM.
- Clean up local storage: limit caches and delete old files so the app doesn't silently grow on the device.
Keeping performance high: measuring in production
Optimisations evaporate if new features undo them. Make performance part of your development process:
- Add performance budgets as acceptance criteria to user stories.
- Test on a fixed set of real devices, including at least one older Android device.
- Integrate automated measurements, such as startup benchmarks, into the CI pipeline.
- Analyse field data: Android Vitals, Xcode Organizer and monitoring tools show how the app performs for real users.
- Treat regressions like bugs and prioritise them.
How to spot crashes and performance issues before users report them is covered in app monitoring and crash reporting.
Agentic coding workshop for your team? From €799 net – request a quote by e-mailConclusion
Optimising app performance is mostly about working systematically: measure startup, rendering, network as well as battery and memory separately, set budgets and fix the biggest bottlenecks first. Often a handful of measures – deferred initialisation, virtualised lists, properly sized images and a lean API – deliver the largest gains. Whether you are planning a new app or want to speed up an existing one, our offer wizard leads to a fixed-price quote after a free analysis.
Frequently Asked Questions
How fast should an app start?
There is no fixed standard, but users perceive one to two seconds until a usable screen as pleasant. Define your own budget and measure it on older devices.
Are cross-platform apps slower than native apps?
For typical business apps the difference is barely noticeable when implemented well. Native development has advantages for graphics-heavy applications or functionality that is very close to the hardware.
Why does my app use so much battery?
Common causes are continuous location tracking, regular server polling and unnecessary background activity. An energy profiler shows which component is responsible.
Is it worth optimising the performance of an existing app?
Usually yes, if ratings or usage data point to problems. An analysis quickly shows whether a few targeted measures are enough or larger changes are needed.