Optimize React Native Flatlist: ProCoders’ Performance Hacks in Several Steps

Close-up of a thumb swiping on a phone in a blue case

React Native lets you build mobile apps for iOS and Android from one JavaScript and React codebase. Many companies, including some we have worked with here at ProCoders, choose it because the apps feel native without the cost of two separate teams. If you are weighing React against its web sibling first, our overview of the advantages of React JS covers the shared ground.

One codebase does not make an app fast by default. Apps built without performance in mind feel slow, use too much memory and drain the battery faster than users accept. The difference between a smooth app and one people delete is often a handful of habits applied early.

At ProCoders we have helped clients tune React Native apps, and this article collects the optimization hacks that keep paying off. We have updated it for current React Native: the New Architecture is the default, Hermes is the default engine, and React Compiler can now handle some of the memoization we used to do by hand.

React Native General Performance Optimization

Avoid Inline Functions

Inline functions in JSX look convenient but cause extra work. Every render creates a new function, React sees a changed prop, and memoized children render again for nothing. This matters most inside list items, where the cost repeats for every row.

ProCoders Hack: Wrap handlers in useCallback() in function components so they are only re-created when their dependencies change. If your project uses React Compiler, which reached 1.0 in October 2025, it memoizes most of this for you, but keep the habit for handlers passed into list rows and into libraries that compare props by reference.

Optimize Render Cycles

Unnecessary re-renders are one of the biggest causes of lag in React Native apps. React.memo lets a component skip rendering when its props have not changed. This pays off most in list items and screens that sit under frequently updating state.

ProCoders Hack: For components with complex props, pass a custom comparison function to React.memo or restructure the data so a shallow comparison is enough. Measure first: memoizing everything adds comparison cost of its own.

Need a team that profiles on real devices before release? Tell us about your app and get an estimate.

React Native Image Optimization Tips: Cached Optimized Images

Lazy Loading Images

Loading every image at once raises memory use and slows the first screen. Load images only when they are about to appear, and cache what you have already downloaded so scrolling back is instant.

ProCoders Hack: The expo-image component works in bare React Native projects as well as Expo ones, and it caches downloaded images on disk by default. Many older codebases use react-native-fast-image for the same job. If you are starting fresh, check that any image library you pick is maintained for your React Native version.

Use Proper Image Formats

The right format makes a visible difference in load time. WebP files are usually much smaller than PNG or JPEG at similar quality, which cuts download time. Decoded memory depends on pixel dimensions, so resize images too.

ProCoders Hack: Serve images at the size they are displayed, ideally resized on the server or CDN. For images users upload in the app, use a library such as react-native-image-resizer to resize and compress before upload, so the backend and every other client get smaller files.

React Native Optimization Hacks: Large Lists

FlatList Performance Optimization

Rendering a large dataset in one go is a common bottleneck. A ScrollView renders every child at once. A FlatList renders items lazily, which keeps memory use and start time under control. It is built on VirtualizedList, and the same tuning props apply to SectionList.

These props do most of the work:

  • initialNumToRender sets how many items render on the first pass. Set it to what fits on one screen, no more.
  • maxToRenderPerBatch limits how many items render per batch while scrolling. A higher number reduces blank areas but occupies the JavaScript thread longer.
  • updateCellsBatchingPeriod sets the delay between batches. A longer delay means fewer renders and a higher chance of blank space on fast scrolls.
  • keyExtractor gives each row a stable key, so reordering and updates reuse the right rows. Use an id from your data, not the array index.
  • removeClippedSubviews detaches off-screen views to reduce native rendering work. It can cause glitches such as missing content on some layouts, so test it on a low-end device before you ship it.

The React Native team documents these props and their trade-offs in its guide to optimizing FlatList configuration.

ProCoders Hack: Tune one prop at a time and test on a low-end Android phone, not a flagship or a simulator. Blank areas while scrolling and dropped frames show up there first. Also make the row its own memoized component and keep renderItem stable with useCallback instead of an anonymous function.

Virtualization of Lists

For very long lists, virtualization is what keeps the app responsive. FlatList and SectionList render only the items in and near the viewport. windowSize controls how far beyond the viewport they render, measured in viewport heights. The default is 21: ten screens above, ten below and the one you see. A larger value means less blank space and more memory use. A smaller one saves memory and shows blanks sooner.

When rows have a uniform height, getItemLayout removes the need to measure each one, which speeds up rendering and makes jumps with scrollToIndex reliable. Keep rows light too: fewer nested views, smaller images and no heavy effects.

