Mobile Developer Interview Questions

Your app crashes on resume with a TransactionTooLargeException only on Samsung devices after users background it during a long form. How would you diagnose what's bloating the saved instance state and restructure state handling to survive process death?

After migrating callbacks to Kotlin coroutines, QA reports intermittent UI freezes when users rotate the screen mid-network-call. Walk me through how you'd audit your coroutine scopes, dispatchers, and lifecycle ties to find where structured concurrency was violated.

A teammate used GlobalScope for a fire-and-forget upload, and now uploads silently die when the Activity finishes on low-RAM tier-2 city devices. How do you redesign this so the upload survives reliably without leaking the Activity?

Your Compose screen recomposes hundreds of times per second during a simple scroll, tanking frame rates on 2GB RAM phones. What's your methodology with Layout Inspector and recomposition counts to isolate unstable parameters and fix the skipping?

Users on Android 14 report your foreground service gets killed minutes after starting, while Android 11 users are fine. How would you trace the behavior change, pick the right foreground service type, and handle the new restrictions?

You inherit a codebase mixing LiveData, RxJava, and Flow across modules, and race conditions keep surfacing in production. How do you plan an incremental migration to a single reactive stack without freezing feature delivery for two quarters?

A NullPointerException from a Java interop layer keeps hitting production despite Kotlin's null safety. How do you harden the boundary — annotations, platform-type audits, defensive mapping — and stop trusting unannotated Java SDKs your payments partner ships?

Your app's cold start jumped from 1.2s to 3.5s after adding three SDKs, and Play Vitals flags you. Describe how you'd use Macrobenchmark and App Startup to find the culprits and defer or lazy-init them safely.

Your RecyclerView list of orders stutters badly on entry-level devices common in tier-2 markets. Image loading is already async. What would you check next — view inflation cost, DiffUtil misuse, nested layouts, overdraw — and in what order?

Leadership wants one codebase feature shared with iOS via Kotlin Multiplatform, but your team has zero KMP experience. Which layers would you share first, what risks do you flag, and how do you keep the Android app shippable throughout?

A WorkManager job that syncs invoices runs twice on some OEM devices, double-posting data. How do you investigate duplicate scheduling, OEM battery-manager interference, and idempotency, and what guarantees do you actually promise the backend team?

After enabling R8 full mode, a release-only crash appears in a reflection-based JSON parser while debug builds work perfectly. Walk through your process: mapping files, keep rules, and deciding whether to fix rules or kill reflection entirely.

Your Compose and View-based screens coexist, and shared element transitions between them feel janky and occasionally crash on fold/unfold of a Samsung Flip. How do you architect the interop boundary and decide which screens migrate next?

A memory leak ships every few releases because juniors keep capturing Activity context in singletons. Beyond code review, what compile-time checks, LeakCanary CI gates, and architectural conventions would you institutionalize to make this class of bug rare?

Your iOS app gets terminated by the watchdog at launch for some users, and crash reports show 0x8badf00d. How do you find what's blocking the main thread during didFinishLaunching and restructure startup work?

After adopting Swift Concurrency, you see sporadic data races flagged by the Thread Sanitizer in a cache layer that mixes async/await with legacy GCD queues. How do you draw actor boundaries and migrate without rewriting the whole layer?

A retain cycle between a view controller and its closure-based network callbacks is leaking entire screens. Memory graph shows hundreds of stale instances. Describe your triage with Instruments and the conventions you'd enforce to prevent recurrence.

Your SwiftUI list of transactions re-renders the entire hierarchy on every keystroke in a search field, lagging on older iPhones still common among Indian users. How do you profile body re-evaluations and restructure state to contain invalidation?

Users complain that returning to your app after a phone call loses their half-filled KYC form. Explain how you'd implement state restoration and decide what belongs in scene state versus persisted drafts.

A third-party analytics SDK is crashing in production with symbols you can't read, and the vendor is slow to respond. How do you symbolicate, isolate the SDK behind a wrapper, and design a kill switch so one vendor can't take down your app?

Your app's memory footprint spikes when users browse a photo-heavy feed, triggering jetsam terminations on 3GB iPhones. What would you change in image decoding, downsampling, and caching to keep the footprint flat while scrolling?

Finance asks why your iOS release is two weeks behind Android every cycle. You find slow Xcode builds, flaky signing, and manual TestFlight steps. Lay out how you'd cut iOS cycle time in half without hiring.

After an iOS update, your custom keyboard-avoidance logic breaks and text fields hide behind the keyboard on smaller iPhones. How do you decide between patching the manual logic and migrating to system-provided layout guides, given release pressure?

You must support iOS 15 through 18, and SwiftUI bugs differ per OS version. How do you structure availability checks, fallback UIKit paths, and a device-lab test matrix so one team can sanely own four OS generations?

