Mobile System Design Interview Guide
The client-side design loop, broken down - and the questions to practice it on.
Mobile system design is its own interview, not backend system design with a phone bolted on. The rubric rewards client-side judgment: how you model local state, survive a flaky network, keep an offline-first cache honest, and budget battery and memory while you do it. Interviewers want to see you reason about the device as a constrained, intermittently-connected node - not draw boxes for a server fleet.
Work the breakdowns below the way a real loop runs: start from requirements and a rough data model, then defend the deep dives - sync conflict resolution, pagination and cursoring, image and media handling, background work. Each page walks the trade-offs an interviewer probes, so you practice defending decisions rather than memorizing a single 'right' diagram.
- The Android App Template
The 90% every concrete app design shares - the Compose + ViewModel + Flow + Room + Hilt skeleton to know and reuse.
Mobilemedium-2mo - Weather App
Design a forecast app like the Google or Apple weather app - one screen for the current location, a forecast that loads instantly from cache, an honest offline state, and a constrained background refresh.
Mobileeasy-1mo
+2 - Notes App(premium)
Design a local-first notes / to-do app like Google Keep - the note saves to Room the instant you type it, the UI renders from disk, and a background outbox syncs it to the cloud whenever the network is up.
Mobileeasy-1mo
- Feature Flag SDK(premium)
Design a LaunchDarkly-lite / Firebase Remote Config-lite Android SDK - typed flag evaluation that never throws, deterministic bucketing on user attributes, SSE push refresh with polling fallback, and a global kill switch that outranks targeting.
Mobilemedium-2mo
- Analytics / Logging SDK(premium)
Design a Firebase-Analytics-lite / Amplitude-lite Android SDK - microsecond-budget `track()` on the main thread, a durable on-device queue that survives OOM kill, and batched uploads that respect battery and consent.
Mobilehard-2mo
- Crash Reporter SDK(premium)Mobilehard-2mo
- HTTP Client Library(premium)
Design an OkHttp-lite Android HTTP client - the shared layer every network call flows through. Reuse warm connections, cache and retry safely, pin TLS certificates, and keep any one call from running forever.
Mobilehard-2mo - Image Loading Library(premium)
Design a Coil / Glide-lite Android image loader - memory + disk + network cache ladder, in-flight request dedup, downsampled decode, cancel-on-rebind, and bitmap pooling that keeps a 100-cell `LazyVerticalGrid` at 60 FPS without OOM.
Mobilehard-2mo - Messenger App(premium)
Design an Android messenger - a durable outbox so a tapped message survives a kill, a server-assigned per-chat seq so order is a property of the data, reconnect catch-up, and FCM wakeup for offline recipients.
Mobilehard-2mo+5 - Photo Gallery App(premium)
Design a Google Photos-style gallery - one timeline over the device and cloud libraries, background backup, full-resolution viewing, fresh-device restore.
Mobilehard-1mo+3 - Music Player App(premium)
Design a Spotify-lite Android player - adaptive HLS/DASH streaming, gapless playback via the Media3 playlist API, background playback as a MediaSessionService that lights up Auto / Wear / lockscreen, offline downloads with Widevine DRM, audio focus, and resume-position persistence.
Mobilehard-2mo
- Doc Editor App(premium)
Design a Google Docs-style collaborative editor on Android - local-first keystrokes, conflict-free merge across hours-long offline gaps, reconnect catch-up, and 100k-character documents at 60 fps.
Mobilehard-2mo
- Newsfeed App(premium)
Design an Android social feed - opaque cursor pagination over Paging 3 + RemoteMediator, optimistic engagement with idempotent retries, 60 FPS mixed-media scrolling with autoplay video, and pull-to-refresh that surfaces new posts without losing the reading position.
Mobilehard-2mo
+7 - Ride-Sharing App(premium)
Design an Uber / Lyft-lite Android rider app - a server-authoritative ride state machine, an idempotent ride request that survives a process kill, a 1-2 Hz driver-location stream interpolated to 60 FPS, FCM (Firebase Cloud Messaging) wakeup when the WebSocket is closed, and reconnect-and-reconcile under cellular drops.
Mobilehard-2mo+4 - Mobile System Design Introduction
Start here, what's important to demonstrate during mobile system design interview, the rubric the panel grades against, and types of such interviews.
Core Concept8m2mo - Platform Knowledge
Activity / Fragment / Service lifecycles, Application + ProcessLifecycleOwner, the ART runtime, and the OS-level constraints (process model, Doze, App Standby) every modern Android API assumes you understand.
Core Concept22m2mo - Mobile Core Concepts
The map of the Core Concepts catalog - the subjects, the order they depend on, and the two ways to read them.
Core Concept6m2mo - Android Compatibility
Why "it works on my device" is not a shippable answer, and the version-gating strategy that keeps one codebase correct across a decade of Android releases.
Core Concept18m2mo - Concurrency
Coroutines, structured concurrency, and Flow - Kotlin's concurrency model on Android, with the cancellation and scoping rules that keep work from leaking.
Core Concept20m2mo - Architecture
Clean Architecture layers, MVVM vs MVI, the Repository observe/refresh split, the three types of data operations, and Use Cases - the architecture vocabulary every mobile system-design panel listens for.
Core Concept26m2mo - Compose
Jetpack Compose's declarative model, recomposition rules, and the stability / state APIs that separate a fast Compose UI from a janky one.
Core Concept20m2mo - State Management
Why "who owns the state and what survives rotation" is the question every screen has to answer, with SSOT and UDF as the named principles, the two kinds of state holder, one-shot events as state, and the survival ladder - ViewModel, SavedStateHandle, rememberSaveable - that tells you which surface keeps each piece of state alive.
Core Concept22m2mo - How Rendering Works
The Android frame pipeline - main thread to RenderThread to SurfaceFlinger to display - plus Compose phases, Hardware Composer fallback, and how WebView's parallel pipeline meets up at the compositor.
Core Concept20m2mo - Navigation
Compose Navigation - NavController, type-safe routes, back stack mechanics, deep links, and per-destination ViewModel scoping. The contract every multi-screen Android app builds on top of.
Core Concept18m2mo - Accessibility and Internationalization
Why a screen that ignores semantics and locale reads as broken to a chunk of your users, and the parts an interviewer expects you to name when "accessibility" or "i18n" comes up.
Core Concept18m2mo - Network Protocols
Why the transport you pick shapes latency, reconnection, and battery - and the protocol an interviewer expects you to justify for any live or streaming surface.
Core Concept22m2mo - Caching Strategies
HTTP cache semantics, in-memory and disk LRU, CDN tiers, stale-while-revalidate, and invalidation patterns - the layered cache model every mobile app inherits.
Core Concept21m2mo - Persistence
Why "where does this state live when the process dies" is a design question, and the persistence decision tree that keeps data safe, fast, and recoverable.
Core Concept21m2mo - Pagination
Why an infinite scroll needs a cursor and a cache, and the pagination pattern that keeps a feed stable and smooth under inserts.
Core Concept20m2mo - Image Loading Internals
Why loading an image is a memory and decode problem, not a network call - and the pipeline decisions that keep a thousand-cell grid from OOMing a mid-range device.
Core Concept20m2mo - Background Work and Scheduling
Why work you start after the user leaves the screen has to be scheduled, not threaded, and the OS constraints that decide which scheduler a given job earns.
Core Concept20m2mo - Offline-First and Sync
Why offline is the mobile design problem, and the sync and conflict strategies every system-design loop probes the moment the network drops.
Core Concept22m2mo - Push and Notifications
Why push is a wakeup signal, not a data channel - and the FCM + notification rules that keep a background app responsive without burning battery.
Core Concept18m2mo - IPC
Why an Android app with more than one process or a cross-app surface needs the IPC primitives, and which one each system-design shape reaches for.
Core Concept21m2mo - Dependency Injection
Why the wiring between your layers is a build-time contract, not a runtime guess - and the scopes that keep a Singleton from leaking a screen's state across the app.
Core Concept20m2mo - Security and Crypto
Why a sensitive feature without the platform's crypto and attestation primitives is a liability, and the security seams an interviewer probes for anything touching tokens, keys, or user data.
Core Concept22m2mo - Memory and GC
Why a memory budget is a design constraint - and how GC pauses may cause dropped frame.
Core Concept21m2mo - Performance and Profiling
Why a performance claim without a measurement is a guess, and the tools an interviewer expects you to reach for when a frame budget or startup target is on the line.
Core Concept20m2mo - WebView and Custom Tabs
Why embedding web content inside an Android app is a security and performance decision, and the seam an interviewer probes when "show this web page" lands in a design.
Core Concept20m2mo - NDK and JNI
When reaching for C/C++ on Android earns its complexity, and the JNI and ABI constraints that decide whether a native dependency ships at all.
Core Concept22m2mo - Build Systems
Why the build is an architecture decision - the module graph and tooling knobs that decide whether a team ships weekly or watches CI all day.
Core Concept20m2mo - App Size and Delivery
Why every megabyte you ship costs install rate and startup time, and the delivery pipeline an interviewer probes when "app size" or "cold start" lands on the table.
Core Concept20m2mo - Testing
The Android test pyramid in practice - JVM unit tests, Robolectric on the JVM, instrumentation on a device, plus the doubles and screenshot tools that make the layers work.
Core Concept20m2mo