If tuning FlatList is not enough, look at Shopify’s FlashList, which keeps a similar API and recycles row views instead of creating them. Swap it into one heavy screen first and compare the numbers before you migrate the rest.

ProCoders Hack: Show skeleton placeholders while data loads. A simplified version of the list rows keeps users engaged and hides the wait on slow networks. Libraries such as react-native-skeleton-placeholder make this quick to add.

React Native Apps Performance by Reducing App Size for a Big Performance Boost

Code Splitting and Bundle Optimization

A smaller bundle starts faster. Defer heavy screens and modules until they are opened, and remove code the app never uses, and the app stays quick as it grows. Teams that hire React Native developers to scale an app should expect this audit early: find what ships in the bundle and does not need to.

ProCoders Hack: Run react-native-bundle-visualizer to see which modules take the most space, then replace the biggest ones or defer their initialization. Hermes, the default engine, compiles your JavaScript to bytecode at build time, which helps startup, but it does not make an oversized bundle small.

Minimize Third-Party Libraries

Every dependency adds weight to the bundle and to the native binary, and each one is code you must keep updated. Be selective, and remove packages nobody imports anymore.

ProCoders Hack: Prefer a lightweight alternative or a small custom helper when a library is used for one function. A dependency that is no longer maintained costs more later, because it can block a React Native upgrade.

Slow screens, large bundles or a laggy list? Our React Native engineers can review the app and tell you where the time goes.

React Native Performance Improvement: Memory Management

Avoid Memory Leaks

Memory leaks slow an app down over a long session. Unmounted components keep event listeners, timers and subscriptions alive, and the memory is never released.

ProCoders Hack: Return a cleanup function from every useEffect that subscribes to something, and clear timers and intervals there. In class components, do the same in componentWillUnmount. Cancel in-flight requests with AbortController when a screen closes.

Clear Unnecessary State

Efficient state management helps memory too. State that nothing reads still lives in memory, and it can trigger renders.

ProCoders Hack: Keep state as local as it can be, and when several values change together, consider useReducer instead of many useState calls. It keeps related updates in one place and makes the state easier to reason about.

How to Optimize React Native Apps: Optimize Animations

Use Native Driver for Animations

Smooth animations matter for how an app feels, and they are expensive. The useNativeDriver option sends animation work to the native side, so animations keep running when the JavaScript thread is busy. It supports transform and opacity, not layout properties such as width or height.

ProCoders Hack: For gestures and complex animations, use react-native-reanimated, which runs animation logic on the UI thread and gives you more control than the built-in Animated API.

Minimize Re-renders during Animations

Re-renders during an animation cause dropped frames and visible stutter.

ProCoders Hack: Postpone non-critical work, such as analytics calls or heavy data processing, until the animation finishes, for example by starting it from the animation’s completion callback.

React Native App Optimization Tips: Efficient State Management

Use Context API or Redux Wisely

State management is where many hidden re-renders start. With Context or Redux, limit how many components subscribe to state changes. Every subscriber re-renders when the value it reads changes.

ProCoders Hack: In Redux, use selectors that return only the slice a component needs, and connect only components that need the store. Split large contexts into smaller ones so an update to one value does not re-render the whole tree.

Don’t Overuse Context

Context is a good tool for values that change rarely, such as theme, locale or the current user. Put fast-changing data in it and large component trees re-render on every update.

ProCoders Hack: Memoize components that sit under a context provider with React.memo, and read context with useContext only in the components that need the value. For frequently changing state, use a store with selector support.

Want an engineer who already knows where React Native apps lose frames? We can have a shortlist to you in 72 hours.

React Network Request Optimization

Cache Network Requests

Frequent network requests slow the app and use data and battery. Caching API responses helps most for data that rarely changes.

ProCoders Hack: Use TanStack Query (formerly React Query) to cache, deduplicate and refetch requests in the background. Repeated calls then return cached data instantly, and the screen shows fresh data when it arrives.

Debounce Input

A search field that fires a request on every keystroke wastes bandwidth and re-renders the screen. Debouncing waits until the user pauses typing before sending the request.

ProCoders Hack: Use lodash.debounce or a small custom hook that delays the action. Pair it with request cancellation so an old response never overwrites a newer one.

ProCoders React Native Tips: Use Proguard for Android

Minify Code for Android

On Android, release builds shrink and obfuscate code with R8, which reads the same rules files as ProGuard. Shrinking removes unused code and resources, so the app is smaller and loads faster. It is not guaranteed to be on in a new project, so check the minify and shrink settings in android/app/build.gradle for your Android Gradle Plugin version.

