Amazon Senior Mobile Developer Interview Preparation Guide

Mobile Developer

Amazon

Senior

7 rounds

Updated 6/12/2026

Amazon's interview process for Senior Mobile Developers typically includes an initial recruiter screening, a technical phone screen, and a 4-5 round onsite interview loop. The onsite typically assesses mobile development technical expertise, system design and architectural thinking, performance optimization knowledge, behavioral alignment with Amazon Leadership Principles, and depth of technical knowledge through a bar raiser round. The entire process is designed to evaluate both technical capabilities and cultural fit.

Interview Rounds

Recruiter Screening

30 min4 focus topicsculture fit

Technical Phone Screen

60 min5 focus topicstechnical

What to Expect

A 45-60 minute technical screening typically with a hiring manager or senior engineer. This round assesses your mobile development fundamentals and coding ability under pressure. You'll be expected to write code (often in a shared document or whiteboard tool) and discuss your approach. Questions may focus on data structures, algorithms, or mobile-specific scenarios. This is your first technical evaluation and sets the bar for the onsite rounds.

Tips & Advice

Think out loud and explain your approach before coding. Ask clarifying questions about requirements and constraints. For mobile-specific problems, discuss platform trade-offs (iOS vs Android). Be prepared to optimize your solution if asked. At the senior level, interviewers expect you to identify edge cases and propose scalable solutions. Practice on a collaborative document editor to simulate the real experience. Ensure your environment is quiet and your internet connection is reliable.

Focus Topics

Optimization and Scalability Thinking

Ability to analyze time and space complexity, identify bottlenecks, and propose optimized solutions.

Practice Interview

Study Questions

Platform-Specific Knowledge (iOS or Android)

Deep familiarity with either iOS (Swift, UIKit/SwiftUI, memory management) or Android (Kotlin, Jetpack, lifecycle), or both.

Practice Interview

Study Questions

Code Quality and Communication

Writing clean, readable code with proper variable naming, comments, and clear logic flow. Explaining your reasoning while coding.

Practice Interview

Study Questions

Data Structures and Algorithms Fundamentals

Solid understanding of arrays, linked lists, trees, graphs, hashing, and common algorithms (sorting, searching, dynamic programming).

Practice Interview

Study Questions

Mobile-Specific Problem Solving

Ability to solve problems in the context of mobile constraints (memory, battery, network latency, storage) and platform-specific APIs.

Practice Interview

Study Questions

Mobile Development Technical Interview (Onsite - Round 1)

60 min6 focus topicstechnical

What to Expect

This is the first onsite round focused on hands-on mobile development skills. You may be asked to design and implement a mobile feature, debug existing code, or solve a more complex mobile-specific problem. This round evaluates your practical mobile development expertise, understanding of platform conventions, and ability to think about user experience alongside technical implementation. Expect 45-60 minutes of deep technical discussion.

Tips & Advice

Come prepared with recent projects you've built and be ready to dive deep into technical decisions. If asked to implement a feature, start with a basic solution and iterate based on feedback. Discuss trade-offs between different approaches (native vs cross-platform, state management libraries, navigation patterns). At senior level, interviewers expect you to consider performance, testability, and maintainability. If you encounter an unfamiliar API or framework, think through how you would approach learning it rather than pretending to know. Ask clarifying questions about requirements, constraints, and success metrics.

Focus Topics

Cross-Platform Considerations

If applicable, understanding differences between iOS and Android development, or experience with cross-platform frameworks (React Native, Flutter, Kotlin Multiplatform).

Practice Interview

Study Questions

State Management and Architecture Patterns

Understanding MVC, MVVM, Redux, Bloc, or other architectural patterns. Managing app state across screens and lifecycle events.

Practice Interview

Study Questions

Testing and Debugging Mobile Applications

Unit testing, integration testing, UI testing frameworks. Debugging device-specific issues, using debugging tools, and understanding performance profiling.

Practice Interview

Study Questions

Mobile Network and Data Management

Efficient API integration, handling network failures gracefully, caching strategies, background data sync, and understanding different network conditions.

Practice Interview

