📱Mobile Developer

Native builds separate apps per platform with Swift and SwiftUI or Kotlin and Compose, giving full API access and best performance at the cost of two codebases. Cross-platform shares one codebase with React Native or Flutter for faster delivery and consistent UI, with trade-offs in platform fidelity, native-module bridging and binary size. Choose native for hardware-heavy apps and cross-platform for speed and shared logic.

Centralize routes in a typed navigation graph with deep link URIs, auth guards and analytics events per destination. Keep navigation state serializable so it survives process death, and separate bottom-tab stacks so each tab preserves its own back history. Test cold start links, logged out redirects and back-button behavior on both platforms.

Layer fast unit tests for business logic, widget or component tests for UI states, integration tests for navigation and data flows, and a small set of end-to-end tests on real devices for critical paths. Add screenshot and snapshot tests for regressions, plus manual exploratory testing for gestures and accessibility. Run the pyramid in CI with device farms for fragmentation coverage.

Use platform APIs like Face ID with LocalAuthentication and Android BiometricPrompt, storing keys in Keychain or Keystore with biometric-bound access control. Fall back to device passcode, handle enrollment changes by invalidating sessions, and never store raw biometrics. Explain privacy messaging that increases opt-in and support coverage.

Enforce HTTPS with TLS 1.2 or higher, add certificate or public-key pinning for sensitive domains with a rotation and bypass plan, and validate hostnames and certificate chains. Store tokens in Keychain or Keystore, avoid logging secrets, and add jailbreak and tamper detection proportional to risk. Test pinning expiry and fallback before release.

Provide labels, hints and traits for screen readers like VoiceOver and TalkBack, ensure 48dp touch targets, contrast ratios and dynamic type scaling without clipped layouts. Support keyboard, switch control and reduced-motion paths, and test full flows with assistive tech enabled. Treat accessibility bugs as release blockers for core journeys.

Tokenize colors, typography and spacing in a design system with semantic names, then bind to system appearance with runtime switching and persisted preference. Test contrast, images and custom drawings in both modes, and snapshot key screens to catch regressions. Support high-contrast and reduced-transparency variants for accessibility.

Externalize all strings with format placeholders, support RTL layouts, plural rules and locale-aware dates and currencies with translators in the loop. Test with pseudolocales, long German strings and right-to-left mirroring on real devices. Automate screenshot review per locale and stage string freezes before release.

Optimize title, subtitle, keywords, screenshots, preview video and ratings with A and B testing of creatives per locale and season. Drive quality ratings with well-timed prompts after success moments, respond to reviews, and track conversion from impression to install. Align paid, featuring and editorial pitches with release themes.

Automate signing, versioning, tests, screenshots and store uploads with Fastlane lanes per app and environment, running on ephemeral CI with cached dependencies. Add quality gates for lint, coverage and size, plus automatic beta distribution and release notes. Monitor lane duration and flakiness with retry and sharding.

React Native runs JavaScript on a separate thread and communicates with native UI modules over an asynchronous bridge in the legacy architecture, or the newer JSI and Fabric layer for direct bindings. JS describes the UI tree while native code renders real components. The bridge serialization cost motivated the new architecture; heavy work should move off the JS thread with native modules or worklets.

setState manages local component state with re-renders scoped to the component tree, ideal for form fields and toggles. Redux (or Zustand or Context) lifts shared state into a global store with predictable updates, better for auth, carts or cross-screen data. Prefer local state by default and promote to global only when multiple distant screens need the same data.

Hermes is a lightweight JavaScript engine optimized for mobile startup with ahead-of-time bytecode, smaller memory footprint and faster time to interactive compared with JavaScriptCore. It improves cold start and on-device performance especially on lower-end Android devices. Mention enabling Hermes in builds, profiling with Hermes traces, and pairing it with the new architecture for best results.

Fabric is the new rendering system with C++ core and synchronous layout for faster, more consistent UI updates, while TurboModules enable lazy, type-safe native modules over JSI instead of the legacy bridge. Together they cut serialization overhead and startup cost and improve interop with native views. Mention migration steps, codegen specs and fallback for unmigrated libraries.

Use over-the-air services like Expo Updates or CodePush for JavaScript and asset bundles, keeping native version compatibility checks and staged rollouts with rollback. Reserve store releases for native changes, permissions or SDK upgrades. Track bundle versions, crash deltas and adoption separately from store versions.

