Basic Questions
Q1. What is React Native?
Answer:
React Native is a JavaScript framework built on React for developing cross-platform mobile applications. Instead of rendering HTML inside a WebView, React Native renders real native UI components for iOS and Android.
This allows us to share most of the business logic and UI code between platforms while still having access to native functionality when required.
Q2. What is the difference between React and React Native?
Answer:
React is primarily used for building web applications and renders UI to the browser DOM.
React Native uses the same React concepts such as components, props, state, hooks, and reconciliation, but instead of rendering HTML elements like div and span, it renders native components such as View, Text, and Image.
So the main difference is the rendering target:
React → Web DOM
React Native → Native iOS/Android UI
Q3. What are the advantages of React Native?
Answer:
The major advantages are:
A single codebase can target both iOS and Android.
Faster development and iteration.
Large React and JavaScript ecosystem.
Most business logic can be shared across platforms.
Native modules can be used when platform-specific functionality is required.
OTA updates can be used for eligible JavaScript-only changes.
Q4. What are the disadvantages of React Native?
Answer:
Some disadvantages include:
Platform-specific issues may still require native iOS or Android knowledge.
Some functionality requires custom native modules.
The application can have a larger binary size than a purely native application.
Poorly optimized JavaScript, lists, images, or animations can cause performance problems.
Major React Native upgrades can sometimes require significant migration work.
Q5. What are the core components of React Native?
Answer:
Some of the commonly used core components are:
View, Text, Image, ScrollView, FlatList, SectionList, TextInput, Pressable, Modal, ActivityIndicator, Button, and SafeAreaView.
Virtual DOM
Q6. What is Virtual DOM and how does it work?
Answer:
The Virtual DOM is an in-memory representation of the UI.
When state or props change, React creates a new element tree and compares it with the previous tree through reconciliation. React determines what actually changed and commits the required updates to the host environment.
In React Native, the final target is native UI rather than the browser DOM.
Q7. What is reconciliation in React Native?
Answer:
Reconciliation is the process React uses to compare the previous element tree with the new element tree.
React determines:
Which elements changed
Which elements were added
Which elements were removed
Which list items moved
Keys are particularly important for lists because they help React identify items consistently between renders.
Q8. What are the main threads in React Native?
Answer:
The important execution areas include:
JavaScript thread — application JavaScript and React logic.
UI/Main thread — native rendering and user interaction.
Shadow/layout thread — layout calculations using Yoga.
Native background threads — native modules can perform heavy operations away from the UI thread.
With the New Architecture, JSI and Fabric reduce some of the communication overhead associated with the old bridge architecture.
FlatList
Q9. What is FlatList?
Answer:FlatList is React Native's optimized component for rendering large lists.
It uses virtualization, meaning it doesn't mount every item at once. Instead, it renders the visible items and a configurable buffer around them.
This improves memory usage and performance compared with rendering a large dataset inside a ScrollView.
Q10. What are the advantages of FlatList over ScrollView?
Answer:
| FlatList | ScrollView |
|---|---|
| Uses virtualization | Renders all children |
| Suitable for large lists | Better for small content |
| Better memory usage | Can consume more memory |
Supports onEndReached | No built-in pagination |
| Supports pull-to-refresh | Requires additional handling |
| Supports optimized rendering | Simple but less suitable for huge lists |
I would generally use FlatList when the number of items can become large or is dynamically loaded.
Q11. Do we need a ScrollView around FlatList?
Answer:
No. FlatList already provides scrolling functionality.
Wrapping a FlatList inside another vertical ScrollView is generally unnecessary and can introduce nested scrolling and virtualization problems.
Q12. How do you optimize a FlatList?
Answer:
For a large list, I would consider:
React.memo()for list-item componentsStable
keyExtractoruseCallback()for stable callbacksgetItemLayoutwhen item dimensions are predictableAppropriate
windowSizeinitialNumToRendermaxToRenderPerBatchAvoiding expensive calculations inside
renderItemOptimizing images
Avoiding unnecessary state updates
I would also profile the actual bottleneck rather than blindly changing FlatList parameters.
State & Props
Q13. What is state?
Answer:
State is data owned by a component that can change over time. When state changes, React schedules a re-render.
In functional components, state is commonly managed using useState or useReducer.
Q14. What are props?
Answer:
Props are read-only values passed from a parent component to a child component.
They are commonly used to configure a component or pass data and callbacks.
For example:
<Profile
name="Salil"
onPress={handleProfilePress}
/>
Here, name and onPress are props.
Q15. What is the difference between state and props?
Answer:
| State | Props |
|---|---|
| Owned by the component | Passed by the parent |
| Can be updated by the component | Read-only from child's perspective |
| Used for internal/dynamic data | Used to configure a child |
| Updating state triggers rendering | New props can trigger rendering |
A simple way to remember it:
State belongs to the component; props come from outside the component.
Hooks
Q16. What are React Hooks?
Answer:
Hooks are functions that allow functional components to use React features such as state, effects, context, and refs without using class components.
Common hooks include:
useState, useEffect, useMemo, useCallback, and useRef.
Q17. Explain useState, useEffect, useCallback, useMemo and useRef.
Answer:
useState
Manages local component state.
useEffect
Handles side effects such as API calls, subscriptions, timers, and other external interactions.
useCallback
Memoizes a function reference so that the function isn't recreated unnecessarily when dependencies haven't changed.
useMemo
Memoizes a calculated value to avoid repeating an expensive calculation unnecessarily.
useRef
Stores a mutable value that persists across renders without causing a re-render. It is also commonly used for references to native components.
Q18. How do you update state based on the previous state?
Answer:
Use the functional form of the state setter:
setCount(prev => prev + 1);
This is important when the new state depends on the previous state because React may batch state updates.
Redux
Q19. What is Redux?
Answer:
Redux is a predictable state-management library that provides centralized application state.
The typical flow is:
UI → Dispatch Action → Reducer/Middleware → Store Update → UI Re-render
Reducers should be pure functions and state should be updated immutably.
Q20. What is Redux Saga?
Answer:
Redux Saga is middleware that uses JavaScript generator functions to manage asynchronous operations and side effects.
It is useful for complex workflows such as:
API requests
Cancellation
Debouncing
Race conditions
Sequential operations
Background workflows
For simpler applications, Redux Toolkit with createAsyncThunk or another async approach may be sufficient.
Performance
Q21. What are common React Native performance problems?
Answer:
Common problems include:
Unnecessary re-renders
Poorly optimized FlatLists
Heavy JavaScript execution
Large unoptimized images
Memory leaks
Excessive JS/native communication
Expensive calculations during rendering
Heavy work blocking the UI experience
I would first profile the application to identify whether the bottleneck is JavaScript, rendering, layout, memory, networking, or native code.
Q22. How do you prevent memory leaks?
Answer:
I make sure that resources created by a component are cleaned up when the component unmounts.
For example:
Clear timers
Remove event listeners
Unsubscribe from subscriptions
Cancel network requests where appropriate
Clean up navigation listeners
Avoid retaining large objects unnecessarily
With hooks, cleanup is commonly handled inside the function returned from useEffect.
Modern React Native
Q23. What is Fabric?
Answer:
Fabric is React Native's modern rendering system and is part of the New Architecture.
It provides a more efficient rendering pipeline and works with the newer architecture based around technologies such as JSI and the C++ core.
The goal is better performance, more direct JS/native interaction, and better support for modern React capabilities.
Q24. What is the difference between the old architecture and New Architecture?
Answer:
Old Architecture:
JavaScript → Bridge → Native
Communication relied heavily on asynchronous message passing and serialization.
New Architecture:
JavaScript → JSI / TurboModules / Fabric → Native
The New Architecture reduces the communication overhead and provides a more direct interaction between JavaScript and native code.
Q25. How do you test a React Native application?
Answer:
I would use different testing levels depending on the requirement:
Jest — unit and logic testing
React Native Testing Library — component and interaction testing
Detox / Maestro — end-to-end testing
For a production application, I would combine unit, component, integration, and E2E testing rather than relying on only one type.
React Native Senior Interview — Additional Questions & Answers
12. Advanced React Native Questions
Q1. What happens when you call setState or a state setter?
Answer:
When state changes, React schedules a re-render. React creates the next component tree, compares it with the previous tree during reconciliation, and commits the required updates to the native UI.
Senior point:
A state update does not necessarily mean the entire screen is recreated. React updates the affected parts of the tree based on reconciliation.
Q2. Why does a React Native component re-render?
Answer:
A component can re-render when:
Its state changes.
Its parent re-renders.
Its props change.
Its context value changes.
An external state subscription updates.
A re-render is not automatically a performance problem. The important thing is whether expensive work or unnecessary native updates happen as a result.
Q3. How do you prevent unnecessary re-renders?
Answer:
I first identify the actual cause using profiling tools. Then I use techniques such as:
React.memouseMemouseCallbackstable object and function references
proper component boundaries
optimized selectors
normalized state
FlatList optimization
I avoid blindly adding useMemo and `useCallback because they also have overhead.
Q4. What is React.memo?
Answer:
React.memo prevents a functional component from rendering when its props have not changed based on shallow comparison.
const UserCard = React.memo(({ user }) => {
return <Text>{user.name}</Text>;
});
It is especially useful for expensive list items, provided the props remain referentially stable.
Q5. What is referential equality?
Answer:
JavaScript compares objects and functions by reference rather than their contents.
{} === {} // false
This matters in React because creating new objects or functions on every render can make memoized components render again.
Q6. What is a stale closure?
Answer:
A stale closure happens when a function captures an older value from a previous render.
For example, an effect or callback may continue using an old state value because its dependency list is incorrect.
I handle this by using correct dependencies, functional state updates, or refs when appropriate.
Q7. When should you use a functional state update?
Answer:
When the new state depends on the previous state.
setCount(prev => prev + 1);
This is safer than:
setCount(count + 1);
especially when multiple updates can be scheduled.
Q8. What is batching in React?
Answer:
React can group multiple state updates together and perform fewer renders instead of rendering after every individual update.
This reduces unnecessary work and improves UI performance.
13. JavaScript Questions for React Native
Q9. What is the JavaScript event loop?
Answer:
JavaScript executes synchronous code on the call stack. Asynchronous operations are handled by the runtime, and their callbacks are placed into queues. The event loop processes queued work when the call stack becomes available.
In React Native, understanding this is important because heavy JavaScript work can block the JS thread and affect responsiveness.
Q10. What is the difference between synchronous and asynchronous code?
Answer:
Synchronous code executes sequentially and blocks until it completes.
Asynchronous code allows other work to continue while waiting for an operation such as a network request, timer, or file operation.
Q11. Promise vs async/await?
Answer:
async/await is syntax built on top of Promises. I generally prefer async/await because it makes asynchronous control flow easier to read and error handling with try/catch is straightforward.
Q12. What is the difference between == and ===?
Answer:
== performs type coercion before comparison, while === checks both value and type.
In production React Native code, I generally use === because it provides predictable behavior.
Q13. Explain let, const, and var.
Answer:
let and const are block-scoped. const prevents reassignment of the variable binding.
var is function-scoped and has hoisting behavior that can cause bugs, so modern JavaScript generally uses const and let.
Q14. What is debouncing?
Answer:
Debouncing delays execution until the user stops triggering an event for a specified period.
A common React Native example is search:
User types:
c → ca → car → cars
Instead of calling the API four times,
wait until typing stops and call it once.
Q15. What is throttling?
Answer:
Throttling limits how frequently a function can execute.
For example, during a scroll event, instead of processing hundreds of events continuously, we can process them at a controlled interval.
14. Navigation
Q16. How does React Navigation work?
Answer:
React Navigation manages navigation state and renders navigators such as:
Stack
Bottom Tab
Drawer
Native Stack
Navigation state determines which screen is active and what the navigation history looks like.
Q17. Stack Navigator vs Native Stack?
Answer:
A JavaScript-based stack provides more flexibility but may involve more JS-side work.
Native Stack uses native navigation primitives and can provide more native behavior and performance.
The choice depends on application requirements and the navigation library/version being used.
Q18. How do you protect authenticated screens?
Answer:
I maintain authentication state centrally and conditionally render authenticated and unauthenticated navigation flows.
For example:
App
├── Loading
├── Auth Stack
└── Main App
├── Home
├── Profile
└── Settings
I also make sure authorization is enforced on the backend. Navigation guards are UX protection, not a security boundary.
Q19. How would you handle deep linking?
Answer:
I configure URL schemes/universal links/app links and map incoming URLs to navigation routes.
For example:
myapp://payment/123
could open:
PaymentDetails
with transaction ID 123.
I also validate the incoming parameters before performing sensitive actions.
Q20. How do you handle navigation state after app restart?
Answer:
For required use cases, navigation state can be persisted and restored. However, I avoid persisting sensitive navigation data blindly and ensure authentication state is validated before restoring protected screens.
15. Native Android / iOS Questions
Q21. When would you write native code instead of React Native code?
Answer:
I use native code when:
RN doesn't expose the required API.
A device-specific feature is needed.
Performance-critical functionality requires native implementation.
Existing native SDKs need integration.
Bluetooth, payments, biometrics, background services, or OS-specific APIs require deeper platform access.
Q22. How do you create a native module for React Native?
Answer:
I define a native API that can be called from JavaScript and implement the platform-specific functionality in Kotlin/Java for Android or Swift/Objective-C for iOS.
With the New Architecture, I would consider TurboModules and the typed/codegen-based approach where appropriate.
Q23. What is a Native Module?
Answer:
A Native Module exposes platform functionality to React Native JavaScript.
For example:
React Native
↓
Native Module
↓
Android/iOS API
↓
Device capability
Examples include Bluetooth, biometrics, payment SDKs and custom device APIs.
Q24. What is JSI?
Answer:
JSI, or JavaScript Interface, provides a C++ interface that allows JavaScript to interact more directly with native/C++ functionality without relying on the traditional serialized bridge for every interaction.
It is an important foundation of React Native's New Architecture.
Q25. What is Fabric?
Answer:
Fabric is React Native's modern rendering system. It uses a shared C++ core and improves communication between React and native rendering.
It is part of the New Architecture alongside technologies such as TurboModules and JSI.
Q26. What are TurboModules?
Answer:
TurboModules are the modern native module system in React Native.
One important benefit is lazy loading, meaning native modules don't necessarily have to be initialized immediately at application startup.
16. Android-Specific Interview Questions
Q27. What is the Android Activity lifecycle?
Answer:
The common lifecycle is:
onCreate
↓
onStart
↓
onResume
↓
onPause
↓
onStop
↓
onDestroy
Understanding it is important when integrating React Native with native Android functionality.
Q28. What happens when an Android app goes into the background?
Answer:
The Activity can move through lifecycle states and the operating system may reclaim resources if necessary.
For long-running background work, I don't assume that JavaScript will continue executing indefinitely. I use appropriate Android background mechanisms depending on the requirement.
Q29. How do you handle Android back button behavior?
Answer:
I handle it through the navigation system or BackHandler when custom behavior is required.
For example:
BackHandler.addEventListener(
'hardwareBackPress',
handleBackPress
);
I always remove the listener during cleanup.
Q30. What causes ANR on Android?
Answer:
ANR, or Application Not Responding, can occur when the main UI thread is blocked for too long.
Common causes include:
Heavy computation
Large synchronous operations
Blocking I/O
Poor native code
Excessive work on the main thread
The solution is to move expensive work away from the UI thread and profile the actual bottleneck.
17. Performance Debugging
Q31. Your React Native app is slow. How would you investigate?
Answer:
I don't immediately optimize random components.
My process is:
Reproduce
↓
Measure
↓
Identify bottleneck
↓
Profile JS/native/UI
↓
Fix
↓
Measure again
I investigate:
startup time
JS thread
UI thread
memory
network
image loading
list rendering
unnecessary renders
native modules
Q32. What causes dropped frames?
Answer:
Dropped frames happen when the application cannot complete the required work within the frame budget.
Possible causes include:
expensive JavaScript
expensive layout
large images
excessive rendering
animation work
blocking native/UI thread work
Q33. How would you optimize a screen containing 5,000 items?
Answer:
I would use a virtualized list such as FlatList or another appropriate high-performance list.
Then I would investigate:
stable keys
memoized row components
getItemLayoutwhere possiblebatch rendering
window size
image optimization
pagination
server-side filtering
avoiding unnecessary state updates
I would measure performance rather than blindly tuning every property.
Q34. FlatList is still lagging. What do you check?
Answer:
I check:
Whether
renderItemis expensive.Whether each item unnecessarily re-renders.
Whether images are large.
Whether item heights are dynamic.
Whether
keyExtractoris stable.Whether callbacks and objects are recreated unnecessarily.
Whether the dataset is too large.
Whether pagination is needed.
Whether JS thread work is blocking scrolling.
Q35. How do you optimize app startup?
Answer:
I measure cold startup first.
Then I look at:
bundle size
JavaScript execution
unnecessary initialization
native module initialization
API calls during startup
image loading
fonts
analytics initialization
large synchronous computations
I defer non-critical work until after the first useful screen is displayed.
18. Memory Management
Q36. How do you identify a memory leak?
Answer:
I reproduce the problem repeatedly and monitor memory usage using tools such as Android Studio Profiler or Xcode Instruments.
In React Native I specifically inspect:
event listeners
timers
subscriptions
navigation listeners
WebSocket connections
large closures
image resources
unmounted components retaining references
Q37. Give an example of a common React memory leak.
Answer:
A common example is an event listener registered inside an effect without cleanup.
Correct approach:
useEffect(() => {
const subscription = subscribe();
return () => {
subscription.remove();
};
}, []);
19. API Architecture
Q38. How would you design API handling in a large React Native application?
Answer:
I separate API infrastructure from UI components.
For example:
src/
├── api/
│ ├── client.ts
│ ├── auth.ts
│ ├── users.ts
│ └── payments.ts
│
├── features/
├── components/
├── navigation/
└── store/
The API client handles common concerns such as:
authentication
headers
timeout
error handling
refresh tokens
logging
request cancellation
Q39. How do you handle token refresh?
Answer:
When an API returns an authentication failure because the access token expired, I use the refresh token to obtain a new access token.
For concurrent requests, I avoid sending multiple refresh requests simultaneously. I use a refresh queue or shared refresh promise and retry the pending requests after the token is refreshed.
Q40. What happens if the refresh token also expires?
Answer:
The session is considered invalid.
I clear the authentication state securely and redirect the user to the login flow.
Sensitive tokens should be stored using secure platform storage rather than ordinary unencrypted storage.
Q41. How do you handle API retries?
Answer:
I don't retry every failure.
I distinguish between:
network failures
timeout
server errors
authentication failures
client validation errors
For retryable transient failures, I can use exponential backoff with a retry limit.
20. Offline-First Questions
Q42. How would you make a React Native application work offline?
Answer:
I first classify the data:
Critical local data
Cached server data
User-generated pending actions
Temporary UI state
I persist appropriate data locally, detect connectivity, cache server responses, and queue mutations that can safely be synchronized later.
Q43. What is optimistic UI?
Answer:
Optimistic UI updates the interface immediately assuming the server operation will succeed.
For example:
User likes post
↓
UI immediately shows Like
↓
API request
↓
Success → keep state
Failure → rollback
It improves perceived performance but requires proper rollback handling.
21. Security
Q44. How do you secure a React Native application?
Answer:
I use multiple layers:
HTTPS
secure token storage
certificate/public-key pinning where justified
biometric authentication for sensitive actions
server-side authorization
input validation
secure logging
protection of secrets
dependency updates
obfuscation/minification where appropriate
I never treat client-side security as a replacement for backend authorization.
Q45. Can API keys be hidden inside a mobile app?
Answer:
No truly secret credential can be considered completely secure if it must be shipped to the client.
Anything embedded in the application can potentially be extracted.
Sensitive credentials should remain on a trusted backend.
Q46. Should authentication tokens be stored in AsyncStorage?
Answer:
For sensitive authentication credentials, I prefer platform-secure storage such as Keychain/Keystore-backed solutions.
AsyncStorage is not encrypted by default and should not be treated as a secure secret store.
Q47. How would you implement biometric login?
Answer:
I use the platform biometric APIs or a trusted React Native library.
The biometric check unlocks access to a securely stored credential rather than acting as the backend authentication mechanism itself.
22. Error Handling
Q48. How do you handle errors globally?
Answer:
I use multiple levels:
Component errors
↓
Feature-level handling
↓
API error handling
↓
Global logging/crash reporting
For production I use tools such as Crashlytics or Sentry to capture crashes and useful context.
Q49. What is an Error Boundary?
Answer:
An Error Boundary catches JavaScript rendering errors in its child component tree and allows the application to show fallback UI instead of crashing the entire React tree.
Traditional React Error Boundaries use class lifecycle methods such as componentDidCatch.
Q50. How do you handle API errors shown to users?
Answer:
I separate technical errors from user-facing messages.
For example:
HTTP 500
↓
Log technical details
↓
Show user-friendly message
↓
Offer retry where appropriate
I avoid displaying raw backend errors directly to users.
23. TypeScript
Q51. Why use TypeScript in React Native?
Answer:
TypeScript provides static typing, better IDE support, safer refactoring, and catches many errors before runtime.
It becomes particularly valuable in large applications with shared models, navigation parameters, API responses, and complex state.
Q52. Interface vs type?
Answer:
Both can describe object shapes.
interface is commonly useful for extensible object contracts, while type is more flexible for unions, intersections and aliases.
The important point in a team is consistency rather than choosing one universally.
Q53. How do you type React Navigation parameters?
Answer:
I define a central parameter list.
For example:
type RootStackParamList = {
Home: undefined;
Profile: { userId: string };
Details: { id: number };
};
This gives compile-time validation when navigating between screens.
24. Redux / State Architecture
Q54. When should you use Redux?
Answer:
I use Redux when the application has substantial shared state, complex state transitions, predictable debugging requirements, or many features that need access to the same state.
I don't introduce Redux just because the application has more than a few screens.
Q55. Redux vs Context API?
Answer:
Context is useful for relatively stable shared values such as theme, locale, or authentication context.
Redux provides a more structured state-management architecture with predictable updates, middleware, dev tooling, and scalable patterns.
Q56. Redux Toolkit vs traditional Redux?
Answer:
Redux Toolkit is the recommended modern approach because it reduces boilerplate and provides utilities for slices, immutable updates, middleware configuration, and async workflows.
I would generally choose Redux Toolkit for a new Redux application.
Q57. What is normalized state?
Answer:
Instead of deeply nesting duplicated objects, related entities are stored independently and referenced by IDs.
For example:
users:
1 → User A
2 → User B
posts:
10 → { authorId: 1 }
This reduces duplication and makes updates easier.
25. Architecture / System Design
Q58. How would you structure a large React Native application?
Answer:
I prefer feature-oriented architecture.
src/
├── features/
│ ├── auth/
│ ├── payments/
│ ├── profile/
│ └── trading/
│
├── components/
├── navigation/
├── services/
├── store/
├── hooks/
├── utils/
├── theme/
└── types/
Each feature owns its screens, components, API logic and state where appropriate.
The goal is strong module boundaries rather than simply creating many folders.
Q59. How do you design a scalable React Native application?
Answer:
I focus on:
feature boundaries
reusable design system
typed APIs
predictable state management
navigation architecture
testing strategy
error handling
analytics
performance monitoring
CI/CD
native integration strategy
Architecture should evolve with product requirements rather than becoming unnecessarily complex from day one.
Q60. Monorepo or separate repositories?
Answer:
It depends on the organization.
A monorepo can make code sharing and coordinated changes easier across mobile, web and backend packages.
Separate repositories can provide stronger isolation and independent release processes.
I would decide based on team structure, deployment requirements and the amount of genuinely shared code.
26. CI/CD
Q61. Explain a React Native CI/CD pipeline.
Answer:
A typical pipeline is:
Git Push
↓
Lint
↓
Type Check
↓
Unit Tests
↓
Build
↓
E2E Tests
↓
Signing
↓
Artifact
↓
Test Distribution
↓
Store Release
Tools can include GitHub Actions, Fastlane, Bitrise, Firebase App Distribution and the respective app-store systems.
Q62. How do you manage Android signing?
Answer:
Keystore credentials should never be committed to Git.
I store signing credentials securely in CI/CD secret storage and inject them during the build process.
Q63. What is the difference between debug and release builds?
Answer:
Debug builds are optimized for development and debugging.
Release builds enable production optimizations, use production configuration, signing credentials and generally disable development tooling.
Performance characteristics can therefore differ significantly.
27. Testing
Q64. What should you unit test in React Native?
Answer:
I focus on business logic, utilities, hooks and important state transitions.
For UI components, I test user-visible behavior rather than implementation details.
Q65. What is the difference between unit, integration and E2E testing?
Answer:
Unit: tests an isolated function or small piece of logic.
Integration: tests multiple pieces working together.
E2E: tests the complete application flow from the user's perspective.
Q66. What should an E2E test cover?
Answer:
Important business-critical flows such as:
login
registration
payment
checkout
transaction
logout
critical navigation
I don't try to reproduce every unit test at the E2E level.
28. Real-World Scenario Questions
Q67. Production app crashes only on Android. What do you do?
Answer:
First I collect crash information and identify the affected Android versions/devices.
Then I reproduce if possible and inspect:
Crashlytics/Sentry
native stack trace
JavaScript stack
recent releases
native dependencies
ProGuard/R8 mapping if applicable
Then I create a minimal reproduction and release a controlled fix.
Q68. API is taking 8 seconds. Would you optimize React Native?
Answer:
Not necessarily.
I first determine where the eight seconds are spent:
App
↓
DNS/network
↓
Backend
↓
Database
↓
Response
↓
Parsing
↓
Rendering
If the backend takes seven seconds, optimizing the React component won't solve the root problem.
Q69. The UI freezes when processing a large JSON response. Why?
Answer:
Parsing and processing a large response can consume significant JavaScript-thread time.
I would profile the operation and consider:
reducing response size
pagination
server-side filtering
moving heavy processing away from the critical UI path
restructuring the API response
native/background processing where justified
Q70. Your FlatList has only 100 items but still feels slow. Why?
Answer:
Item count isn't the only factor.
The problem may be:
expensive row rendering
huge images
nested components
unnecessary state updates
animations
expensive selectors
synchronous JavaScript work
I would profile the row and JS/UI thread before changing FlatList settings.
29. Leadership Questions
Q71. How do you conduct code reviews?
Answer:
I focus on:
Correctness
Architecture
Maintainability
Security
Performance
Testing
Consistency
I try to explain the reason behind a requested change rather than simply saying "change this."
Q72. How do you mentor junior developers?
Answer:
I prefer a combination of code reviews, pairing, architecture discussions and gradually increasing ownership.
The goal is not just to fix their current code but to help them understand the reasoning behind the solution.
Q73. What if another developer disagrees with your architecture decision?
Answer:
I focus the discussion on requirements, constraints and measurable trade-offs rather than personal preference.
If necessary, we can create a small proof of concept, compare the approaches and make the decision based on evidence.
Q74. How do you handle technical debt?
Answer:
I categorize technical debt based on impact and risk.
Critical debt affecting security, reliability or delivery gets higher priority.
For lower-risk debt, I usually address it incrementally while working in the affected area instead of stopping feature development completely.
30. Project-Based Questions
Q75. Tell me about your most challenging React Native project.
Answer structure:
Use:
Problem
↓
Your responsibility
↓
Technical challenge
↓
Decision
↓
Implementation
↓
Result
Avoid giving only a feature list.
Q76. What was the biggest performance issue you solved?
Answer structure:
Explain:
What users experienced
How you measured it
Root cause
Changes you made
Before/after numbers
How you prevented regression
This is much stronger than saying "I optimized the app."
Q77. Tell me about a production bug you caused.
Answer:
Choose a genuine but recoverable example.
Explain:
What happened.
Why it happened.
How you detected it.
How you fixed it.
What you changed afterward to prevent recurrence.
Don't blame another developer.
Q78. Tell me about a disagreement with a team member.
Answer:
Explain the technical disagreement objectively, how you evaluated both approaches, how the team reached a decision and what you learned.
Q79. Why should we hire you as a Senior React Native developer?
Answer structure:
Don't simply say "I have seven years of experience."
Talk about:
production ownership
architecture
performance
native integration
debugging
delivery
mentoring
business understanding
Then connect those strengths to the role.
31. Difficult Senior-Level Questions
Q80. React Native vs native Android/iOS — when would you choose native?
Answer:
I would choose fully native when platform-specific behavior, extremely demanding performance, deep OS integration or platform-specific UX is the dominant requirement.
I would choose React Native when cross-platform development, shared business logic and faster iteration provide significant value.
For many applications, a hybrid approach is also practical.
Q81. Can React Native achieve native performance?
Answer:
It can achieve excellent performance for many application types, but "native performance" is not a single measurable property.
The result depends on rendering, JavaScript workload, native modules, animations, networking, images and architecture.
The correct approach is to profile the actual bottleneck.
Q82. What is the biggest React Native performance mistake?
Answer:
Assuming that every performance problem is caused by React Native itself.
I first determine whether the bottleneck is JavaScript, native UI, network, backend, memory, images or application architecture.
Q83. How would you migrate an old React Native application to the New Architecture?
Answer:
I would not switch everything blindly.
I would:
Audit dependencies
↓
Check compatibility
↓
Upgrade RN/dependencies
↓
Enable New Architecture
↓
Run tests
↓
Fix incompatible native modules
↓
Profile
↓
Gradual production rollout
The migration should be driven by compatibility and measurable results.
Q84. How would you reduce app bundle size?
Answer:
I would measure the current bundle first.
Then investigate:
unused dependencies
large assets
duplicate libraries
unnecessary native dependencies
JavaScript bundle composition
image formats
fonts
build configuration
I would avoid removing dependencies without verifying their actual usage.
Q85. How would you design a fintech React Native application?
Answer:
I would prioritize:
secure authentication
secure credential storage
server-side authorization
transaction integrity
biometric protection
audit logging
secure networking
reliable error handling
idempotent transaction APIs
strong testing
crash monitoring
controlled releases
For financial operations, correctness and security are more important than simply making the UI fast.
32. Rapid-Fire Questions
Q86. What is useCallback?
Answer:
It memoizes a function reference between renders when dependencies don't change.
Q87. What is useMemo?
Answer:
It memoizes a calculated value between renders.
Q88. What is useRef?
Answer:
It stores a mutable value that persists across renders without causing a render when changed.
Q89. What is useEffect?
Answer:
It runs side-effect logic after rendering and can return a cleanup function.
Q90. What is React.memo?
Answer:
It memoizes a functional component and can skip rendering when props are unchanged.
Q91. What is Hermes?
Answer:
Hermes is a JavaScript engine optimized for React Native applications.
Q92. What is Fast Refresh?
Answer:
Fast Refresh updates React component code during development while attempting to preserve component state.
Q93. What is OTA update?
Answer:
An over-the-air update can deliver certain JavaScript/assets changes without requiring a full native binary release, subject to platform and store policies.
Q94. What is a race condition?
Answer:
A race condition occurs when the result depends on the timing/order of concurrent operations.
Q95. What is idempotency?
Answer:
An operation is idempotent when repeating the same request produces the same intended result.
This is particularly important for payment and transaction APIs.
Q96. What is pagination?
Answer:
Pagination loads data in smaller chunks instead of downloading the entire dataset at once.
Q97. What is lazy loading?
Answer:
Lazy loading means loading a resource only when it is actually needed.
Q98. What is code splitting?
Answer:
Code splitting divides application code into smaller chunks so that not everything needs to be loaded immediately.
Q99. What is memoization?
Answer:
Memoization caches a previous computation or reference so repeated work can be avoided when inputs have not changed.
Q100. What is normalization?
Answer:
Normalization structures data to reduce duplication and make updates more predictable.
33. Interview Rule for Senior Candidates
For every technical question, try to answer in this order:
1. Direct answer → 2. Why → 3. Real example → 4. Trade-off
Example:
"I would use FlatList for a large dataset because it virtualizes items. In one production scenario, I would also profile the row rendering because FlatList itself doesn't solve expensive
renderItemlogic. If row height is predictable, I can additionally usegetItemLayout."
That sounds much more senior than simply saying:
"FlatList is better because it is optimized."
34. Final Preparation Checklist
Before the interview, be able to explain without memorizing:
React vs React Native
Old Bridge vs JSI
New Architecture
Fabric
TurboModules
Hermes
React rendering/reconciliation
Hooks
stale closures
memoization
FlatList internals
performance profiling
JS thread vs UI thread
memory leaks
navigation
deep linking
native modules
Android lifecycle
iOS lifecycle
API architecture
token refresh
secure storage
offline architecture
optimistic updates
Redux Toolkit
Context vs Redux
TypeScript
testing pyramid
CI/CD
app signing
crash monitoring
architecture design
security
fintech considerations
mentoring
code reviews
technical debt
production incident handling
Most importantly, prepare 5 real stories from your own projects:
A performance problem you solved
A difficult production bug
A major architecture decision
A native Android/iOS integration
A feature where you led or mentored other developers
These stories can be reused across dozens of senior-level interview questions.
No comments:
Post a Comment