Study Questions

Mobile UI/UX Implementation

Building responsive user interfaces that work across different device sizes and orientations. Understanding mobile-specific UI patterns and frameworks (SwiftUI, Jetpack Compose, or cross-platform solutions).

Practice Interview

Study Questions

Platform-Specific Features and APIs

Deep understanding of camera integration, location services, push notifications, file handling, permissions, sensors, and other device-specific capabilities.

Practice Interview

Study Questions

System Design and Mobile Architecture (Onsite - Round 2)

60 min5 focus topicssystem design

What to Expect

This round assesses your ability to design large-scale mobile systems and make architectural decisions. You may be asked to design a complex mobile feature or system (e.g., a photo sharing app, real-time messaging, offline-first app, or scalable social feed). The focus is on how you structure code, choose appropriate libraries, think about scalability, handle edge cases, and justify design trade-offs. This is critical for senior-level candidates who are expected to influence architecture decisions.

Tips & Advice

Start by clarifying requirements and constraints before diving into design. Discuss trade-offs between different approaches (e.g., monolithic app vs modularized architecture, local databases vs cloud sync, native vs cross-platform). At senior level, interviewers expect you to think holistically: user experience, code maintainability, team scalability, and testability. Draw diagrams if helpful. Discuss how your design handles edge cases like network failures, app backgrounding, and concurrent operations. Be prepared to explain why you chose certain libraries or patterns over alternatives. Show awareness of common pitfalls in mobile architecture (tight coupling, poor state management, inefficient data fetching).

Focus Topics

Modular and Component-Based Design

Breaking down large apps into feature modules, creating reusable components, and managing dependencies between modules.

Practice Interview

Study Questions

Error Handling and Resilience

Designing systems to gracefully handle network errors, crashes, permissions denial, and other failure modes. User experience in error scenarios.

Practice Interview

Study Questions

Performance Optimization and Scalability

Designing for app startup speed, memory efficiency, battery consumption, smooth animations, and handling growing user base and data volume.

Practice Interview

Study Questions

Mobile App Architecture Patterns

Designing scalable, maintainable mobile app architectures. Understanding layering (presentation, business logic, data), dependency injection, and clean code principles.

Practice Interview

Study Questions

Data Persistence and Synchronization

Designing systems for offline-first apps, local databases (SQLite, Realm, etc.), cloud synchronization, conflict resolution, and data consistency.

Practice Interview

Study Questions

Mobile Performance, Optimization, and Security (Onsite - Round 3)

60 min6 focus topicstechnical

What to Expect

This round dives deep into mobile-specific performance challenges, optimization techniques, and security best practices. You may be asked to debug a slow app, optimize battery drain, improve startup time, handle memory leaks, implement secure data storage, or design for different device capabilities. This round evaluates your depth of knowledge in mobile-specific concerns and your ability to solve real production problems.

Tips & Advice

Be familiar with platform-specific profiling tools (Xcode Instruments, Android Profiler, etc.) and common performance bottlenecks in mobile apps. Discuss concrete examples from your experience: 'I reduced app startup time from X to Y by doing Z.' Understand mobile security best practices like secure storage, certificate pinning, encryption, and permission handling. Be prepared to discuss trade-offs between security and usability. At senior level, you should be able to mentor others on these practices. Ask clarifying questions about performance requirements (e.g., 'What is acceptable latency for this feature?'). Show systematic thinking about identifying and solving performance issues.

Focus Topics

App Store Deployment and Distribution

App signing, versioning, release management, handling app store review processes, crash reporting, and continuous deployment practices.

Practice Interview

Study Questions

Device Compatibility and Fragmentation

Handling different OS versions, screen sizes, hardware capabilities, and vendor-specific behaviors. Backward compatibility and feature detection.

Practice Interview

Study Questions

Mobile Security Best Practices

Secure data storage (keychain, encrypted preferences), API security, certificate pinning, secure communication, permissions management, and handling sensitive user data.

Practice Interview

Study Questions

Mobile Performance Analysis and Profiling

