Skip to contentCIELONT SOFTWARE PRIVATE LIMITED logoCIELONTSOFTWARE PRIVATE LIMITED
Mobile

React Native Performance: From 45fps to 60fps

The optimisations that doubled frame rates in our mobile commerce app — Hermes, list virtualisation, and the profiling workflow we use on every project.

C
Cielont Engineering
Mar 22, 2026
10 min read

The app was shipping. It worked. The product manager was happy. And then a user filmed their screen and posted it — 45fps janky scrolling, visible stutters on navigation transitions, and a 1.2-second perceived input lag on the checkout button.

We've since developed a systematic performance optimisation workflow for React Native. Here's what we applied to get from 45fps to a stable 60fps.

Start with profiling, not guessing

The most common mistake: optimising the wrong thing. Before touching a line of code, we profile. The React Native DevTools Performance panel, Flipper, and the Systrace API give you frame budgets, JS thread utilisation, and render times per component.

Rule: if you don't have a frame timeline showing where budget is being spent, you're guessing. Guessing wastes weeks.

In our case, the profiler showed three culprits: a FlatList re-rendering 200 items on every scroll event, a checkout button handler doing synchronous JSON parsing, and an image loading strategy that blocked the UI thread.

Enable Hermes if you haven't

Hermes is React Native's optimising JavaScript engine, now enabled by default since RN 0.70. If you're on an older project that hasn't migrated, the performance improvement on Android is often dramatic — startup time typically drops 30–50% and memory usage falls noticeably.

Migrating is straightforward. Enable it in android/app/build.gradle, run cd android && ./gradlew clean, and rebuild. Verify with HermesInternal.getRuntimeProperties() returning a non-null value.

Fix your FlatList

FlatList is the most performance-sensitive component in most apps. The three settings that matter most:

  • removeClippedSubviews={true} — unmounts views outside the viewport. Critical for long lists.
  • maxToRenderPerBatch={5} — limits items rendered per JS batch. Default is 10, which is too high for complex item layouts.
  • windowSize={5} — reduces the viewport multiplier for pre-rendered items. Default is 21, which pre-renders 10 screens of content.

Also: memoize your renderItem function and make your item component a React.memo. Without memoisation, every item re-renders when any list state changes.

const renderItem = useCallback(({ item }) => (
  <ProductCard product={item} />
), []);

const ProductCard = React.memo(({ product }) => {
  // ...
});

Move expensive work off the JS thread

React Native has two threads: the JS thread (where your React code runs) and the UI thread (where the native rendering happens). Jank happens when the JS thread is blocked — usually by synchronous data processing.

In our checkout flow, a synchronous JSON.parse of a 400kb cart object was blocking the JS thread for ~80ms on every tap. The fix: defer it with InteractionManager.runAfterInteractions and show a loading state.

For heavier work (image processing, cryptography, large JSON operations), move it to a native module or use the new Architecture's JSI to run it in a background worklet.

Image loading: the silent frame killer

React Native's built-in Image component decodes images on the main thread. For a product grid with 20 images loading simultaneously, this creates frame drops every time a new image enters the viewport.

Use @shopify/flash-list instead of FlatList for product grids — it's dramatically faster. Pair it with an image caching library (we use react-native-fast-image) that handles progressive decoding and memory management properly.

Also: never load full-resolution images in list views. Resize to the display dimensions server-side or via a CDN image transformation service. Displaying a 2000×2000px product image in a 200×200px cell wastes 100× the memory budget.

Navigation transitions

If screen transitions are janky, the usual culprit is component initialisation happening on the same frame as the transition animation. Use useFocusEffect from React Navigation to defer data fetching until after the transition completes:

useFocusEffect(useCallback(() => {
  const fetch = async () => {
    const data = await loadScreenData();
    setData(data);
  };
  fetch();
}, []));

Combined with a skeleton loading state, this makes transitions feel instant even when data loading is slow.

The profiling loop

After each optimisation, run the profiler again before moving on. Performance work without measurement is busy work. We track three metrics per sprint: P75 frame time (under 16.6ms = 60fps), JS thread peak utilisation during scroll, and startup time to interactive.

The checkout button that had a 1.2s perceived lag? After deferring the JSON parse and reducing the renderItem complexity, it dropped to 80ms — effectively instant.

Performance optimisation isn't glamorous. It's systematic: profile, identify the bottleneck, fix the specific bottleneck, measure again. Skip any step and you're wasting time.

Work with us

Ready to build something great?

From custom software to AI systems — we ship production-grade products on time.