Question 1
Difficulty: easy
How do you decide when to use React Native instead of building separate native apps for iOS and Android?
Sample answer
I usually recommend React Native when the product needs to move quickly across both platforms, the team wants to share a large portion of the codebase, and the app’s core features fit well within React Native’s strengths. For example, if the app is mostly forms, dashboards, content browsing, authentication, and standard device access, React Native is a strong fit. I also consider team composition. If the company already has web React developers, the ramp-up is often faster. That said, I’m careful not to force React Native into every case. If the app depends heavily on complex native graphics, advanced Bluetooth work, or very platform-specific interactions, I’d evaluate the native requirements early and identify any modules that may need custom native code. My goal is always to balance speed, maintainability, and user experience rather than choosing a framework just because it’s familiar.
Question 2
Difficulty: medium
Can you walk me through how you would troubleshoot a performance issue in a React Native app?
Sample answer
My first step is to reproduce the issue consistently and narrow it down to a screen, interaction, or device type. Then I look for the common causes of React Native slowdowns: unnecessary re-renders, large lists without proper virtualization, expensive logic running during render, heavy images, or too many bridge calls. I use profiling tools, logs, and sometimes temporary instrumentation to understand what is actually causing the lag instead of guessing. If a list is involved, I check whether FlatList is configured properly, with stable keys, memoized row components, and sensible windowing settings. For animation or gestures, I make sure the work is happening on the right thread and not blocking the JS thread. I also like to test on lower-end devices because performance issues often show up there first. Once I fix the issue, I verify the improvement with the same scenario so I know the change was real, not just perceived.
Question 3
Difficulty: medium
Tell me about a time you had to solve a difficult bug in a React Native feature. How did you approach it?
Sample answer
On one project, a form submission flow was failing intermittently on Android but worked fine on iOS and in most emulator tests. Rather than jumping straight into code changes, I broke the problem into layers: API response handling, state updates, navigation timing, and device-specific behavior. I added more logging around the request lifecycle and discovered that the failure happened when users tapped submit quickly after making the final input change. The issue was a race between state updates and the submission handler reading stale values. I fixed it by refactoring the form state management so the latest values were always available at submission time and by disabling the button during the request. I also added a small integration test to cover the sequence. What I learned from that situation is that “random” mobile bugs often become predictable once you observe the timing carefully and test the edge cases on real devices, not just the happy path.
Question 4
Difficulty: easy
How do you structure React Native code so it stays maintainable as the app grows?
Sample answer
I try to keep the app organized around features rather than only by technical type. That means each screen or domain area gets its own components, hooks, services, and state logic where it makes sense. I prefer a structure that makes it easy for another developer to understand where a feature lives without searching across unrelated folders. I also separate reusable UI components from screen-specific code so shared pieces stay clean and consistent. For business logic, I avoid putting too much into components; instead I use custom hooks, helper functions, or a service layer when the logic needs to be reused or tested independently. I also care about naming, linting, and TypeScript types because those small choices reduce confusion later. In larger apps, I like to establish patterns early for navigation, API calls, error handling, and state management so the codebase grows in a controlled way instead of becoming a collection of one-off solutions.
Question 5
Difficulty: medium
How do you handle state management in a React Native application?
Sample answer
I start by matching the state solution to the problem. Not every app needs a heavy global store. Local component state works well for UI details, input values, toggles, and temporary screen behavior. For shared app data like user profile, authentication, or cross-screen cache, I use a more centralized approach. Depending on the complexity, that could be Context, Redux Toolkit, Zustand, or a dedicated server-state tool. I pay attention to whether the state is client state or server state, because those should often be managed differently. For server data, I like caching, refetching, and loading-state support rather than manually duplicating everything in the app. My main priority is making state predictable. If a teammate can trace where the data comes from and what changes it, then the app is easier to debug and evolve. I try to avoid overengineering, but I also avoid scattering important app data across too many unrelated components.
Question 6
Difficulty: easy
How do you ensure a React Native app feels native on both iOS and Android?
Sample answer
I focus on the details that users notice immediately: spacing, touch feedback, platform conventions, and navigation patterns. Even when the app shares most of its logic, the UI should respect each platform’s expectations. That means using platform-appropriate components where needed, checking safe areas, handling keyboard behavior properly, and making sure fonts, shadows, and elevations look right on both systems. I also pay attention to gestures and transitions because those influence how polished the app feels. When a feature naturally behaves differently on iOS and Android, I don’t always force identical behavior; sometimes a small platform-specific adjustment creates a much better experience. I like to test on both platforms regularly, not just at the end, because layout issues can build up fast. Ultimately, a React Native app should feel intentionally designed, not just ported. If users can’t tell it was built with a cross-platform framework, that usually means the implementation is thoughtful.
Question 7
Difficulty: hard
Describe your experience working with native modules or third-party libraries in React Native. How do you evaluate them?
Sample answer
I’m comfortable using third-party libraries when they solve a real problem, but I evaluate them carefully before adopting them. I look at maintenance activity, issue history, compatibility with the current React Native version, and whether the library has a clear API and good documentation. I also consider whether the dependency is actively used in the community and whether it introduces unnecessary complexity. If I need functionality that isn’t available in JavaScript, I’m open to native modules or writing a small bridge, but I want to understand the long-term ownership cost first. A native dependency can be perfectly justified, especially for things like device APIs, advanced media handling, or specialized platform features. The key is to avoid adding libraries just because they seem convenient in the moment. I’d rather use a smaller number of well-understood dependencies and keep the upgrade path manageable than create a fragile app that becomes hard to maintain after six months.
Question 8
Difficulty: medium
How do you handle API integration, loading states, and error states in a React Native app?
Sample answer
I like to treat API integration as part of the user experience, not just data fetching. That means clear loading states, predictable empty states, and error handling that tells the user what happened without overwhelming them. I typically wrap network logic in a service or data layer so screens stay focused on presentation and user interaction. For requests, I try to handle retries, request cancellation where appropriate, and thoughtful caching if the same data is reused often. On the UI side, I make sure loading indicators are visible but not annoying, and I avoid showing a blank screen when a partial view would be more helpful. For errors, I distinguish between recoverable issues like a timeout and more serious issues like authentication failures. I also make sure the app logs enough diagnostic information for developers while keeping the message user-friendly. In mobile apps, network conditions vary a lot, so a strong integration strategy needs to handle weak connections, offline scenarios, and inconsistent response times gracefully.
Question 9
Difficulty: medium
Tell me about a time you had to collaborate with designers, backend engineers, or QA to deliver a mobile feature.
Sample answer
In one release, I worked on a checkout flow that required tight coordination between design, backend, and QA. The designers had created a clean flow, but once we mapped it to real device behavior, a few details needed adjustment, especially around keyboard handling and validation feedback. I worked with the backend team early to confirm request and response shapes so the API would support the front-end states we needed, including partial failures. With QA, I helped define test cases around slow networks, invalid coupons, and repeated taps on the pay button. I found that the best collaboration came from translating technical risks into concrete user scenarios rather than abstract problems. Instead of saying, “there might be a race condition,” I’d say, “if the user taps twice on a weak connection, we need to guarantee only one order is created.” That approach kept everyone aligned and made the release smoother because each team understood both the feature and its edge cases.
Question 10
Difficulty: hard
What would you do if a product manager asked for a feature that you believed could hurt app stability or maintainability?
Sample answer
I’d start by understanding the business goal behind the request. Often there’s a real reason for the feature, and the implementation detail is what needs adjusting. I’d explain the technical trade-offs clearly: what the risk is, why it matters, and what it could cost later in bugs, performance, or maintenance. Then I’d try to offer alternatives, such as a smaller version of the feature, a phased rollout, or a different implementation that achieves the same user value with less risk. I’ve found that most product partners respond well when you bring options rather than just a refusal. If the feature is still important, I’d suggest a prototype, spike, or limited release so we can validate the idea before committing fully. My goal is to protect the long-term health of the app without blocking progress. Good mobile development is often about making practical compromises that support both product goals and engineering quality.