Using profiling tools to identify bottlenecks. Understanding CPU usage, memory consumption, battery drain, and rendering performance metrics.

Practice Interview

Study Questions

Battery and Power Optimization

Techniques to reduce battery drain: efficient networking (batching requests, smart caching), location services optimization, background task management, and CPU/GPU efficiency.

Practice Interview

Study Questions

Memory Management and Leak Prevention

Understanding memory model on iOS (ARC) and Android (GC). Identifying and preventing memory leaks, managing large data structures, and handling bitmap memory.

Practice Interview

Study Questions

Amazon Leadership Principles (Onsite - Round 4)

60 min6 focus topicsbehavioral

What to Expect

This behavioral round assesses alignment with Amazon Leadership Principles through structured interview questions. You'll discuss past experiences and how they demonstrate principles like Customer Obsession, Ownership, Invent and Simplify, and others. Expect questions in STAR format (Situation, Task, Action, Result). This round evaluates cultural fit and your ability to think about problems from Amazon's perspective. A behavioral interviewer will look for evidence of impact and the lessons you learned.

Tips & Advice

Prepare 5-7 strong stories from your career that demonstrate different leadership principles. Use the STAR method: clearly describe the Situation and Task, explain the specific Actions you took (with emphasis on your role), and articulate the Result with quantifiable impact. For a senior-level developer, focus on stories that show: mentoring others, making architectural decisions that benefited the team, customer impact, handling failure and learning, and driving innovation. Research Amazon's 16 Leadership Principles and map your stories to them. Practice out loud; you should be comfortable telling these stories concisely (2-3 minutes each). Be authentic and specific rather than generic. Connect your examples back to why they matter for the mobile development role at Amazon.

Focus Topics

Amazon Leadership Principle: Learn and Be Curious

Seeking knowledge, adapting to new technologies, learning from failure, and having a growth mindset even at senior level.

Practice Interview

Study Questions

Amazon Leadership Principle: Earn Trust

Being trustworthy, following through on commitments, asking tough questions, and building credibility through consistent delivery.

Practice Interview

Study Questions

Amazon Leadership Principle: Invent and Simplify

Proposing new ideas, simplifying processes, and doing more with less. Not resting on existing solutions; finding simpler approaches to complex problems.

Practice Interview

Study Questions

Amazon Leadership Principle: Dive Deep

Understanding details deeply, investigating root causes, asking detailed questions, and not accepting surface-level explanations.

Practice Interview

Study Questions

Amazon Leadership Principle: Ownership

Taking accountability for outcomes, thinking long-term, not making excuses, and being willing to work on unglamorous tasks to solve problems.

Practice Interview

Study Questions

Amazon Leadership Principle: Customer Obsession

Demonstrating deep understanding of customer needs, putting customer experience first, and making decisions based on customer impact rather than internal convenience.

Practice Interview

Study Questions

Bar Raiser Technical Deep Dive (Onsite - Round 5)

60 min5 focus topicstechnical

What to Expect

This round is conducted by a 'Bar Raiser'—an experienced senior engineer or architect who ensures the hiring bar remains high. This is typically the most challenging round. You'll be asked a complex technical problem, asked to explain a project in extreme detail, or solve an ambiguous problem from scratch. The bar raiser evaluates whether you're truly senior-level: can you think strategically, handle ambiguity, make sound architectural decisions, and raise the bar for the team? Expect deep probing into your technical expertise and decision-making.

Tips & Advice

This is the hardest round. The bar raiser will dig into nuances and edge cases. Prepare by deeply understanding one or two major projects you've led: be ready to explain architectural decisions, trade-offs considered, what you'd do differently, and the impact. If given a design problem, don't rush to a solution; think out loud, ask clarifying questions, consider multiple approaches, and be honest about trade-offs and limitations. Show that you can operate at a strategic level while remaining technically grounded. When stuck, explain your thinking and ask for hints rather than guessing. At senior level, the bar raiser is looking for someone who will make the team better. Demonstrate learning from mistakes, mentoring mindset, and ability to influence decisions through reasoning.

Focus Topics

Mentoring and Raising the Bar

