React Native · Mobile UI at native speed

How do you reduce app startup time?

HardstartupbundleperformanceUpdated Oct 2026
Quiz this track

Short answer

Measure cold start with platform tools, then reduce JavaScript bundle work, defer non-critical initialisation, use Hermes bytecode, and avoid synchronous storage or network calls on the startup path.

Startup has native and JavaScript phases. The OS launches the process and native app delegate, then the JS runtime loads the bundle, evaluates modules and renders the first screen. Optimising the wrong phase wastes effort, so measure from process start to first meaningful paint.

Where time goes

  • Native initialisation and third-party SDK setup
  • Bundle download or read, parsing and module evaluation
  • Synchronous storage reads and token refresh before the first screen
  • Rendering a heavy initial screen with too many views
  • Analytics and feature-flag SDKs blocking the main thread
tsx
import { InteractionManager } from "react-native";

export function deferUntilIdle(task: () => void) {
  const handle = InteractionManager.runAfterInteractions(task);
  return () => handle.cancel();
}
Deferring analytics and warm-up work keeps the first screen responsive.

Use Hermes so the bundle ships as bytecode and starts faster than parsing plain JavaScript. Keep the initial route small, lazy-load heavy screens and SDKs, and avoid importing large modules at the top of the entry file. Inline requires can help, but verify the effect on your bundle rather than assuming.

A splash screen should hide only when the first screen is ready, not after a fixed timer. A fixed delay either wastes time or flashes an unfinished UI.

Follow-ups you should expect

Interviewers use these to check whether the first answer was understanding or memorisation.

  1. 1What is the difference between cold, warm and hot start?
  2. 2How does Hermes improve startup?
  3. 3Why is a synchronous token read during startup risky?
  4. 4How do you decide what to lazy-load?

Say it in the interview

I measure cold start from process launch to first meaningful paint, then split the time between native setup and JavaScript. The biggest wins usually come from deferring non-critical SDKs, shrinking and lazy-loading the initial bundle, using Hermes bytecode, and removing synchronous storage or network work from the startup path. I also hide the splash only when the first screen is actually ready.

Use this as a model, not a script. Saying it in your own words is what makes it survive follow-up pressure.

Related questions

Reading is step one

Now say it out loud.

Understanding an answer and delivering it under pressure are different skills. Rehearse this topic in a live React Native mock interview and get scored feedback on depth, clarity and confidence.