Combine Hermes debugger and Flipper with React DevTools, network and layout inspectors, plus symbolicated crash reports and breadcrumb logging. Reproduce on both platforms, isolate JS versus native causes with minimal repros, and use Fast Refresh with caution around stateful modules. Add E2E smoke tests to lock fixed regressions.

Use React Navigation with typed stack, tab and drawer navigators, linking config for deep links, and navigation-aware data fetching to avoid stale screens. Keep params serializable, guard auth routes centrally, and test back behavior on Android separately. For heavy apps, consider native-stack variants for better animation performance.

Reanimated runs animations on the UI thread with worklets and shared values, avoiding bridge round trips that cause dropped frames, while Gesture Handler provides native-driven gesture states. Together they enable 120fps interactions like bottom sheets and carousels. Mention version compatibility with Fabric and testing on low-end Android.

Embed React Native screens as single destinations first with shared auth, theming and analytics bridges, versioning the JS bundle with the native shell. Handle navigation handoffs, memory overhead and bridge init cost before expanding scope. Align release trains so native and JS compatibility is tested together.

Flutter compiles Dart ahead-of-time to native ARM and draws every pixel with its own Skia or Impeller engine, giving consistent UI and strong performance. React Native runs JavaScript driving real native components, giving a more platform-authentic feel with easier web-team reuse. Choose Flutter for pixel-consistent custom UI and React Native for native-look apps with shared JS expertise.

Impeller replaced Skia as the default renderer to fix shader compilation jank by precompiling shaders, giving smoother first frames and more predictable performance. It modernizes the graphics backend with platform APIs like Metal and Vulkan while keeping the same Dart widget code. Mention testing on low-end devices and checking custom shaders for compatibility.

Provider or Riverpod suits medium apps with simple dependency injection and reactive caching, while Bloc fits large teams needing strict event-to-state separation and testable transitions. Keep ephemeral UI state local with StatefulWidget and promote only shared or persisted state upward. Evaluate boilerplate, devtools, test story and team familiarity before standardizing.

Platform channels pass asynchronous messages with codecs between Dart and Kotlin or Swift handlers for APIs Flutter does not expose, like sensors or payments. Keep calls coarse-grained, handle threading and errors explicitly, and prefer established plugins before writing custom channels. Test on both platforms with mocked method channels.

Write unit tests for logic, widget tests for interaction and golden tests for visual regressions, plus integration tests on real devices for navigation and plugins. Mock platform channels and network layers, run coverage gates in CI, and shard device-farm runs by OS version. Keep golden baselines versioned and review diffs deliberately.

Navigator 2.0 exposes a declarative page stack driven by app state, enabling URL-driven web paths, nested navigation and better back-button handling compared with imperative push and pop. Pair it with a router package for guards, deep links and state restoration. Mention migration cost and testing deep-link parity.

Isolates run Dart code in separate memory heaps without shared state, letting you move JSON parsing, image processing or crypto off the UI isolate via message passing. Use compute helpers or background isolates with ports, keeping payloads serializable and small. Profile before parallelizing since spawn and copy costs can outweigh gains.

Define dev, staging and prod flavors with separate bundle IDs, signing configs, API endpoints and icons, injected via compile-time defines and config files. Isolate secrets from repos with vaults and CI injection, and automate flavored builds and tests per environment. Document promotion paths from dev to store builds.

Design offline-first: treat a local database such as SQLite, Realm or WatermelonDB as source of truth, queue mutations with operation logs, sync with last-write-wins plus per-field merge or CRDTs for conflicts, and show sync status with retry. Handle auth token refresh, large payload chunking and background sync limits per OS.

iOS uses APNs with device tokens, strict permission prompts and background modes, while Android uses FCM with channels, priorities and data versus notification payloads. Both need token registration and refresh handling, deep-link routing from taps, and server-side provider auth with an APNs key or FCM credentials. Note battery and OEM-specific delivery quirks on Android.

Support universal links on iOS and app links on Android with hosted association files, plus custom schemes as fallback. Route incoming URLs through a central link handler that resolves auth state, parses params and navigates to the right screen with analytics. Test cold start, warm start and logged-out flows, and handle deferred links for fresh installs.