Evidence that you've elevated others, driven improvements in code quality or processes, and influenced team decisions for the better.

Practice Interview

Study Questions

System Design at Scale

Designing systems that work as user base and data volume grow. Understanding load, latency, and availability trade-offs at a deep level.

Practice Interview

Study Questions

Architectural Decision-Making and Trade-off Analysis

Ability to evaluate multiple approaches, understand trade-offs (performance vs maintainability, security vs convenience, etc.), and justify design choices with reasoning.

Practice Interview

Study Questions

Deep Technical Expertise in Mobile Development

Mastery of your platform(s): iOS or Android (or both). Ability to explain complex technical concepts, understand nuances, and solve novel problems using fundamental principles.

Practice Interview

Study Questions

Ambiguity and Novel Problem-Solving

Ability to tackle ill-defined problems, ask the right clarifying questions, break down complex challenges, and propose reasonable solutions with limited information.

Practice Interview

Study Questions

Frequently Asked Mobile Developer Interview Questions

Amazon Leadership PrinciplesHardTechnical

73 practiced

As a Staff Mobile Developer, define a 12-month technical roadmap to increase user engagement and reduce churn for the mobile product while reflecting Amazon Leadership Principles like Think Big, Customer Obsession, Deliver Results, and Hire and Develop. Provide measurable objectives/OKRs, key initiatives with milestones, dependencies, required hires or skill gaps, cross-team coordination needs, and how you will measure and iterate on outcomes.

Sample Answer

**12‑Month Technical Roadmap (Staff Mobile Developer)**

**Goal / OKRs**- Objective 1 (Customer Obsession): Increase 30‑day DAU by 25% in 12 months; reduce 30‑day churn by 20%. - KR1: +25% DAU, KR2: -20% churn, KR3: NPS mobile score +10 pts.- Objective 2 (Deliver Results / Think Big): Improve A/B experiment velocity to ship 6 major engagement experiments/quarter. - KR: 24 experiments/year with statistically significant results.

**Key Initiatives & Milestones**1. Instrumentation & Analytics (Q1) - Milestones: event schema, SDK upgrade, session tracking, funnel dashboards. - Deliverable: real‑time analytics dashboard + baseline metrics.2. Personalization & Push Revamp (Q2–Q3) - Milestones: server-driven personalization, segmented push templates, engagement ML model pilot. - Deliverable: 10% uplift pilot cohort.3. Onboarding & Retention Flows (Q2) - Milestones: onboarding A/B tests, progressive profiling, deep link campaigns. - Deliverable: reduce first‑week churn by 15%.4. Performance & Reliability (ongoing) - Milestones: app size reduction, cold-start <1s, 99.95% crash‑free target.5. Experimentation Platform & CI/CD (Q1–Q4) - Milestones: feature flags, rollback automation, nightly builds for device matrix.

**Dependencies & Cross‑Team Needs**- Product: prioritization, UX research for experiments.- Backend/ML: APIs for personalization, real‑time events.- Data Engineering: event pipeline, attribution.- Marketing: push/content coordination.

**Hiring / Skill Gaps**- 1 Mobile SDK Engineer (performance & infra)- 1 ML/Personalization engineer (mobile inference)- 1 QA/Automation engineer (device farm & CI)- Mentorship plan: pair‑programming, biweekly brown‑bags (Hire and Develop).

**Measurement & Iteration**- Weekly dashboards: DAU, retention cohorts, crash rate, experiment p‑values.- Monthly review: pivot or scale experiments; retro and learnings logged.- Success = hit OKRs; if not, run 30/60/90 corrective plans prioritizing customer pain points.

This plan emphasizes customer obsession, thinks big with personalization/ML, delivers measurable results, and builds the team.

Mobile Platform Features and ServicesHardTechnical

38 practiced

Plan a migration strategy for an Android app that currently uses legacy external storage file paths to move to Scoped Storage (Android 10/11+). Explain how to migrate existing user media files, update stored file paths in databases, support third-party integrations that expect filesystem paths, handle content URIs, and maintain backward compatibility across API levels without data loss.

Sample Answer