Background URLSession uploads of large documents complete on Wi-Fi but silently stall for users on metered 4G with Low Data Mode enabled. How do you diagnose discretionary scheduling behavior and design resumable uploads users can trust?

A Core Data migration crashed for a slice of users upgrading from a two-year-old app version, leaving them stuck on the splash screen. Walk through your recovery options in production and how you'd test migrations across old store versions.

Your app binary crossed 200MB and App Store cellular download behavior is hurting installs. How do you attack binary size — asset catalogs, on-demand resources, dead Swift code, static versus dynamic frameworks — and what wins come first?

Your Flutter app janks every time a new screen with images opens, but only on first navigation. How would you distinguish shader-compilation jank from widget-build cost, and what concrete fixes apply to each on mid-range Android phones?

A plugin you depend on for UPI payments is abandoned and breaks on the latest Android target SDK. Compare your options — forking, replacing, writing a platform channel yourself — and the criteria you'd use to choose under a deadline.

setState calls scattered across a 2,000-line widget file make a checkout screen unpredictable, and bugs regress every sprint. How do you carve this into a sane state-management structure incrementally while the screen keeps shipping changes?

Your Flutter app's memory climbs steadily during a long browsing session until Android kills it on 2GB devices. Describe your leak-hunting workflow with DevTools, common culprits like retained controllers and image caches, and how you'd add regression guards.

Text and icons render fine on most phones, but on a popular budget device with unusual DPI your layouts overflow and clip. How do you reproduce, audit hardcoded sizes, and build a responsive strategy that survives India's device diversity?

Platform-channel calls to a native Bluetooth SDK intermittently deadlock your UI isolate during device pairing. How do you redesign the threading model across Dart isolates and native handlers, and what instrumentation proves the fix?

After a Flutter SDK upgrade, golden tests fail en masse with one-pixel differences and your team wants to delete them. How do you decide what golden coverage is worth keeping and make the suite resilient to engine changes?

Your app ships to both stores from one Flutter codebase, but iOS users complain it feels like an Android app — wrong scroll physics, wrong transitions. Where do you draw the line between platform-adaptive widgets and a unified brand experience?

A ListView.builder rendering chat messages with mixed media stutters when users fling-scroll on low-end devices. Which Flutter-specific levers — itemExtent, RepaintBoundary, cacheExtent, image pre-sizing — would you try, and how do you measure each change honestly?

Build times for your Flutter monorepo crossed 20 minutes in CI and developers stopped running tests locally. How do you restructure into packages, cache builds, and shard tests to get feedback under five minutes?

Product wants a Flutter module embedded inside an existing native Android super-app. What integration pitfalls do you anticipate — engine warm-up cost, navigation handoff, shared auth state — and how do you keep both teams unblocked?

Your Dart code throws an unhandled exception inside an async callback and the app continues in a corrupted state instead of crashing visibly. How do you set up zone-level error capture and decide which errors should fail loudly?

Impeller rollout caused rendering artifacts on a subset of Adreno GPUs that your Indian user base over-indexes on. How do you build a device-tier strategy for toggling rendering backends and validating visual correctness at scale?

Your React Native list screen drops frames whenever new API data arrives, and the profiler shows massive re-renders. Walk through how you'd track unnecessary renders, memoize correctly, and decide if FlashList replacement is justified.

Migrating to the New Architecture broke two community libraries your payments flow relies on. How do you sequence the migration — interop layers, patch-package stopgaps, library replacement — while production releases continue weekly?

A gesture-heavy carousel feels smooth on iPhones but laggy on budget Androids your users actually own. Explain how bridging costs and JS-thread contention cause this, and how you'd move the animation work onto the UI thread.

Your team ships JS updates over CodePush-style OTA, and one bad bundle bricked the app's home screen for thousands of users overnight. Design the rollback, staged rollout, and bundle-validation guardrails you'd put in place afterward.

Crash logs show 'undefined is not an object' spiking in production but you can't reproduce locally. How do you wire source maps, error boundaries, and release-channel metadata so JS crashes become actionable instead of noise?

Your RN app's Android startup is 4 seconds on devices common in tier-2 cities. Break down where time goes — native init, bundle parse, JS execution, first render — and the highest-leverage fixes for each segment, including Hermes options.

A native module for biometric login works on Android but crashes on iOS when invoked twice quickly. How do you debug across the bridge, reason about promise lifecycle in native code, and add guards on both sides?

Leadership questions whether to stay on React Native after three quarters of upgrade pain. How would you frame the evaluation — upgrade cost trends, team skills, native-feature roadmap, hiring market — and what evidence would change your recommendation?

Your app's JS bundle crossed 12MB and TTI suffers on cheap phones. What's your approach to bundle analysis, code-splitting with lazy requires, asset slimming, and stopping the next dependency from undoing your work?

An infinite re-render loop from a misused useEffect drained users' batteries and your store rating dropped. Beyond the fix, what lint rules, render-count telemetry, and review practices would you add to catch effect misuse before release?

