Performance is the feature users notice most but talk about least. Nobody says "I love this app because it loads fast." But they absolutely delete apps that don't.
Here's what we've learned from building 25+ mobile products.
The Metrics That Actually Matter
Forget vanity metrics. These are the numbers that correlate with retention:
- Time to Interactive (TTI): Time from app open to usable state. Target: under 2 seconds.
- Frame rate: 60fps for scrolling and animations. Users notice drops below 50fps.
- App size: Every 10MB over your category average increases uninstall probability.
- Crash rate: Under 0.1% of sessions. Anything higher tanks store ratings fast.
The Cold Start Problem
Cold start (launching an app from scratch) is where most performance problems are visible. Common culprits:
- Heavy dependencies initialized synchronously — move non-critical initialization off the main thread
- Blocking network calls on startup — use cached data while fetching fresh content
- Unoptimized launch screen — use a static snapshot, not a spinning loader
- Large initial bundle — defer loading of non-critical screens until after first interaction
Images Are Usually the Bottleneck
In our experience, image handling causes more performance issues than any other single factor:
- Use the right format: WebP for photos, SVG for icons, AVIF where supported
- Lazy load aggressively: Only load images within the viewport plus one screen ahead
- Size images correctly: Serve 2x images for retina displays, 1x for standard — don't serve 3x to everyone
- Cache at multiple layers: Memory cache for recently viewed, disk cache for persistence across sessions
Animation Performance
Janky animations are immediately noticeable and make an app feel broken. Rules we follow:
- Animate only
transformandopacity— these are composited on the GPU and don't trigger layout recalculation - Avoid animating
height,width, ormargin— these cause expensive layout passes - Use native driver (React Native) or platform animations — keep animation work off the JS thread
- Measure with real devices — emulators hide GPU bottlenecks entirely
Network Efficiency
Mobile networks are unreliable. Design for it:
- Optimistic UI: Apply user actions immediately in the UI, sync to server in the background
- Offline-first architecture: Core features should work without a connection
- Request batching: Combine multiple API calls where possible to reduce round-trips
- Request only what you need: Use GraphQL or field-specific REST endpoints to avoid over-fetching
Profile Before You Optimize
The cardinal rule: measure before you fix. Use:
- Xcode Instruments for iOS profiling (Time Profiler, Allocations, Leaks)
- Android Profiler in Android Studio for CPU, memory, and network
- Flipper for React Native app debugging and performance inspection
- Real device testing on a mid-range device on a cellular connection — that's your real user
Profile in release mode. Debug builds are always slower and will mislead you.
Building a mobile app and concerned about performance from day one? Talk to us — performance architecture is something we plan before writing the first line of code.