**Plan summary — goals**- Move user media to MediaStore / app-specific storage so files remain accessible under scoped storage.- Preserve/accessibility: update app DB to map old absolute paths → content:// URIs, support third-party libs expecting file paths via FileProvider or temp copies.- Maintain backward compatibility (API <29), avoid data loss.

**Steps**1. Audit & requirements - Enumerate file types (images, video, documents), count, total size. - Decide targets: MediaStore (images/video/audio) vs SAF/app-specific for others.

2. Migration mechanics - Run migration off-main-thread with progress + resumable checkpoints. - For each legacy file: - Insert into MediaStore (or SAF) and stream-copy bytes, verify checksum/size. - On success, delete original. - Record mapping old_path → new_content_uri in a migration table; update app DB atomically (transaction).

Kotlin example — insert image into MediaStore and copy:

kotlin

val values = ContentValues().apply {
  put(MediaStore.Images.Media.DISPLAY_NAME, file.name)
  put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg")
  put(MediaStore.Images.Media.RELATIVE_PATH, "Pictures/MyApp")
}
val uri = contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)!!
contentResolver.openOutputStream(uri).use { out ->
  FileInputStream(file).use { input -> input.copyTo(out) }
}

3. Handling content URIs & third-party integrations- Prefer storing content:// URIs in DB. When consumer needs filesystem path: - Use FileProvider to expose a streamed temporary file (create temp in cache, write contentResolver.openInputStream(uri), expose via FileProvider.getUriForFile). Grant URI permission intent flags for share. - For libraries needing File object (not URI), create temp file and pass its File path; ensure deletion after use.

4. Backward compatibility- API 29: set requestLegacyExternalStorage=true temporarily to ease migration; ensure migration complete before removing.- Use runtime branching: - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) use MediaStore/SAF/content URIs - else continue using legacy paths.- For devices <Q, keep original paths and sync mapping.

5. Edge cases & safety- Handle name collisions by appending suffix.- Resume after interruption using migration table and checksum comparisons.- Preserve EXIF/meta when copying.- Ensure permissions: READ/WRITE_EXTERNAL_STORAGE where required; request MANAGE_EXTERNAL_STORAGE only if absolutely necessary and justify to Play.

6. Rollout strategy- Phased rollout with telemetry, small % first, validate migration success rates; provide in-app recovery (retry) and manual export.

Result: users keep their media intact, app uses modern APIs, third-party compatibility via FileProvider/temp files, and no data loss via verify-then-delete and mapping table.

Offline First Architecture and Data SynchronizationHardTechnical

42 practiced

For a mobile e-commerce checkout flow, analyze trade-offs between implementing strong consistency (server-side reservation or locks at checkout) versus eventual consistency (optimistic checkout with later reconciliation). Propose a hybrid approach that minimizes user friction, reduces oversell risk, and supports offline shopping scenarios.

Native and Cross Platform Trade OffsMediumTechnical

30 practiced

Outline unique security considerations for cross-platform frameworks (for example bundled JS code, runtime introspection). For each risk propose mitigation strategies and explain how these choices affect release, QA, and audit processes.

Sample Answer

**Overview**Cross-platform frameworks introduce specific security risks: bundled JS/Dart code exposure, runtime introspection/reflection, third‑party plugin supply chain, platform bridge misuse, and binary tampering. Below I list each risk, mitigations, and impacts on release/QA/audit.

**1) Bundled source (JS/Dart) exposure**- Risk: Logic, API keys, secrets reverse‑engineered from bundle.- Mitigation: Move secrets to backend; use per-installation tokens; obfuscate code (ProGuard/R8, JS obfuscators, Dart minification + symbol stripping); encrypt sensitive assets and decrypt at runtime using OS keystore.- Impact: Release requires obfuscation build step and keys management; QA must test obfuscated builds and telemetry; audits check secret handling and obfuscation config.

**2) Runtime introspection & dynamic eval**- Risk: eval(), dynamic code loading, or reflection increases attack surface.- Mitigation: Disallow remote code execution; reject runtime eval; enable code signing for dynamically loaded modules; restrict plugin API surfaces.- Impact: CI must block unsafe APIs; QA performs runtime fuzzing and instrumentation tests; auditors review policy and code signing.