ProCoders Hack: Write keep rules for the libraries that use reflection, and test the release build, not only debug. Over-aggressive shrinking removes classes your app needs at runtime, and the crash only shows in release.

React Native Performance Tunning: Navigation

Use react-navigation Correctly

Navigation affects how fast every screen opens. A heavy screen mounted too early or a stack that re-renders on every state change makes transitions slow.

ProCoders Hack: Memoize screen components, keep screens lazy so they mount when first opened (tab navigators do this by default), and keep heavy work out of the first render. The native stack navigator uses native navigation primitives and often feels smoother than a JavaScript-based stack.

What Changed for Performance Work in 2026

Three shifts change how you approach this list.

The New Architecture is the default since React Native 0.76, as the React Native team announced in October 2024, and React Native 0.82 (October 2025) made the New Architecture the only supported option by ignoring legacy opt-out flags. TurboModules load native modules lazily, the Fabric renderer supports concurrent layout, and JavaScript communicates synchronously with native code over JSI without the old asynchronous JSON bridge. Hermes is the default bytecode engine (with Hermes V1 available as an opt-in from 0.82), so there is nothing to enable manually, though you should verify that every third-party native library in your project supports the New Architecture.

React Compiler reached 1.0 in October 2025. It adds memoization at build time, so the manual useCallback and React.memo hacks above matter less in code it compiles. List rows, library props and anything outside the compiler’s reach still benefit from the manual versions.

The third shift is AI-assisted coding. Coding assistants write a working FlatList quickly, but they can produce an inline renderItem, index keys, images with no cache and effects with no cleanup. Those pass a demo on a fast phone and fail on a three-year-old Android. When you buy development, ask how the team reviews generated code for these patterns, and whether it profiles on low-end devices before release.

ProCoders’ Experience to Improve React Native Performance

For Roth River’s IoT development we used React Native to build a cross-platform mobile app that connected whiskey lovers and distillers. One codebase served both iOS and Android, and the app felt native on each platform. You can read the full story in the Roth River case study.

Optimizing the app was key. We focused on efficient state management and careful image handling so real-time updates flowed smoothly, whether users were tracking their whiskey’s aging process or making custom requests, onboarding the team in 1 week, cutting development costs by 50%, and taking the beta to trial 40% faster.

Looking for React Native engineers who treat performance as part of the build? Get an estimate for your app.

React Performance Tips: Conclusion

Optimizing a React Native app comes down to a few habits: fewer re-renders, lighter images, tuned lists, disciplined state and a smaller bundle. Measure on a low-end device, change one thing at a time and keep what moves the numbers.

If you are planning a build and want to know what performance work will cost, see how much a React Native app costs. If you want engineers who already work this way, look at our React Native developers for hire or our wider mobile app development service.

This guide is written for developers, so it stays technical. If you are a hiring manager reading it to judge a vendor, the sections on lists, memory and AI-written code are the ones to ask about in an interview.

FAQ
01How to optimize performance in React Native?

Cut unnecessary re-renders with React.memo, stable callbacks and, if your project uses it, React Compiler. Use FlatList or FlashList instead of ScrollView for long lists, and tune initialNumToRender and windowSize. Profile on a low-end Android device, since that is where problems show first.

02How do I speed up React Native build times?

Builds and runtime are separate problems. For builds, cache Gradle and CocoaPods dependencies in CI and keep the Gradle daemon and build cache on. Clean the project only when a cache is actually broken. Hermes is on by default and speeds up app startup, not the build itself.

03How to reduce loading time in React Native?

Resize and compress images, use WebP, and cache downloads with a library such as expo-image. Defer heavy modules and screens so they initialize only when opened, and check what ships in the bundle with react-native-bundle-visualizer. Deferring work shortens startup, while removing unused code is what shrinks the bundle.

04What are the best practices for React Native performance monitoring and optimization?

Use React Native DevTools and the React profiler to find components that re-render too often, and the platform profilers (Android Studio, Xcode Instruments) for native cost. Test release builds, not debug. Set a frame-rate and startup budget for key screens and check it before each release.

05What are some ways to reduce memory leaks in React Native?

Return a cleanup function from every useEffect that adds a listener, subscription, timer or interval. Cancel in-flight requests with AbortController when a screen unmounts. Avoid holding large objects in module-level variables, and check memory in Xcode Instruments or Android Studio during a long session.

06How can code splitting be used to optimize React Native apps?

Defer heavy screens and modules so they initialize only when first used, and remove unused dependencies and heavy libraries after checking the bundle visualizer. Hermes compiles the JavaScript to bytecode, which helps startup but does not replace a smaller bundle.