Senior Mobile Engineer Interview Questions & Answers
40 questions for Senior Mobile Engineer interviews — 19 medium, 21 hard.
About the Senior Mobile Engineer role
A senior mobile engineer designs architecture for large cross-platform apps, sets standards for state management and testing, and owns app quality metrics like crash-free rate, startup time and app size. They review code, mentor juniors, integrate native SDKs and lead tricky migrations such as adopting the React Native New Architecture. Interviews focus on mobile system design, trade-offs and leadership examples.
Mobile system design Performance optimisation Native integrations Code review and mentoring Testing strategy
Solved for this roleStart practicing
3 QUESTIONS FREESign up to unlock the full question bank and track your progress.Unlock every question and answer, then continue practising company-wise and package-wise.
✓ 3 questions free • Unlock the rest in seconds
01
The product team wants the same app on mobile and web from one codebase. What would you propose?
With React Native, Expo with Expo Router and React Native Web lets one codebase target Android, iOS and web, with file-based routes working as URLs. With Flutter, the web target exists but suits app-like experiences more than SEO-heavy pages. I would share business logic and most screens, keep SEO landing pages on a web framework, and plan for platform-specific tweaks like hover states and keyboard navigation.
02
The API responses are slow on mobile networks. What can the mobile team ask the backend team to change?
Ask for pagination with sensible page sizes, gzip or brotli compression, removing unused fields or providing screen-specific endpoints, and aggregated endpoints to avoid multiple sequential calls. Request proper cache headers and ETags so the client can reuse responses. Ask for resized images through a CDN and HTTP/2 or HTTP/3 support. Share measured timings from real devices to justify the requests.
03
Write a Dart HTTP client using dio with an interceptor that adds an auth token.
Pause the staged rollout to limit impact. Filter crash reports by OS version and device to find the top stack trace, and check behaviour changes for that version, such as permission, background or edge-to-edge rules. Reproduce on an emulator of that version, fix it, add a regression test and resume rollout with a hotfix. Add that OS version to the regular test device matrix.
05
How would you migrate a large React Native app from JavaScript to TypeScript?
Enable TypeScript with allowJs so both coexist, start with a relaxed tsconfig, and convert shared code first: API types, models, utilities and navigation param lists. Then convert screens feature by feature, tightening strict options gradually. Add type checks to CI so new files must be TypeScript. Avoid using any to silence errors; use unknown and narrow. Track progress and celebrate milestones to keep momentum.
06
Your team has no automated tests and frequent regressions. How would you introduce testing?
Start where bugs hurt most: write unit tests for business logic like pricing, validation and state transitions, and a few end-to-end smoke tests for login, checkout and payment flows with Maestro or integration tests. Run them in CI on every pull request so failures block merges. Require tests for bug fixes going forward. Show reduced regressions after a few sprints to build team support.
07
Deep links open the app but land on the home screen instead of the product page. How do you debug it?
Check that the link configuration maps the URL path to the right screen name, including nested navigators, and that path parameters match. Verify verified link setup on both platforms: assetlinks.json for Android and the associated domains entitlement plus the site association file for iOS. Test with adb shell am start and xcrun simctl openurl. Also handle links when the app is cold started versus already running.
08
How do you handle gestures such as swipe to delete in React Native?
Use react-native-gesture-handler, which processes gestures on the native side, often with Reanimated for smooth animations. For swipe to delete, the Swipeable or ReanimatedSwipeable component renders action buttons behind a row. Define gestures with the Gesture API, such as Gesture.Pan, and compose them when needed. Wrap the app root in GestureHandlerRootView. Provide an accessible alternative like a long-press menu for screen reader users.
09
Your company wants to publish the same app for five white-label clients. How do you manage builds and store listings?
Keep one codebase and create a configuration per client with app ID, name, icons, colours, API base URL and feature flags, using Android flavours and iOS targets or schemes, or dynamic Expo app config. Automate builds for each client in CI with fastlane or EAS. Each client usually needs its own store account or listing, so document signing keys and access per client and automate metadata uploads.
10
What security practices should every mobile app follow?
Use HTTPS everywhere and consider certificate pinning for high-risk apps. Store tokens only in secure storage, never log sensitive data, and keep secrets on the server. Obfuscate release builds, validate all input on the server, and protect sensitive screens from screenshots where needed. Check device integrity with platform attestation APIs for high-risk actions, and follow the OWASP Mobile Application Security Verification Standard as a checklist.
11
How do you communicate a delayed release to stakeholders?
I inform them as soon as I know, not on the release day. I explain the reason briefly, such as a store rejection or critical bug, the impact, the new estimated date, and what we are doing to avoid repeating it. I offer options, like releasing other features first. Regular short updates until release keep trust, and I note learnings in the release retrospective.
12
How do you manage form state and validation across multiple steps in a Flutter onboarding flow?
Keep the onboarding data in one state object owned by a notifier or cubit scoped to the flow, with each step updating its part. Validate per step before moving forward and again on final submit. Save progress locally so users can resume if they leave. Keep validation rules in pure functions that are unit tested. Dispose the state when the flow completes so data does not leak into later sessions.
13
Write a React Native function that uploads an image with progress using Expo FileSystem.
Server state, such as data fetched from APIs, has caching, refetching, staleness and retry concerns that client state libraries do not handle well. TanStack Query caches responses by query keys, deduplicates requests, refetches on focus or reconnect, supports pagination and infinite queries, optimistic updates and offline persistence. It removes large amounts of useEffect and loading-state code and keeps screens consistent.
15
Two users editing the same shared list offline create conflicting changes. How do you resolve conflicts?
Choose a strategy based on data. Last write wins, using server timestamps, is simple but can lose edits. Field-level merging keeps non-conflicting changes. For lists, treat each item as a separate record with its own version so edits rarely clash. For collaborative content, CRDT-based approaches merge automatically. Always let the server decide final order, and show users when their change was overwritten.
16
What would you do if you joined a project and found the codebase poorly structured?
I would first understand why it is that way, since deadlines and changing requirements often explain it. I would document the main pain points with examples, such as frequent bugs in a module, and propose small improvements tied to upcoming features rather than a rewrite. I would add tests around risky areas first. Showing measurable wins, like fewer bugs, builds trust for larger refactors later.
17
Tell me about a bug that was hard to reproduce and how you solved it.
Situation: some users reported a blank screen after login, but no one on the team could reproduce it. Task: find the cause. Action: I added breadcrumb logs and non-fatal error reports around the login flow, and found it happened when the device clock was wrong, making tokens appear expired. I changed expiry checks to rely on server responses. Result: reports stopped, and we kept the breadcrumbs for future debugging.
18
The Firestore bill is growing fast because of too many reads. How do you reduce it?
Find screens that listen to large collections or re-read data on every rebuild. Paginate queries with limits, listen only to needed documents, detach listeners when screens close, and avoid starting listeners inside build methods. Denormalise data to reduce reads per screen, cache data locally with offline persistence, and use aggregate count queries instead of reading all documents to count. Monitor usage per collection.
19
An animation stutters whenever the screen fetches data. How do you fix it?
The animation likely runs on the JS thread, and data parsing or re-renders block it. Move the animation to the UI thread with Reanimated or Animated with useNativeDriver, reduce the work done when data arrives by memoising components and normalising state updates, and delay heavy processing with InteractionManager or requestIdleCallback-style scheduling until the animation finishes. Profile with React Native DevTools to confirm.
20
A Flutter animation is smooth on a flagship phone but janky on a budget phone. How do you fix it?
Profile on the budget device in profile mode. Common fixes: wrap frequently repainting areas in RepaintBoundary, avoid expensive effects like Opacity on large subtrees, clipping and shadows in scrolling lists, use AnimatedBuilder with child so static parts do not rebuild, precache images and decode them at display size, and move heavy computation to isolates. Reduce animation complexity on low-end devices if needed.
21
How do native modules work, and when do you write one?
A native module exposes platform code written in Kotlin, Java, Swift or Objective-C to JavaScript. With the New Architecture, you define a typed TypeScript spec, Codegen generates interfaces, and the TurboModule implements them natively. Expo Modules API offers a simpler way using Swift and Kotlin. You write one when no library supports a needed SDK or device feature, such as a specific payment or biometric SDK.
22
The app needs a bottom navigation bar where each tab keeps its own navigation history. How do you implement it?
Use go_router's StatefulShellRoute.indexedStack, which creates a separate navigator branch for each tab and keeps their stacks alive with an IndexedStack. The scaffold shows a NavigationBar and switches branches with navigationShell.goBranch(index). This preserves scroll positions and nested pages when switching tabs, and deep links can open a specific tab and page. Handle tapping the active tab to pop to its root.
23
Tell me about a time you improved app performance in a cross-platform app.
Situation: our React Native order history screen took three seconds to render and scrolled poorly. Task: make it smooth. Action: I profiled with React Native DevTools, replaced ScrollView with FlashList, memoised rows, moved date formatting into the API layer and switched images to a caching library. Result: render time dropped below 600 milliseconds, and frame drops nearly disappeared on budget phones.
24
How would you set quality gates before a mobile release?
Define clear criteria: all automated tests pass, no open critical or high bugs, crash-free rate in beta above an agreed threshold like 99.5 percent, performance budgets for startup time and app size met, accessibility checks on new screens, and security review for sensitive changes. Run smoke tests on the release build on real devices. Release with a staged rollout and monitor metrics before expanding.
25
A payment shows success in the app but the order is not created on the server. How would you fix the flow?
The app is probably treating the SDK's success callback as final and the verification call failed or was never sent, for example when the app was killed. Make the backend the source of truth: verify payments with the gateway's signature on the server and use webhooks to update orders even if the app never reports back. The app should poll order status after payment and show a pending state until confirmed.
Provider is simple and built on InheritedWidget but depends on BuildContext and can throw provider-not-found errors at runtime. Riverpod, from the same author, is compile-safe, independent of the widget tree, supports async providers and easy overrides for testing. Bloc uses events and states with streams, enforcing strict separation and traceability, popular in large teams and enterprises. Choose based on team familiarity and app complexity.
27
Users lose their place in a long Flutter form when they get a phone call and the app is killed in background. How do you fix it?
The operating system may kill the app process in background, and in-memory state is lost. Save draft form data to local storage, such as shared_preferences, Hive or a SQLite table, as the user types with a short debounce, and restore it when the screen opens. Flutter's RestorationMixin and restorationScopeId can restore simple UI state like scroll position and text fields. Clear the draft after successful submission.
28
The JS bundle grew large and startup is slow. How do you reduce startup time in React Native?
Measure time to interactive on a release build first. Make sure Hermes is enabled, remove unused dependencies and heavy libraries like full date or icon packs, and lazy-load screens and modules with inline requires. Defer non-critical SDK initialisation until after the first screen. Keep the initial screen light, avoid large synchronous storage reads at startup, and use the New Architecture for faster native module loading.
29
You are designing a large Flutter app for a bank with 30 developers. How do you structure it?
Split the app into feature packages in a monorepo managed with Melos or pub workspaces, plus core packages for networking, design system, analytics and security. Pick one state management approach, such as Bloc for strict traceability, with clear layer boundaries. Use code generation consistently, enforce lints and architecture tests in CI, and assign feature ownership. Add integration tests for critical journeys and strict security reviews for storage and network code.
30
A screen re-renders every time the user types in a search box, making it laggy. How do you fix it?
Keep the search text state local to the search input component so only it re-renders, debounce the query before updating the list or calling the API, and memoise the list and row components. Avoid storing frequently changing values in a global store that many components subscribe to. Use the React DevTools profiler to confirm which components render, and useDeferredValue to keep typing responsive.
31
The app takes six seconds to start on low-end phones. How do you improve it?
Measure cold start on a release or profile build and trace what runs before the first frame. Defer non-critical SDK initialisation such as analytics and ads, avoid large synchronous storage reads and network calls before showing UI, load the first screen with cached data, and lazy-load other features. In Flutter, keep main() light; in React Native, use Hermes and inline requires. Use a native splash screen to avoid a blank screen.
Store data in a local database and render the UI from it, so the app works without network. Queue user changes locally with a pending status and sync them in the background when connectivity returns, using retries with backoff. Fetch server changes using timestamps or sync tokens and merge them. Resolve conflicts with clear rules like last write wins or server authority, and show sync status to users.
In Bloc, the UI adds events, the Bloc handles them with on<Event> handlers and emits new immutable states, and widgets rebuild with BlocBuilder or react with BlocListener. A Cubit is a simpler version where the UI calls methods directly and the Cubit emits states, without event classes. Use Cubit for straightforward logic and full Bloc when you need event transformations like debounce or detailed traceability.
34
How would you plan a staged rollout for a major redesign?
Release to internal testers and beta users first and collect feedback. Then roll out to 5 percent of production users, monitoring crash-free rate, ANRs, key conversion metrics and reviews for a few days, before moving to 20, 50 and 100 percent. Keep the redesign behind a remote flag to switch back without a release. Define rollback criteria in advance and communicate the plan to support teams.
35
What is a performance budget and how do you enforce it?
A performance budget sets limits on metrics like cold start time, app download size, frame rendering time and memory usage. Enforce it by measuring in CI, for example tracking release build size per pull request and running startup benchmarks on a reference device, and failing or flagging builds that exceed limits. Budgets make performance a shared responsibility rather than something fixed only after users complain.
36
How do you write a Fabric native component or use one in React Native?
A Fabric component wraps a native view for use in JavaScript. You write a TypeScript spec using codegenNativeComponent with typed props, run Codegen to generate C++ and platform interfaces, and implement the view in Kotlin and Objective-C or Swift. With Expo, the Expo Modules API lets you define a native view in Kotlin and Swift with less boilerplate. Use this for maps, video players or custom SDK views.
Test business logic without widgets. For Bloc, the bloc_test package's blocTest builds the bloc with a fake repository, acts by adding events, and expects a list of emitted states. For Riverpod, create a ProviderContainer with overrides for repository providers, read the notifier, call methods and assert the state. Use mocktail for mocks and keep tests fast, deterministic and independent of the network.
38
Integration tests pass locally but fail randomly in CI. How do you make them reliable?
Flaky tests usually come from timing assumptions, shared state, network dependence or slow emulators. Replace fixed delays with waiting for specific conditions, mock or stub network calls with predictable responses, reset app data between tests, and use stable selectors like keys or test IDs instead of text that changes. Give CI emulators enough resources, retry only as a temporary measure, and track flaky tests separately to fix them.
39
What are the JS thread and UI thread in React Native and why do they matter?
JavaScript, including React rendering and business logic, runs on the JS thread, while the native UI thread draws views and handles touches. If the JS thread is busy with heavy computation or large re-renders, taps and JS-driven animations lag even though the UI thread is free. Keep heavy work off the JS thread, move animations to the UI thread with Reanimated, and split expensive tasks into smaller chunks.
40
How do you integrate a payment gateway in a mobile app safely?
Create the order on your backend with the amount, get an order ID, and open the gateway's SDK checkout in the app with that ID. After payment, the SDK returns a payment ID and signature, which the app sends to the backend to verify with the secret key before marking the order paid. Rely on server-side webhooks as the final truth. Never keep secret keys in the app or trust client-side success alone.
Frequently asked questions
What does a Senior Mobile Engineer do?
A senior mobile engineer designs architecture for large cross-platform apps, sets standards for state management and testing, and owns app quality metrics like crash-free rate, startup time and app size. They review code, mentor juniors, integrate native SDKs and lead tricky migrations such as adopting the React Native New Architecture. Interviews focus on mobile system design, trade-offs and leadership examples.
Which skills are tested in a Senior Mobile Engineer interview?
Expect questions on Mobile system design, Performance optimisation, Native integrations, Code review and mentoring, Testing strategy. Most rounds also ask you to explain a project and solve one practical problem live.
How do I prepare for a Senior Mobile Engineer interview?
Revise Flutter State Management and Architecture, React Native Navigation, State and Native Modules, Testing, Performance and CI/CD, Mobile Backend, APIs and Firebase first using the topic sheets, practise the questions on this page aloud, then do one full mock interview to practise timing.