**3) Native bridge misuse**- Risk: Unsafe marshaling across JS/Dart ↔ native leads to injection or privilege escalation.- Mitigation: Validate and type‑check bridge inputs; enforce least privilege in native modules; use typed interfaces (e.g., RN TurboModules, Flutter platform channels with strong schemas).- Impact: Release requires gating native modules; QA includes cross‑boundary unit tests and security integration tests; audits examine interface contracts.

**4) Third‑party plugins & supply chain**- Risk: Malicious or vulnerable packages.- Mitigation: Vet packages, pin versions, use SCA tools, sandbox third‑party code, minimize permissions.- Impact: Release process includes SBOM and dependency checks; QA runs dependency fuzz and permission audits; auditors review SBOM and SCA reports.

**5) Binary tampering & repackaging**- Risk: Repackaged apps with backdoors.- Mitigation: App signing, tamper detection, runtime integrity checks, Play/App Store distribution verification.- Impact: Release enforces strict signing pipelines; QA tests integrity checks and rollback behavior; audits verify signing keys and CI security.

Summary: Adopt defense-in-depth—move secrets server-side, enforce strong CI gating (obfuscation, SCA, signing), add targeted QA tests for obfuscated/runtime builds, and produce artifacts (SBOM, signing proofs) for audits.

Ambiguity Navigation and Decision MakingEasyTechnical

135 practiced

Describe a lightweight pattern for running rapid on-device experiments in mobile apps (e.g., trying two onboarding flows) that minimizes build/release friction. Include the tools or frameworks you would use and how you'd handle data collection for analysis.

Mobile Platform KnowledgeHardTechnical

77 practiced

Discuss pros and cons of using over the air code update mechanisms such as CodePush for React Native or similar hot patching in other frameworks. Include app store policy constraints, security and integrity risks, compatibility issues with native APIs and ABI changes, and outline a safe implementation plan that includes verification, rollback and legal considerations.

Sample Answer

**Brief stance**OTA JS/bytecode updates (e.g., CodePush for React Native) speed bug fixes and UX tweaks but carry policy, security, compatibility and legal risks. Use them selectively and with strict controls.

**Pros**- Fast bug fixes and A/B experiments without store resubmits- Reduced user friction; faster mean time to fix- Smaller payloads than full binary updates

**Cons / Risks**- App store constraints: Apple allows JS/content updates but forbids changing app’s primary purpose or delivering new native code/feature sets that bypass review; Google’s policies similar — risk of rejection or removal if abused.- Security/integrity: remote code delivery opens supply-chain attack surface.- Compatibility: native API or ABI changes require binary updates; JS patches can break if native bridge signatures change.- Debuggability & support complexity; increased testing matrix.

**Safe implementation plan**- Policy & legal: - Document OTA usage in TOS and privacy policy. - Limit OTA to non-native-feature changes; keep features requiring native modules to store updates. - Maintain audit logs of released bundles and rollbacks for compliance.- Verification & delivery: - Serve bundles over TLS with HSTS. - Sign bundles server-side with asymmetric keys; verify signature before applying. - Validate bundle schema and runtime compatibility metadata (min native SDK version, ABI hash).- Deployment strategy: - Canary/staged rollouts (e.g., 1% → 10% → 100%) with metrics gates. - Use feature flags to toggle risky changes server-side.- Rollback & safety nets: - Automatic health checks and crash-rate monitoring; revert on threshold breach. - Keep previous known-good bundle on-device for instant rollback. - Remote “kill switch” to disable OTA execution if compromise suspected.- Testing & QA: - Preflight E2E tests on device farm and on every supported native ABI/version. - CI to verify bundle signs, integrity, and compatibility metadata.

**Example checks**- Before apply: verify signature, check ABI hash matches native app, validate min/native SDK constraints.- On failure: load local fallback bundle and report telemetry with logs.

Using CodePush-like tools can be powerful if constrained to JS/UI fixes, cryptographically verified, staged, observability-driven, and aligned with app store policies and legal disclosures.