Keyboard handling on your chat screen behaves differently across iOS, stock Android, and MIUI, producing overlapped inputs. How do you build one abstraction that survives OEM quirks, and how do you test it without owning fifty devices?

You're asked to share business logic between your RN app and a new web dashboard. How do you structure a monorepo, isolate platform-specific code, and prevent web-oriented dependencies from bloating or breaking the mobile bundle?

Reanimated worklets crash in release builds only, with cryptic stack traces after minification. Describe your strategy for debugging worklet crashes, controlling Babel plugin order, and deciding what animation logic shouldn't live in worklets at all.

Two field agents edit the same customer record offline on flaky 4G, and sync produces silent data loss. Design a conflict-resolution strategy — last-write-wins versus field-level merge versus manual review — and justify it for this domain.

Your offline-first order queue occasionally posts the same order twice when the network drops mid-request and retries fire. Explain how you'd implement idempotency keys end to end and verify the fix against real network chaos.

Users in low-connectivity areas see stale prices that change on checkout, destroying trust. How do you design cache TTLs, server-driven invalidation, and honest UI staleness indicators so offline convenience doesn't become a business liability?

Your sync engine retries failed uploads aggressively, and users on metered connections complain about data consumption. How would you redesign retry backoff, batching, and network-type awareness while keeping data freshness acceptable for the business?

A delta-sync protocol you built drifts out of consistency after weeks of use, and full re-syncs are too heavy for 2GB devices. How do you add checksums, repair flows, and self-healing without redesigning the protocol from scratch?

Product wants the app to 'just work offline' for a feature involving search across 50,000 catalog items. What do you push back on, what do you ship — local index strategy, storage budget, update cadence — and why?

Your queue of offline mutations replays in order, but one permanently failing mutation blocks everything behind it for some users. How do you redesign for partial progress — dead-lettering, dependency tracking, user-visible resolution — without corrupting data?

After a schema change, old queued offline records fail server validation and users lose a day's field entries. What versioning and migration strategy for queued payloads would you implement so app updates never strand unsynced data again?

You're choosing between rolling your own sync on SQLite, using a sync-enabled database, or a CRDT library for a collaborative notes feature. Walk through the trade-offs for an Android-heavy user base on intermittent networks.

Users report the app shows 'synced' but the web dashboard misses their entries for hours. How do you instrument the sync pipeline so support can trace a single record's journey, and what does the sync-status UI actually promise?

Your app must work for a 10-hour shift in rural areas with zero connectivity, then sync everything during brief coverage windows. How do you prioritize what syncs first, handle auth-token expiry offline, and design for power loss mid-sync?

Clock skew on cheap Android devices is wrecking your timestamp-based conflict resolution — some devices are minutes off. How do you detect skew, switch to server-authoritative ordering or logical clocks, and migrate without breaking existing data?

Your offline image attachments fill device storage and Android starts clearing your app's cache, deleting unsynced photos. How do you separate evictable cache from must-keep pending uploads, and warn users before storage pressure causes loss?

Play Vitals shows your ANR rate above the bad-behavior threshold, concentrated on 2GB RAM devices. Describe your triage workflow from ANR traces to root cause, and the three most common ANR sources you'd suspect first.

Your app performs fine in office testing but users in tier-2 cities on budget phones report it 'hangs'. How do you build a low-end-device performance program — device tiers, synthetic throttling, field telemetry — that keeps regressions out?

A heap dump after a memory crash shows thousands of bitmap allocations retained by an image cache that should be bounded. How do you verify cache configuration versus leak, and what sizing policy fits devices from 2GB to 12GB RAM?

After a release, scroll jank doubled but no single commit looks guilty. How would you set up automated performance regression detection — macrobenchmarks in CI, frame metrics in production, bisection strategy — so this never takes a week again?

Your app's startup shows a 2-second blank white screen before content. Separate the contributions of process start, dependency injection graph, synchronous disk reads, and first-frame rendering, and explain how you'd measure each rather than guess.

Marketing added two more analytics SDKs and frame drops rose 30%. How do you quantify per-SDK performance cost, present the evidence to non-engineering stakeholders, and design an SDK governance process with measurable budgets?

Users report the app gets slower the longer they use it, recovering after restart. What categories of degradation would you investigate — listener accumulation, cache growth, fragment back-stack depth, thread leaks — and how do you reproduce a 'two-hour session' quickly?

Your video feed feature must run on devices with 2GB RAM where the OS kills you for exceeding budget. Define a memory budget per screen, the enforcement tooling, and the graceful degradation ladder when devices can't afford full fidelity.

A jankless animation in isolation stutters when a background JSON parse of a large config runs concurrently. Explain the contention — CPU cores, GC pressure, thread priorities — and the fixes you'd apply on low-core budget chipsets.

You're handed a target: P90 cold start under 2 seconds on a Redmi-class device. Current P90 is 4.8s. Lay out a milestone plan — baseline profiles, deferred init, splash strategy, code elimination — with expected gains per step.