Use local state for single-screen UI, lifted or store-based state for cross-screen domains like auth and cart, and server cache tooling for remote data with loading and error states. Enforce unidirectional data flow so events flow up and state flows down, which makes debugging and testing predictable. Add selectors or derived state to avoid unnecessary re-renders across the tree.

Use visible pushes with media attachments and action buttons for engagement, and silent pushes to wake the app for content refresh or sync without alerting the user. Handle permission priming, token rotation, notification service extensions on iOS and channels with importance on Android. Always provide in-app fallback and respect battery and frequency limits to avoid opt-outs.

Assign each record a version vector or timestamp, queue local mutations as intents, and merge with server state using per-field last-write-wins or operation transforms for collaborative fields. Surface conflicts in UI with keep mine, keep theirs and merge options when automatic rules are unsafe. Test airplane mode, flaky networks and multi-device edits with deterministic fixtures.

Split by feature modules with clear public APIs, shared core modules for design system and networking, and dependency rules that prevent circular imports. Modularization speeds builds with caching, enables team ownership and safer rollouts. Enforce boundaries with lint rules, versioned interfaces and contract tests between modules.

MVVM: separates Views from ViewModels that expose observable state, keeping UI logic testable and lifecycle aware with minimal layers. Clean Architecture: organizes code into presentation, domain and data layers with dependency inversion, isolating frameworks for long-term scale at the cost of boilerplate. Use MVVM inside Clean features: ViewModels in presentation call use cases in domain backed by repositories in data.

Gate features with remotely configurable flags supporting staged rollout, kill switches and per-platform targeting, with local defaults for offline launch. Log exposures for experiment analysis and clean up stale flags on a cadence. Combine flags with phased store rollouts to limit blast radius of regressions.

Track crash-free sessions, ANR and hang rates, startup time, network error rates and app-store ratings segmented by version, device and region. Pipe crashes with breadcrumbs and releases into Crashlytics or Sentry, alert on regressions, and link issues to feature flags for fast mitigation. Review quality dashboards in release check-ins.

REST: uses fixed endpoints with predictable caching and simple tooling, but can over-fetch data and needs versioning for mobile evolution. GraphQL: lets clients request exactly the fields they need in one round trip with strong typing, at the cost of caching complexity and query governance. Choose GraphQL for varied screens on slow networks and REST for simple CRUD with edge caching.

Use independent versioning per app with shared library releases, automated changelogs, and train-based cut dates with cherry-pick criteria. Gate breaking changes with feature flags and contract tests, and align native, JS and backend compatibility matrices. Automate tagging, notes and phased rollouts from CI.

Use managed sockets with authentication, heartbeats, backoff reconnect and message deduplication, falling back to polling or push when sockets die in background. Persist subscription state across restarts, batch UI updates, and monitor connection success and message latency by region. Design for battery and data constraints on cellular.

Verify crash-free rate, startup and ANR budgets, migration paths, feature-flag defaults, analytics events, accessibility pass, store metadata and rollback plan across supported devices and OS versions. Run release-candidate soak on beta tracks with staged rollout criteria. Hold a go or no-go review with support, QA and backend owners.

Key iOS states are Not Running, Inactive during foreground transitions, Active, Background for suspended or task-running apps, and Suspended or Terminated. Handle scene phase changes to save state, pause media, stop timers and request background time for uploads. The system can kill backgrounded apps anytime, so persist critical state early.

SwiftUI: you describe what the UI should show for a given state and the framework diffs and updates the view tree automatically, which reduces boilerplate and sync bugs. UIKit: you create views and mutate them step by step in response to events, giving fine control over lifecycle and animations at the cost of more code. Prefer SwiftUI for new screens and use UIHostingController bridges when you need UIKit components.

Follow Human Interface Guidelines, provide a demo account and review notes, declare permissions with purpose strings, and avoid private APIs and misleading metadata. Preflight with TestFlight, crash-free builds, complete privacy nutrition labels and age ratings. Plan for rejection turnaround with expedited review criteria and a rollback build ready.

Use Swift async await for readable asynchronous work, actors to isolate mutable shared state, and Task groups for parallel fetches with cancellation support. Keep UI updates on the main actor and move parsing or image work off the main thread. Handle task cancellation, priority and error propagation explicitly in view models.