Mobile Networking and API IntegrationEasyTechnical

25 practiced

Compare JSON and Protocol Buffers (protobuf) for mobile API payloads. Discuss trade-offs in size, parsing speed, schema evolution, human-readability, tooling and cross-platform support. Give examples of when you would choose JSON versus protobuf for a mobile client app.

Mobile Application ArchitectureMediumTechnical

55 practiced

Explain strategies to manage native dependencies and ABI compatibility for Android NDK and iOS C/C++ libraries across OS versions and multiple CPU ABIs. Discuss packaging (AAR, .framework), ABI splits, fat binaries, symbol conflicts, semantic versioning, and testing across a device/ABI matrix.

Sample Answer

**Approach summary**I manage native libs by treating ABI/OS compatibility as first-class: produce per-ABI artifacts, version them semantically, avoid symbol clashes, and validate across an explicit device × ABI × OS matrix in CI.

**Packaging**- Android: produce an AAR that contains jni/<abi>/libmylib.so (built with CMake/ndk-build). Use ABI splits in Gradle (abiFilters or bundle splits) or upload multiple APKs/Bundles per ABI to Play; keep common Java API stable.- iOS: prefer XCFramework (replaces fat .framework) to package slices per architecture and platform (device/simulator). Export a single XCFramework or SPM/CocoaPod with platform-aware binaries.

**ABI splits & fat binaries**- Android: ship per-ABI .so files inside AAR; use Play Asset Delivery / App Bundle ABI targeting to minimize APK size.- iOS: use XCFramework (not single fat frameworks) to cleanly support arm64/armv7/x86_64 and simulator without linker surprises.

**Symbol conflicts & namespacing**- Use unique namespaces and C++ inline namespaces or versioned symbols; apply -fvisibility=hidden and explicit exported symbol lists. For C APIs, prefix symbols (mylib_*) and use versioned SONAME on Android/Linux.- For static libs, avoid linking same symbols twice; prefer shared libs and dependency deduplication.

**Versioning & compatibility**- Semantic versioning: MAJOR break = public API/ABI change. For C/C++ expose a stable ABI or bump SONAME. Document supported OS/min SDKs and ABI matrix.- Use header version guards and runtime checks (api-level) to gate features.

**Testing matrix**- Create CI jobs for each ABI × minOS × build type: - Android: emulators + physical ARM64 devices; run instrumentation tests and native unit tests via google-test on device or host. - iOS: unit/UI tests on simulators + real devices (arm64) using XCTest on CI (Bitrise/Device Farm/Xcode Cloud).- Include fuzz/smoke tests for load/link, regression tests for symbol resolution, and performance benchmarks.

**Trade-offs**- XCFrameworks and per-ABI AARs increase build complexity but reduce runtime surprises and APK size. Fat binaries simplify distribution but risk linker conflicts and larger downloads.

Concrete steps: automate cross-compiled builds via Gradle/CMake and Xcode archives, tag releases with semantic versions and SONAME, run CI matrix, and publish artifacts (AAR/XCFramework) with clear compatibility metadata.

OwnershipMediumBehavioral

22 practiced

Give an example of how you owned customer feedback from app store reviews or in-app surveys. Explain how you triaged feedback, translated it into engineering or product actions, prioritized fixes, measured impact after shipping, and communicated results back to users or stakeholders.

Mobile User Interface Implementation and ResponsivenessMediumTechnical

19 practiced

In Kotlin using Jetpack Compose, implement (or outline) a screen that shows a list of items and a detail pane. On narrow screens (phones) tapping an item should navigate to a detail screen; on wide screens (tablets/landscape) the UI should show list and detail side-by-side. Provide composable layout structure, how you detect width/breakpoints, and how you handle navigation and state sharing between panes. Include pseudocode or sample Compose code.

Sample Answer

**Approach (brief)**- Use a single Activity + Jetpack Navigation Compose.- Detect window width with WindowSizeClass or custom breakpoints.- If compact -> show ListScreen; on item tap navigate to DetailScreen.- If expanded -> show SplitView with ListPane and DetailPane sharing ViewModel.