OutOfMemoryError crashes cluster on a screen that stitches multiple full-resolution camera photos. What decoding, downsampling, and streaming changes keep peak memory flat, and how do you prove the fix on a real 2GB device?

Your performance dashboards look healthy but app-store reviews keep saying 'slow'. How do you reconcile telemetry with perception — instrumenting user-centric metrics like interaction latency and rage taps — and find what your dashboards aren't measuring?

GC pauses during typing make your search-as-you-type feature feel sticky on entry-level Androids. How would you confirm GC as the culprit, then reduce allocation churn in the hot path — object pooling, string handling, debounce design?

Your app appears in Android's battery-blame screen for some users, and uninstall surveys cite battery drain. How do you reproduce and attribute drain — wakelocks, sync frequency, location usage — and prioritize fixes by measured impact?

A periodic location ping powers your delivery-tracking feature, but Doze, OEM battery managers, and Android 14 restrictions each break it differently. Design a background-location strategy that degrades predictably across Xiaomi, Vivo, Oppo, and stock Android.

WorkManager jobs scheduled for nightly sync simply never run on several Chinese OEM devices unless users whitelist the app. How do you detect this population, guide users through OEM-specific settings, and design a fallback sync trigger?

Your iOS background app refresh-based prefetch works inconsistently, and product blames engineering. Explain how BGTaskScheduler budgets actually behave, how you'd instrument fulfillment rates, and how you'd reset product expectations with data.

After adding a step-counting feature using sensors, battery complaints spiked 4x. Walk through sensor batching, sampling-rate trade-offs, and how you'd A/B test battery impact before a full rollout.

A wakelock held by a third-party SDK keeps the CPU awake for hours, but removing the SDK isn't an option this quarter. How do you contain the damage — process isolation, conditional init, vendor escalation with evidence — and monitor it?

Your chat app must feel instant, but holding a persistent socket in background murders battery on 4G. Compare push-triggered wake versus persistent connection versus hybrid, with the metrics you'd use to pick for an Android-heavy user base.

Battery drain reports spike only for users on poor networks — radios retrying constantly. Explain how network conditions multiply battery cost and how you'd redesign request batching, prefetch windows, and failure backoff for flaky 4G towns.

Product wants real-time order status updates every 10 seconds while the app is backgrounded. What do you counter-propose, given platform background limits, and how do you frame the battery-versus-freshness trade-off in product language?

An expedited WorkManager job for payment confirmation gets deferred under battery saver, causing 'payment stuck' complaints. How do you redesign the confirmation flow so correctness never depends on background execution guarantees?

You're building an SDK other apps embed, and your background work could get host apps flagged for battery abuse. What self-limiting design — work coalescing, host-configurable budgets, telemetry transparency — would you build in from day one?

Field testing shows your app drains 8% battery per hour while seemingly idle. Describe your isolation methodology — Battery Historian, energy profiler, feature-flag bisection — to find whether GPS, network, sensors, or wakelocks are responsible.

Delivery analytics show 40% of your FCM notifications never display on Xiaomi and Vivo devices. How do you separate token staleness, OEM app-killing, and notification-channel misconfiguration, and what fixes apply to each?

A marketing blast sent a malformed data payload and crashed your notification handler on millions of devices at once. Design defensive parsing, crash isolation for the messaging service, and a payload contract process between backend and app teams.

Your OTP notifications arrive 30–90 seconds late for users on certain networks, breaking login flows. How do you investigate FCM priority handling, Doze behavior, and message TTL, and what's your fallback when push simply isn't fast enough?

Notification opens are double-counted because both your analytics SDK and custom tracking fire on tap, inflating campaign ROI. How do you architect a single source of truth for the notification lifecycle across cold start, background, and foreground states?

After iOS users update, your APNs tokens silently invalidate for a slice of devices and re-engagement campaigns miss them. How do you design token-refresh handling, server-side feedback processing, and alerting that catches silent delivery decay early?

Your app sends transactional, promotional, and OTP notifications through one pipeline, and users disabling promos also lose OTPs. Redesign channels and categories, server-side routing, and migration for existing users without losing critical reachability.

A rich notification with an image fails to render for users on slow 4G, showing a bare fallback after a long delay. How do image download timeouts work in notification extensions and services, and how would you make rich pushes degrade gracefully?

Android 13's notification permission tanked your opt-in to 55%. Design a permission-priming strategy — when to ask, contextual value framing, re-ask rules — and the experiment that proves it without annoying users into denial.

Tapping a notification while the app is already open navigates users away from a half-completed payment, causing drop-offs. How do you design in-app notification handling — suppression, in-app banners, navigation rules — per app state?

You must guarantee delivery of payment-confirmation messages even when push fails. Architect a layered reachability system — push, silent sync triggers, polling on app open, SMS fallback — with cost and latency trade-offs for the Indian market.