Use SwiftData for new SwiftUI apps needing concise model-driven persistence with automatic sync helpers, and Core Data for mature apps needing fine-grained migrations, fetched results controllers and proven performance tuning. Both need background contexts, batching and merge policies for smooth UI. Profile fetch faults and index hot queries for large datasets.

Build glanceable WidgetKit extensions with timelines and intents, and Live Activities for real-time events like delivery or scores with compact and expanded presentations. Keep payloads small, update via push or activity kit on a cadence, and design for lock screen and standby. Test across sizes, dark mode and low-data states.

Distribute internal and external TestFlight builds with focused test notes, crash reporting and feedback links, iterating on expiration windows and build numbers. Segment testers by device and OS, track adoption and crash-free sessions per build, and promote only validated builds to App Store review. Automate uploads with CI and changelog generation.

Use BGAppRefresh for periodic refresh, BGProcessing for deferrable work like database cleanup, URLSession background transfers for uploads and downloads, and push-triggered updates within strict time budgets. The system schedules based on usage, battery and privacy, so design idempotent tasks with progress persistence. Test with simulated launches and Instruments energy logs.

Use AuthenticationServices to request identity tokens with nonce validation, verify tokens server-side, and handle private relay emails plus account linking for existing users. Support revocation webhooks and key rotation, and offer it wherever third-party login exists per App Store rules. Test first-login, returning-user and revoked-credential flows.

Use AVFoundation for full control over capture sessions, device inputs, photo and video outputs plus Live Photos and depth, or PHPicker for simple selection with privacy defaults. Handle permissions in context, background audio interruptions and orientation metadata. Test on devices across lenses, low light and thermal throttling.

Combine background push with Core Data or SwiftData updates, widget timeline reloads and Live Activity state patches within payload limits. Handle muted, expired and revoked tokens with server reconciliation and in-app refresh on open. Test throttling, low-power mode and notification settings permutations.

Actors isolate mutable state so only one task accesses it at a time, with compiler-checked suspension points that eliminate manual locks for most app code. Use Sendable types across boundaries, main-actor isolation for UI state, and nonisolated helpers for pure work. Diagnose remaining races with strict concurrency warnings in CI.

An activity moves through onCreate, onStart, onResume (visible and interactive), then onPause, onStop and onDestroy, with onRestart when returning from stopped. Save lightweight UI state in onSaveInstanceState and persistent data earlier via ViewModel and Room, since the system may destroy activities under memory pressure. Fragments and Compose lifecycles are the modern counterparts.

Jetpack Compose replaces XML layouts and findViewById plumbing with Kotlin composable functions that recompose when state changes, which simplifies dynamic UI and theming. It pairs with unidirectional data flow from ViewModel state holders, improving testability and reducing fragment lifecycle bugs. Mention interoperability with existing Views, performance of recomposition scopes, and tooling like live previews.

Roll out through internal, closed and open testing tracks before staged production rollout with halt and rollback criteria on crashes and ANRs. Use version codes, release notes and managed publishing to control timing across regions. Monitor Android vitals, staged percentages and review feedback before full rollout.

Use WorkManager for deferrable guaranteed work with constraints like network and charging, AlarmManager or exact alarms sparingly for time-critical tasks, and foreground services with notifications for user-visible long work. Respect Doze and app standby buckets, OEM restrictions and Android version limits. Always provide retry policies and observability for failed workers.

Define entities, DAOs and a Room database with migrations, expose Flows for reactive UI, and run writes off the main thread with transactions for consistency. Add indices for query patterns, handle schema migrations with tests, and encrypt sensitive fields with SQLCipher or EncryptedSharedPreferences for keys. Pair Room with DataStore for preferences.

Use Glance with Compose-style syntax over RemoteViews to ship responsive home-screen widgets with action callbacks and periodic workers for refresh. Respect size constraints, battery limits and Android version differences in widget behavior. Provide placeholder, loading and error states plus deep links into the app.

Modern Android uses runtime permissions with one-time and while-in-use grants, scoped storage, photo pickers and approximate location to minimize data access. Request in context with rationale screens, gracefully degrade when denied, and re-prompt only after value is shown. Audit manifests and SDKs for over-requested permissions before release.

