Advanced everything in Mobile Dev, page 2
Responsive layout across form factors
Drive layout from dimensions and breakpoints via useWindowDimensions, react to orientation changes, avoid hardcoded OS checks.
Designing a native map UI component
Wrap each platform's native view, expose props mapped to native setters and events as bubbling callbacks, unify behind one JS API.
Apollo's normalized cache
Apollo flattens query results into entities keyed by type plus id, so one object is stored once and shared, updating everywhere at once.
Offline data persistence and mutation queue
Persist reads to local storage, store mutations in a durable queue with client ids and status, drain and reconcile on reconnect via NetInfo.
Optimistic UI updates for actions
Update UI immediately on the assumption of success, send the request, then confirm or roll back on failure.
Offline-capable state architecture
Persist state locally, queue mutations while offline, apply optimistic updates, then sync and reconcile conflicts on reconnect.
State normalization for relational data
Store entities by id in lookup tables, reference relationships by id, avoid nesting and duplication.
Memoized selectors with Reselect
Selectors encapsulate state reads, Reselect memoizes computed results by input identity, preventing recomputation and unnecessary re-renders.
FlatList virtualization and windowing trade-offs
FlatList renders only items within a window of viewports around the visible area, unmounting others; larger windowSize means fewer blanks but more memory, smaller means less memory but more blank flashes.
Preventing unnecessary FlatList item re-renders
Extract the row into a React.memo component, pass stable memoized callbacks and primitive props, and keep renderItem referentially stable so only changed items re-render.
Type-safe navigation with TypeScript
Define a ParamList mapping screen names to param types, type Screen via NativeStackScreenProps, and type useNavigation with the navigation prop generic so route names and params autocomplete.
How react-native-screens optimizes a deep stack
React-native-screens uses native container views so off-screen screens are detached from the view hierarchy and can be freed; enabled by default and powers the native-stack navigator.
Configuring deep linking to a parameterized screen
Register native URL schemes/intent filters, define a linking config with prefixes and screen-to-path mapping including params, pass it to NavigationContainer.
Gesture Handler and Reanimated on the UI thread
Gesture Handler tracks gestures natively and Reanimated runs worklets on the UI thread, so animations driven by shared values continue smoothly even when the JS thread is blocked.
How StyleSheet.create reduces styling overhead
StyleSheet styles are created once with stable references, so identical renders skip reallocation and reduce diffing and serialization work; inline literals allocate new objects each render…
Why Text inherits styles but View does not
Nested Text inherits text styles because it maps to platform attributed-text rendering, while Views are independent layout boxes with no style cascade.
Building a native module from scratch
Write a native module class with exported methods or constants, register it via a package, then expose a typed JS wrapper.
Improving React Native startup time
Enable Hermes for fast bytecode startup, shrink and lazy-load the JS bundle via inline requires and RAM bundles, and defer non-critical native init.
Debugging a closure capture leak in a third-party library
Use the Memory Graph Debugger to inspect retain paths, the Leaks and Allocations instruments, and malloc stack logging; trace the cycle before patching.
Verifying and avoiding copy-on-write overhead
Confirm extra copies via isKnownUniquelyReferenced or instruments and the retain trace; ensure unique references, mutate inout/in place, reserveCapacity, avoid aliasing.
We are hiring for this. Every open role lists the topics its interview covers, so you can prepare for the real thing rather than guessing.
See open roles