Silent pushes you rely on for background content refresh are throttled, and iOS delivers only a fraction. How would you measure actual silent-push fulfillment and redesign the refresh strategy assuming silent pushes are best-effort hints?

Your notification fan-out of 5 million messages causes a thundering herd as devices wake and hit your API simultaneously, taking the backend down. What client-side jitter, staggered send, and cache strategies prevent your own campaign from DDoSing you?

Google Play rejects your update for a background-location policy violation, but the feature is core to your delivery app. How do you build the declaration, in-app disclosure, and demo video that gets approval, and what's your fallback if denied?

A staged rollout at 20% shows a crash spike, but halting strands users on a version with a known payment bug. Walk through your decision framework — crash severity versus bug impact, hotfix timelines, store review delays — and who you involve.

App Store review rejects your build citing guideline 4.2 minimum functionality after a web-view-heavy feature shipped. How do you respond to the rejection, restructure the feature, and prevent web-view creep from triggering this again?

Your team ships every two weeks but emergency fixes regularly bypass process and break things. Design a release train — cut schedule, cherry-pick rules, hotfix lanes, release captain rotation — that survives both store review delays and 2 a.m. incidents.

Half your Android users are stuck three versions behind because updates over mobile data feel expensive in smaller cities. How do you combine in-app update APIs, app bundle size reduction, and forced-update policy without alienating users?

A Play Store policy email gives you seven days to fix a data-safety-form mismatch or face removal. How do you audit actual SDK data collection against your declaration quickly, and what process prevents drift between code and the form?

Your feature flags let marketing enable a half-tested feature on a Friday evening, causing weekend chaos. What flag governance — environments, approval gates, automatic kill switches, change windows — would you implement without killing experiment velocity?

You support a Play Store build, an iOS build, and a lite APK distributed outside the store for low-storage devices. How do you manage build variants, update mechanisms, and crash segmentation across three distribution channels sanely?

Post-release, you discover the shipped build used a wrong API endpoint flag pointing to staging for 5% of users. Reconstruct how your build pipeline allowed this, and design the configuration verification gate that makes it impossible.

Your app rating fell from 4.4 to 3.8 in a quarter, driven by reviews mentioning a redesign. How do you triage review data, separate vocal-minority noise from real regressions, and structure the response across product and engineering?

An app-signing key mishap means your CI can no longer produce Play-acceptable builds, mid release-cycle. Walk through Play App Signing recovery options, key rotation, and the secrets-management redesign you'd implement afterward.

Your iOS TestFlight feedback is silent, then App Store reviews surface a critical onboarding bug post-launch. How do you build a beta program — recruitment from real user segments, structured feedback, instrumented funnels — that actually catches such bugs?

Play Console shows your update halted at 60% adoption with the rest on a version containing a billing bug. Compare the levers — in-app update prompts, remote-config workaround, server-side mitigation — and how you'd sequence them this week.

Crashlytics shows a top crash with a fully obfuscated stack trace because mapping files weren't uploaded for that release. How do you recover symbolication retroactively, and what CI guardrail ensures mapping upload can never be skipped again?

A native SIGSEGV crash from a JNI image-processing library affects only arm32 devices, which dominate your tier-2 installs. Describe your debugging path — NDK symbolication, abi-specific repro, vendor triage — and interim mitigation by ABI targeting.

Your crash-free rate is 99.6% but support tickets describe freezes and force-kills that never appear in Crashlytics. Explain what crash reporting structurally misses — ANRs, watchdog kills, OOMs — and how you'd instrument each gap.

A crash reproduces only after 2–3 days of app usage in production, never in QA. What forensic breadcrumbs, state snapshots, and custom keys would you add to Crashlytics to debug long-session crashes you can't reproduce?

The same logical crash appears as five separate Crashlytics issues due to inlining and differing obfuscated frames across releases. How do you group, dedupe, and track the real fix across versions so the team stops re-triaging it?

An OOM crash wave hits only Android Go devices after a release with no obvious memory changes. Walk through differential analysis between releases — dependency bumps, resource changes, default config flips — when the diff looks innocent.

A crash spikes at 9 p.m. daily, correlating with a backend config push, but the stack trace points deep into JSON parsing. How do you connect server-side changes to client crashes and build a config-validation contract that prevents recurrence?

Your on-call gets paged for every crash spike, causing fatigue, while a slow-burning crash quietly became your top issue over a month. Design crash alerting — velocity triggers, severity scoring, user-impact weighting — that catches both patterns.

After enabling resource shrinking, a crash appears when a rarely-used screen can't find a drawable at runtime. Explain how shrinking removed it, how you'd find other at-risk dynamic resource lookups, and the keep configuration you'd write.

A crash in a coroutine appears in Crashlytics with a stack trace showing only dispatcher internals, no app frames. How do you make async stack traces actionable — debug probes trade-offs, custom exception wrapping, breadcrumb design?