Host a Digital Asset Links file over HTTPS, declare autoVerify intent filters with matching hosts and paths, and handle the intent in a central router with fallback to browser on failure. Test with the statement checker across fresh installs, updates and multi-domain setups. Monitor verification failures from OEM or network issues.

ViewModel survives configuration changes and exposes StateFlow or SharedFlow for UI state and one-shot events, collected lifecycle-aware in Compose or Views. Keep business logic in repositories or use cases, cache latest state for rotation, and test flows with Turbine-style assertions. Handle errors and loading as explicit states rather than exceptions in UI.

Use CameraX use cases for preview, image capture and analysis with lifecycle binding that handles rotation and device quirks automatically. Add ML Kit or custom analyzers for QR and vision, manage permissions and fallbacks for missing lenses, and test across OEMs with the test lab. Handle backgrounding and thermal limits gracefully.

Build adaptive layouts with window size classes, sliding panes and activity embedding, handling posture changes, multi-window and drag and drop. Test on emulators and real foldables for continuity across fold, unfold and rotation. Persist pane state and avoid hardcoded widths in favor of constraints.

Layer Play Integrity verdicts, SafetyNet style attestation, root detection, obfuscation with R8 and secret management that keeps keys server-side. Enforce server-side fraud checks rather than trusting client flags, and degrade gracefully with step-up auth on risky signals. Test on rooted devices and custom ROMs before relying on signals.

Measure with profilers like Instruments, Android Profiler and Hermes profiles, targeting startup time, frame drops, memory and battery. Optimize with lazy loading, image downsampling and caching, list virtualization, memoization, reduced bridge traffic and overdraw, plus batched background work. Set budgets for app size and cold start and track them in CI.

Profile cold, warm and hot starts to find the critical path, then defer nonessential SDK init, lazy-load screens, trim main-thread I/O and shrink the initial bundle. Use splash placeholders, preloaded data and background initialization for auth and config. Set a startup budget in CI and track P50 and P90 by device tier.

Batch network calls, use efficient polling intervals with exponential backoff, prefer push over polling, and defer heavy work to charging or WiFi with WorkManager and BackgroundTasks. Reduce location accuracy when possible, coalesce sensor updates and avoid wake locks. Measure with Battery Historian and Xcode energy gauges on real devices.

Watch for retained view controllers, leaked activities, unclosed cursors and image caches growing without bounds using Instruments Allocations and Android Studio Memory Profiler with heap dumps. Fix with weak references for delegates and listeners, lifecycle-aware scopes, downsampled images and bounded caches. Add leak detection in debug builds and track out-of-memory crash rates in production.

Virtualize with FlatList, LazyColumn or UICollectionView reuse so only visible rows bind, stabilize keys, memoize row components and avoid inline closures. Downsample images, prefetch next pages and move parsing off the main thread. Measure scroll FPS and frame time on low-end devices before adding animations.

Request right-sized images from a CDN, downsample to view size, cache in memory and disk tiers with eviction budgets, and use placeholders with progressive loading. Prefer modern formats like WebP or HEIF and prefetch next-screen assets during idle. Monitor image memory, data usage and scroll jank together.

Trace ANRs from main-thread blocking I/O, lock contention and broadcast receivers with strict mode, traces and vitals, then move work to background threads with proper cancellation. Fix jank by reducing overdraw, flattening layouts or recomposition scopes, and caching expensive work. Set budgets for frozen frames and ANR rate with alerts per release.

Enable R8 or ProGuard shrinking with resource shrinking on Android and bitcode-style thinning plus asset slicing on iOS, convert images to vector or modern formats, and split features into dynamic delivery or on-demand resources. Audit dependencies, native libraries per ABI and duplicate assets. Track download and install size per release in CI.

Layer timeouts, retries with jitter, idempotency keys, offline queues and cached fallbacks with stale-while-revalidate headers. Surface loading, empty and error states with retry actions, and log network quality by region and carrier. Test with proxies, throttling and airplane-mode chaos scenarios.

Start from user complaints or vitals, reproduce with release builds on representative devices, then capture traces with Instruments Time Profiler and Leaks or Android Profiler CPU, memory and energy panes. Correlate frames, threads and network waterfalls to root causes before optimizing. Re-measure after fixes and add regression tests or budgets.