React Native Performance Optimization: 15 Proven Techniques

A slow React Native app is rarely slow because of React Native itself. In most audits we run, the causes are familiar: lists that render too much, components that re-render on every keystroke, animations running on the JavaScript thread and oversized images. This guide collects 15 proven React Native performance optimization techniques, grouped by the problem they solve, so your team can find and fix the bottlenecks that matter.
It is written for CTOs, tech leads and product managers who want to understand what good performance work looks like, and for developers who want a checklist. The official React Native performance overview is a useful companion.
Start Here: Measure Before You Optimize
Always measure in a release build on a mid-range Android device before changing code. Debug builds are much slower and will mislead you.
1. Profile with the right tools
Use React Native DevTools and the React Profiler to find components that render too often, the built-in performance monitor to watch frame rates on the JS and UI threads, and Android Studio or Xcode Instruments for native CPU and memory. Write down baseline numbers, such as cold start time and frames dropped while scrolling a key list, so you can prove each fix helped.
Engine and Architecture
Staying on a current React Native version gives you the biggest free performance gains. Hermes and the New Architecture both target startup time and responsiveness.
2. Use Hermes
Hermes is a JavaScript engine built for React Native. It precompiles JavaScript to bytecode at build time, which improves startup and reduces memory use. It is the default in modern versions; if an older app has it disabled, enabling it is often the quickest win.
3. Move to the New Architecture
The New Architecture (the Fabric renderer, TurboModules and JSI) replaces the old asynchronous bridge with direct, synchronous communication between JavaScript and native code. It is the default for new projects in recent releases. Upgrading older apps takes planning because some third-party libraries need updates, but it removes a whole class of bridge-related lag.
Rendering and Re-Renders
Unnecessary re-renders are the most common cause of sluggish React Native screens. The fix is to render less, less often.
4. Prevent unnecessary re-renders
Wrap pure components in React.memo, and use useMemo and useCallback for expensive calculations and callbacks passed to memoized children. The React documentation explains when memoization helps and when it adds overhead. The React Compiler can automate much of this in supported setups.
5. Keep state close to where it is used
A single global context that changes often forces large parts of the tree to re-render. Split contexts by concern, use state libraries with selectors so components subscribe only to the data they need, and keep fast-changing values like form input local.
6. Avoid inline heavy work in render
Sorting, filtering or formatting large arrays inside the render function repeats that work on every render. Compute once, memoize or move it to the data layer.
Lists, Images and Animations
Long lists, large images and JavaScript-driven animations cause most visible jank. These three fixes usually deliver the improvements users notice first.
7. Virtualize and tune long lists
Never render long lists with ScrollView and map. Use FlatList or SectionList, provide stable keyExtractor values and, for fixed-height rows, getItemLayout. Tune initialNumToRender and windowSize, and keep row components light and memoized. For very large or complex feeds, Shopify’s open-source FlashList recycles views and often scrolls more smoothly.
8. Optimize images
Serve images at the size they are displayed, use modern formats such as WebP, and use an image component with disk caching, such as expo-image. A grid of full-resolution photos can exhaust memory on mid-range Android phones.

9. Run animations on the UI thread
Animations driven from JavaScript stutter whenever the JS thread is busy. Use the native driver for the Animated API where supported, or Reanimated, which runs animation logic on the UI thread. Gesture-driven interactions benefit most.
10. Use native navigation primitives
Use a native stack navigator backed by react-native-screens so each screen uses native containers and transitions. Avoid keeping many heavy screens mounted in the background.
Startup Time and Bundle Size
Users judge an app within seconds of opening it. Reducing what loads at startup is the key to a fast first screen.
11. Load less at startup
Lazy-load screens and heavy modules that are not needed for the first screen, enable inline requires in the Metro bundler, and defer analytics and non-critical SDK initialization until after the first render. Audit dependencies regularly; large libraries used for one helper function are common.
12. Strip debug code from production
Excessive console.log calls slow the JS thread, especially when logging large objects. Remove them in release builds with a Babel plugin, and make sure development-only tools are excluded.
Native Work, Data and Monitoring
The last group covers heavy computation, network behavior and keeping performance good after release.
13. Move heavy computation off the JS thread
Image processing, encryption, large JSON parsing and complex calculations can block the JS thread. Move them to native modules (TurboModules or JSI-based libraries) or background threads so the UI stays responsive.
14. Make networking and data efficient
Paginate large datasets, cache responses with a data-fetching library, avoid refetching on every focus, and store frequently used data locally. Our guide to offline-first mobile apps covers local storage and sync patterns that also make apps feel faster.
15. Monitor performance in production
Lab tests do not capture every device and network. Add production monitoring for crashes, slow screens, app start time and memory issues, and add performance checks to your release process so regressions are caught before users see them. Our guide to mobile app testing explains how to fit this into QA.
Which React Native Performance Optimization to Do First
Prioritize by user impact and effort. In most apps, this order gives the fastest results:
| Priority | Technique | Typical effort |
|---|---|---|
| 1 | Profile in release builds and set baselines | Hours |
| 2 | Enable Hermes, remove console logs | Hours |
| 3 | Fix long lists and image sizes | Days |
| 4 | Cut re-renders with memoization and state structure | Days |
| 5 | Move animations to the UI thread | Days |
| 6 | Reduce startup work and bundle size | Days to weeks |
| 7 | Upgrade to the New Architecture | Weeks, depending on libraries |
Set a Performance Budget to Keep Gains
A performance budget is a set of agreed limits that every release must meet. Without one, apps tend to slow down again within a few months as features are added.
Choose a handful of measurable targets on a named reference device, for example a mid-range Android phone two or three years old. Typical budget items are cold start time to the first usable screen, smooth scrolling on the busiest list, JavaScript bundle size and peak memory on image-heavy screens. Record the numbers in each release’s QA report, and treat a breach like a failing test: either fix it or make a conscious, documented decision to accept it. Product managers should own the budget alongside engineering, because most regressions come from new features rather than refactoring. Folding this into regular upkeep is far cheaper than an emergency audit; our guide to app maintenance costs shows how to budget for it.
Frequently Asked Questions
Is React Native fast enough for production apps?
Yes. Well-built React Native apps feel smooth for the vast majority of business and consumer use cases. Performance problems usually come from implementation choices, which the techniques above address.
Why is my React Native app slow on Android but fine on iOS?
Android devices vary much more in CPU and memory, and many users have mid-range or budget phones. Test on those devices, and focus on list rendering, image sizes and JS thread work, which affect lower-end hardware most.
Should we rewrite our app in native or Flutter to fix performance?
Rarely. A targeted performance audit and fixes typically cost a fraction of a rewrite. Consider switching only if your core feature needs capabilities React Native handles poorly; our native vs cross-platform comparison can help you judge.
Does Expo hurt performance?
No. Expo apps compile to standard native apps, and the Expo documentation supports Hermes, the New Architecture and custom native code. Performance depends on how the app is built, not on using Expo.
Get a React Native Performance Audit
Sigmato’s React Native development team in Bengaluru and the UK profiles existing apps, fixes bottlenecks and handles version upgrades. If you need extra hands on your own team, see our guide to hiring React Native developers.