Leadership wants 'zero crashes' as an OKR. Argue what crash-free-session target is realistic for your Android-heavy device spread, what investment each nine costs, and which non-crash stability metrics belong in the goal instead.

An iOS crash report shows EXC_BAD_ACCESS in objc_release with no app symbols on the offending thread. Outline your zombie-objects and over-release investigation, and when you'd reach for Address Sanitizer versus Instruments.

Your crash dashboard says a fix shipped two releases ago, yet the issue still reports from 'fixed' versions. How do you investigate — stale version metadata, OTA bundle mismatch with native version, incomplete rollout — and tighten version attribution?

You inherit a 300-screen app where ViewModels call repositories, singletons, and Activities directly, and every change breaks something. Lay out your strangler-pattern modularization plan — boundaries first, enforcement tooling, team conventions — over two quarters.

Your ViewModel survives rotation but a one-shot navigation event re-fires after every configuration change, double-navigating users. Compare event-handling approaches — single-event flows, consumed-state flags, channels — and justify what your team should standardize on.

Two feature teams keep breaking each other through a shared 'common' module that has become a dumping ground. How do you split it, define ownership and dependency rules, and add build-time enforcement so the dumping doesn't restart?

A junior put business rules for loan-eligibility inside a Composable, and now the web team can't reuse the logic and tests require UI rendering. How do you explain the layering violation and refactor it with minimal churn?

Your Clean Architecture implementation has so many mappers and use-case classes that adding one field touches nine files, and the team is rebelling. Where would you deliberately collapse layers, and what criteria distinguish useful abstraction from ceremony?

State for a checkout flow is duplicated across three ViewModels and they drift out of sync when users go back and edit. How do you restructure flow-scoped state — shared holder, navigation-scoped graph, single source of truth — and migrate safely?

Your app must support a 'lite mode' for low-end devices that disables animations, heavy modules, and prefetching. How do you architect capability-based feature gating so lite mode is a first-class configuration, not scattered if-checks?

Dependency injection setup time is visibly delaying your app start, with a giant Dagger/Hilt graph initialized eagerly. How do you audit component scoping, lazy provision, and module organization to cut startup contribution without breaking injection guarantees?

Product experiments require swapping entire checkout implementations per A/B cohort, and your current architecture hardcodes one flow. Design the abstraction seams, runtime selection, and test matrix that make experimentation cheap without forking the codebase.

Your repository layer mixes caching policy, retry logic, and data mapping in single 800-line classes that nobody dares touch. Walk through how you'd decompose responsibilities and characterize behavior with tests before refactoring.

A rewrite-versus-refactor debate is raging: the five-year-old app slows every feature, but a rewrite risks two years of stagnation. What evidence would you gather, what hybrid options exist, and how do you frame the recommendation to leadership?

You're defining architecture for a new app expected to reach 10 million Android-heavy users in three years with a team growing from 4 to 20. What decisions do you make now versus defer, and what's deliberately boring in your design?

Your API client retries on every failure, and during a backend incident your apps amplified traffic 10x, prolonging the outage. Redesign retry policy — exponential backoff with jitter, retry budgets, circuit breaking — for a mobile fleet at scale.

P95 API latency on 4G in smaller cities is 6 seconds versus 800ms on office Wi-Fi. How do you redesign the network layer — connection reuse, payload trimming, compression, request prioritization — and validate against real Indian network conditions?

Users see different account balances on two screens because each fetched and cached separately. How would you design a normalized client cache with one source of truth per entity, and what invalidation triggers keep screens consistent?

Your team debates GraphQL versus REST with BFF for a mobile app serving low-end devices on flaky networks. Frame the decision around payload control, caching semantics, versioning, and on-device parsing cost, and state your pick.

A misconfigured Cache-Control header made your app serve a stale feature-config for days, and clients ignored a critical fix. How do you audit HTTP-cache interplay with your local cache layer, and which data must bypass HTTP caching entirely?

Image bandwidth is 70% of your app's data usage, and users on prepaid data plans churn over consumption. Design a strategy — responsive image sizing, modern formats, network-aware quality, prefetch budgets — with measurable data-savings targets.

Requests fired during network transitions — elevator, metro, Wi-Fi-to-4G handoff — fail in confusing ways and users see generic errors. How do you classify failure modes and design retry, queue, or fail-fast behavior per request type?

A new backend rolled out HTTP/2, and a subset of Android devices behind certain carrier proxies started failing TLS handshakes. Describe your debugging across OkHttp logs, carrier behavior, and fallback configuration, and your protection against carrier weirdness.

Your app fires 14 API calls on home-screen load, and on 4G the screen takes 8 seconds to settle. How do you consolidate, prioritize above-the-fold data, and define a request budget that product features must fit within?

