Mobile Developer
Updated for 2026: Mobile Developer interview questions and answers covering core skills, tools, and best practices for roles in the US, Europe & Canada.
What are common mobile app architecture patterns and when would you use each?
Mobile architecture patterns help organize code and separate concerns. **Common patterns:** - **MVC (Model-View-Controller):** Simple separation; View updates from Controller, Model holds data. - **MVVM (Model-View-ViewModel):** Better for reactive UIs (data binding); ViewModel handles presentation logic. - **MVP (Model-View-Presenter):** View is passive; Presenter handles all logic (good for testing). - **Clean Architecture / VIPER:** Strong separation of layers; better for complex apps. **Choose based on:** app complexity, team size, testing needs, and platform (native vs cross-platform). **Interview tip:** Mention state management, dependency injection, and how architecture scales with team growth.
Cross-platform vs native mobile development: what are the trade-offs?
**Native development** (Swift/Kotlin) offers the best performance and platform features but requires maintaining two codebases. **Cross-platform** (React Native, Flutter, Xamarin) shares code between iOS and Android, reducing development time but with performance and feature access trade-offs. **Key considerations:** - Performance requirements - Access to platform-specific APIs - Team expertise - Development speed vs optimization - Long-term maintenance **Interview tip:** Mention that many teams choose hybrid approaches (native for critical paths, cross-platform for shared UI).
How do you design an offline-first mobile app with reliable sync?
Offline-first apps treat the local database as the source of truth and sync changes in the background. Key pieces: - Store data locally (SQLite/Room/Core Data/Realm) - Track local mutations (outbox queue) - Use conflict resolution (last-write-wins, merge rules, or server authority) - Support retries with backoff and idempotent requests Good UX: clear offline indicators, graceful error states, and deterministic sync behavior.
What are best practices for mobile push notifications (design and implementation)?
Good push notifications are timely, relevant, and respectful. Best practices: - Ask permission after explaining value - Segment by user intent and behavior - Use deep links to the right screen - Support quiet hours and frequency caps - Track delivery/open metrics and iterate Implementation usually involves FCM/APNs, device tokens, and server-side targeting logic.
How do deep links work on mobile and how do you handle them safely?
Deep links open specific screens inside an app. Key points: - Validate parameters (avoid spoofed links) - Require auth for sensitive routes - Handle cold start vs running state - Implement fallback for missing content Use universal links/app links where possible to reduce hijacking and improve reliability.
How do you profile and improve mobile app performance?
Start by measuring real bottlenecks. Common areas: - Slow startup time - Janky scrolling (frame drops) - Excessive network calls - Memory leaks and high GC/ARC pressure Use platform profilers (Instruments/Android Studio Profiler), reduce work on the main thread, cache intelligently, and optimize rendering paths.
How do you reduce mobile app size without breaking features?
App size affects downloads, updates, and retention. Tactics: - Remove unused resources and dependencies - Enable code shrinking/minification - Use asset compression and vector assets - Split by ABI/density/language (Android) - Lazy-load optional features Always measure before/after and verify no runtime crashes due to missing resources.
How do you design analytics events for mobile apps?
Analytics should answer product questions, not just collect data. Best practices: - Define event names and schemas (properties) - Keep naming consistent across platforms - Avoid collecting sensitive data - Track funnels, retention, and key feature usage Add server-side or pipeline validation to prevent schema drift and keep dashboards trustworthy.
How do you set up crash reporting and triage crashes effectively?
Crash reporting should make issues actionable. Key steps: - Enable symbolication/mapping (dSYM/Proguard/R8) - Capture breadcrumbs and user context (non-PII) - Group crashes by signature and impact - Fix top crashes by affected users and frequency Combine crash reports with performance traces to catch slow paths and ANRs.
How should secrets and tokens be stored securely on mobile devices?
Avoid storing secrets in plain text. Use secure storage: - iOS: Keychain (+ Secure Enclave when relevant) - Android: Keystore + encrypted preferences Also: - Prefer short-lived tokens - Rotate refresh tokens - Protect against screenshots/logging leaks Security is layered: storage, transport (TLS), and server-side validation all matter.
What does a good mobile CI/CD pipeline include?
Mobile CI/CD improves release quality and speed. Include: - Linting and unit tests - Build signing and versioning - Automated UI smoke tests - Artifact storage and release notes - Beta distribution (TestFlight/Internal testing) Add crash/performance monitoring after release and automate rollback strategies where possible (e.g., feature flags).
How do you build accessible mobile apps (a11y) in practice?
Accessible apps work well for everyone. Key practices: - Support screen readers (VoiceOver/TalkBack) - Provide meaningful labels and hints - Ensure color contrast and scalable text - Support keyboard/switch controls where applicable Test with accessibility tools and real-device settings (large fonts, reduce motion).
How do background tasks work on mobile and what are common pitfalls?
Mobile OSes restrict background work to save battery. Design for: - Platform limits (Doze/background execution limits) - Scheduling APIs (WorkManager/BackgroundTasks) - Network and charging constraints Pitfalls include unreliable timers, excessive wakeups, and work being killed. Always build retry logic and user-visible sync guarantees where required.
What are best practices for mobile networking and API consumption?
Mobile networks are unreliable and expensive. Best practices: - Use timeouts and retries with backoff - Cache responses when safe - Batch requests and reduce payloads - Handle offline and slow networks gracefully Also secure traffic with TLS and certificate pinning only when you fully understand operational trade-offs.
How do you choose a local database on mobile (SQLite, Room, Core Data, Realm)?
Choose based on platform, complexity, and tooling. Consider: - Query needs and indexing - Migrations and schema evolution - Threading/concurrency model - Offline sync requirements SQLite is universal; Room/Core Data add platform tooling; Realm can simplify object storage but adds vendor/runtime constraints.
What is a good testing strategy for mobile apps?
Use a layered approach: - Unit tests for business logic - Integration tests for networking/storage - UI tests for critical flows Keep UI tests small to avoid flakiness. Use mocks/fixtures, run tests in CI, and add crash/performance monitoring to catch issues not covered by tests.
Why does app lifecycle matter (foreground/background/termination) and how do you design for it?
Mobile apps are frequently paused, killed, and resumed. Design for: - Persisting critical state - Resuming network requests safely - Handling interrupted flows (payments, uploads) - Avoiding memory leaks across screens Good lifecycle handling prevents crashes, data loss, and confusing UX when users switch apps or receive calls.
How do in-app purchases and subscriptions work, and what should developers watch out for?
IAP/subscriptions require correct entitlement logic. Key points: - Validate receipts server-side - Handle renewals, grace periods, refunds - Keep entitlements in a server-tracked state machine - Support restore purchases Most bugs come from edge cases (cancellation, upgrades/downgrades, store delays). Good logging and reconciliation are essential.
What are common reasons apps get rejected in app store reviews?
Common rejection reasons include: - Privacy policy and data collection issues - Crashes or broken flows - Misleading metadata/screenshots - Permission requests without clear value - Payments/entitlements implemented incorrectly Prevent rejections by testing thoroughly, documenting permissions, and following platform guidelines for privacy and monetization.
How do you plan safe mobile releases (staged rollout, monitoring, rollback)?
Safe releases reduce risk and protect user experience. Best practices: - Use staged rollouts (percentage-based) - Monitor crashes, ANRs, and performance right after release - Keep feature flags for risky changes - Maintain a fast hotfix path A good release process combines testing, observability, and clear go/no-go criteria.