**Composable layout + navigation (sample)**

kotlin

@Composable
fun MainApp(navController: NavHostController = rememberNavController(), vm: SharedViewModel = viewModel()) {
  val windowSize = rememberWindowSizeClass() // androidx.compose.material3: WindowSizeClass
  NavHost(navController, startDestination = "root") {
    composable("root") {
      if (windowSize.widthSizeClass == WindowWidthSizeClass.Compact) {
        ListScreen(onClick = { item ->
          vm.select(item)
          navController.navigate("detail")
        })
      } else {
        // tablet: master-detail
        SplitScreen(vm = vm)
      }
    }
    composable("detail") {
      DetailScreen(vm.selectedItem)
    }
  }
}

kotlin

@Composable
fun SplitScreen(vm: SharedViewModel) {
  Row(Modifier.fillMaxSize()) {
    ListPane(modifier = Modifier.weight(1f), onSelect = { vm.select(it) })
    Divider(Modifier.width(1.dp).fillMaxHeight())
    DetailPane(modifier = Modifier.weight(2f), item = vm.selectedItem)
  }
}

**State & ViewModel**- SharedViewModel exposes StateFlow / LiveData selectedItem.- On phones, selecting sets ViewModel then navigation shows detail which reads same state.- On tablets, both panes observe the same selectedItem.

kotlin

class SharedViewModel: ViewModel() {
  private val _selected = MutableStateFlow<Item?>(null)
  val selectedItem: StateFlow<Item?> = _selected
  fun select(i: Item) { _selected.value = i }
}

**Notes / trade-offs**- WindowSizeClass is recommended (Material3) for modern breakpoints.- Keep navigation simple: phone uses separate route; tablet keeps single route to avoid backstack duplication.- Ensure null-state handling (show placeholder in detail when nothing selected).

Practice Mobile Developer questions across all topics

Want to create your own tailored preparation guide using our deep research?

Get Started for Free

Interview-Ready Courses

Visual-first, interactive, structured learning paths

Browse Mobile Developer jobs

AI-enriched listings across hundreds of company career pages

Explore Jobs

Amazon Senior Mobile Developer Interview Preparation Guide

Interview Process Overview

Interview Rounds

Recruiter Screening

What to Expect

Tips & Advice

Focus Topics

Compensation and Logistics Expectations

Practice Interview

Study Questions

Understanding of the Role and Team

Practice Interview

Study Questions

Background and Experience Summary

Practice Interview

Study Questions

Motivation and Interest in Amazon

Practice Interview

Study Questions

Technical Phone Screen

What to Expect

Tips & Advice

Focus Topics

Optimization and Scalability Thinking

Practice Interview

Study Questions

Platform-Specific Knowledge (iOS or Android)

Practice Interview

Study Questions

Code Quality and Communication

Practice Interview

Study Questions

Data Structures and Algorithms Fundamentals

Practice Interview

Study Questions

Mobile-Specific Problem Solving

Practice Interview

Study Questions

Mobile Development Technical Interview (Onsite - Round 1)

What to Expect

Tips & Advice

Focus Topics

Cross-Platform Considerations

Practice Interview

Study Questions

State Management and Architecture Patterns

Practice Interview

Study Questions

Testing and Debugging Mobile Applications

Practice Interview

Study Questions

Mobile Network and Data Management

Practice Interview

Study Questions

Mobile UI/UX Implementation

Practice Interview

Study Questions

Platform-Specific Features and APIs

Practice Interview

Study Questions

System Design and Mobile Architecture (Onsite - Round 2)

What to Expect

Tips & Advice

Focus Topics

Modular and Component-Based Design

Practice Interview

Study Questions

Error Handling and Resilience

Practice Interview

Study Questions

Performance Optimization and Scalability

Practice Interview

Study Questions

Mobile App Architecture Patterns

Practice Interview

Study Questions

Data Persistence and Synchronization

Practice Interview

Study Questions

Mobile Performance, Optimization, and Security (Onsite - Round 3)