Your offline cache returns data instantly, but a slow revalidation then visibly rewrites the screen, and users mistrust the flicker. Design a stale-while-revalidate UX contract — what changes silently, what prompts, what animates — and the cache plumbing behind it.

A serialization library upgrade changed default field handling and your app silently dropped unknown JSON fields it later needed. How do you design schema-evolution tolerance between app versions and backend releases that deploy independently?

Your API tokens expire mid-session and three concurrent requests all trigger refresh, occasionally logging users out via refresh-token race. Design single-flight token refresh across your network stack, including process-death and multi-process edge cases.

A security audit finds auth tokens in SharedPreferences, plain text, on rooted devices. Walk through your migration to encrypted storage and Keystore-backed keys, including handling devices where Keystore operations intermittently fail.

Your banking-adjacent app must resist screen-recording malware prevalent on sideloaded-app-heavy Android devices. Which protections — FLAG_SECURE, overlay detection, accessibility-abuse checks — actually work, what breaks legitimate use, and how do you decide?

Certificate pinning you shipped two years ago is now causing outages because a cert rotation didn't match pinned values. Redesign pinning — backup pins, pin rotation strategy, remote kill switch — so security doesn't become an availability risk.

Fraud teams report bots driving fake referrals through your app's APIs. Compare Play Integrity, custom attestation signals, and behavioral detection, including how you handle the chunk of genuine Indian users on uncertified or rooted devices.

A penetration test exfiltrated your SQLite database from a backup of a non-encrypted device and read customer PII. Design your at-rest encryption approach, backup exclusion rules, and the data-classification exercise deciding what's stored at all.

Your app embeds an API key for a third-party service, and scrapers extracted it from the APK within a week, running up your bill. Explain why client-side secrets fail, and architect the proxy, scoping, and rotation fix end to end.

Deep-linked WebViews in your app load partner pages, and an audit flags JavaScript-bridge exposure to arbitrary origins. How do you lock down the WebView — origin allowlists, bridge scoping, navigation interception — without breaking partner integrations?

RBI-style data-localization and consent requirements hit your app, which currently logs verbose analytics including PII to a foreign-hosted service. Lay out your audit, log scrubbing, consent gating, and the SDK-vetting process you'd establish.

Users on shared family devices report seeing each other's sessions in your app. How would you design multi-account isolation, session invalidation on biometric or PIN change, and the trade-off between convenience and isolation for this market?

After a researcher reports your exported Android components allow intent-based data theft, you must respond within disclosure deadlines. Walk through component-exposure auditing, the fix, regression risks for legitimate inter-app flows, and your disclosure handling.

Your offline-capable app caches sensitive documents for field staff, and a lost device is a breach scenario. Design remote wipe, time-boxed offline access, and key-revocation mechanics that work when the device may never reconnect.

Crash logs accidentally captured request bodies containing Aadhaar-like identifiers, and they've been flowing to your crash vendor for months. What's your immediate containment, vendor data-deletion path, and the logging-hygiene framework you implement after?

Marketing complains that campaign deep links open the app but land on home instead of the promoted product for many Android users. How do you debug the routing — App Links verification, intent filters, cold-start handling — across OEM browsers?

Deferred deep links work inconsistently: users installing from a shared WhatsApp link sometimes lose attribution and context. Explain where deferred linking breaks on Android and iOS, and design a fallback context-recovery flow that degrades gracefully.

Your iOS Universal Links open Safari instead of the app for a subset of users after a domain migration. Walk through your AASA file validation, CDN caching pitfalls, and how you'd monitor link health continuously instead of finding out from support.

Your attribution SDK and in-house analytics disagree on install sources by 30%, and marketing budget decisions hang on the answer. How do you investigate methodology differences — lookback windows, fingerprinting limits, self-attributing networks — and establish one truth?

A deep link into your checkout screen crashes when required in-memory state from earlier screens is missing. How do you redesign screens to be entry-point independent, and what testing catches deep-link-reachable states that developers never enter manually?

iOS privacy changes gutted your install attribution, and finance asks how campaigns will be measured now. Explain your plan across SKAdNetwork conversion values, aggregated measurement, and honest communication about what's no longer knowable.

Links shared from your app preview poorly on WhatsApp — the dominant sharing channel for your users — hurting click-throughs. How do you architect link generation with proper previews, short links, and per-channel parameters at scale?

A malformed deep-link payload from an external partner triggered an injection-style navigation into an internal debug screen in production. Design deep-link validation — allowlisted routes, parameter sanitization, authority checks — as a security boundary, not just routing.

Notification taps, deep links, and widget launches each navigate through different code paths, and back-stack behavior differs confusingly between them. How do you unify entry-point navigation so back behaves predictably regardless of how users arrived?

After a router rewrite, dozens of marketing links in old emails and printed QR codes broke. How do you design a server-driven link-resolution layer with versioned routes so client refactors never invalidate links already in the wild?

Your referral feature credits the wrong user when an install comes minutes after multiple referral-link clicks from different friends. How do you define and implement attribution precedence, and how do you communicate the rules so disputes don't burn support?

Designers shipped a 60fps spring-animation spec, but on the budget Androids your users own it stutters visibly. How do you negotiate device-tiered motion — what degrades, what's preserved — and implement tiers without forking every screen?

A shared-element transition between list and detail intermittently leaves a ghost view or blank image, and the bug resists local repro. Walk through your instrumentation of transition lifecycle, image-load races, and the defensive design that eliminates the class of bug.

Your app looks broken with large font-scale and display-zoom settings used by many older users — overlapping text, clipped buttons. How would you audit text-scaling resilience systematically and fix layouts without pixel-perfect rigid redesign?

Your design system's animations were built ad hoc per screen, and motion feels inconsistent across the app. How do you institutionalize motion tokens — durations, easings, choreography rules — and enforce them in code review and tooling?

A skeleton-loading shimmer runs forever when an API hangs, and users stare at it without recourse. Design loading-state policy — timeouts, partial content, retry affordances, cached fallback — and where that policy should live architecturally.

Hindi and Tamil localization broke multiple screens: text expansion overflowed buttons and a script rendered with clipped glyphs. How do you build a localization-resilient layout strategy and a pseudo-localization testing step that catches this pre-release?

Users mis-tap a destructive 'delete entry' action placed near a frequent action, and support tickets pile up. Beyond moving the button, what touch-target, confirmation, and undo patterns would you apply, and how do you validate with real usage data?

An accessibility audit fails your app: TalkBack order is chaotic on custom views and animations can't be disabled. How do you prioritize remediation, build accessibility into your component library, and add automated checks that prevent regressions?

A Lottie animation on your home screen consumes noticeable CPU and the screen heats budget phones. How would you measure its real cost, optimize or replace it — static frames, simpler vectors, conditional playback — and set rules for future animation assets?

Your app must render a designer-mandated custom font across Devanagari and Latin scripts, but the font lacks full glyph coverage and fallback rendering looks jarring. How do you architect font fallback chains and test rendering across scripts and OS versions?

Pull-to-refresh, infinite scroll, and a collapsing header on one screen fight each other's gestures, frustrating users. How do you untangle nested scroll handling and decide which interactions to cut versus fix?

Foldables and tablets are growing in your user base, but your phone-only layouts waste large screens and crash on configuration changes mid-flow. Plan adaptive-layout adoption — window size classes, state preservation, test matrix — with minimal team disruption.

Your Espresso suite passes locally but flakes 20% of the time in CI, mostly on waits and animations. Walk through your de-flaking methodology — idling resources, animation disabling, hermetic data — and how you quarantine versus delete flaky tests.

Your team has 2,000 unit tests but production bugs are mostly integration failures — navigation, caching, process death. How do you rebalance the test pyramid for mobile reality, and what high-leverage integration coverage do you build first?

A payment regression shipped because tests mocked the network layer so thoroughly they validated mocks, not behavior. How do you introduce contract tests against backend schemas and decide what deserves real-dependency testing despite the cost?

You must validate releases across the device spread of the Indian market — MIUI, OneUI, Android Go, old iPhones — with a small team. Design a pragmatic device-coverage strategy mixing cloud device farms, a physical bench, and risk-based selection.

Appium tests for your cross-platform app take 90 minutes and break with every UI change because of brittle XPath selectors. How do you re-architect the suite — stable accessibility identifiers, page objects, parallel sharding — for a 15-minute reliable run?

Process death, permission revocation mid-flow, and storage-full conditions cause your worst production bugs, yet no test exercises them. How would you build a hostile-conditions test harness, and which scenarios give the most protection per effort?

XCTest UI tests fail only on CI simulators with keyboard and alert timing issues that never reproduce on developer Macs. How do you stabilize the simulator environment, handle system interruptions, and decide which flows belong in UI tests at all?

After an incident, leadership mandates 'test everything before release', threatening your weekly cadence. Design a risk-based release-testing strategy — automated gates, targeted manual passes, canary cohorts — that satisfies the mandate without doubling cycle time.

Screenshot tests catch visual regressions but your suite now fails on every intentional design tweak, and engineers rubber-stamp updates. How do you tune screenshot testing — component-level scope, review workflow, diff thresholds — so it stays trustworthy?

Your offline-sync engine has conflict-resolution logic too complex for example-based tests to cover. Make the case for property-based testing or simulation testing here — what invariants you'd assert, and how you'd shrink failures into actionable bug reports.

A flaky end-to-end login test blocks every merge, and developers have started retrying pipelines until green, hiding real failures. What's your immediate intervention and the longer-term policy for flake budgets, ownership, and merge-gate design?

You join a team with zero automated tests on a revenue-critical app that ships monthly. Where do you start — characterization tests, smoke suite on critical flows, CI wiring — and how do you show ROI within one quarter to keep investment flowing?