Mobile Core Concepts

The system-design problems in this catalog assume you have the platform vocabulary. Core Concepts are the primers that fill the gaps - each one covers a piece of Android substrate or an architectural pattern the problem pages don't stop to re-explain. This page is the map: the subjects, the order they depend on, and the two ways to read through them. If you haven't read Mobile System Design Introduction, do that first - this page assumes you understand what the interview grades.

The subjects

Catalog order is intentional - earlier subjects are substrate for later ones. Reading top to bottom never references a concept that hasn't been introduced.

Platform Foundations. Platform Knowledge and Android Compatibility. The meta-knowledge every later entry assumes - what an Activity is, what a Service is, the App Standby bucket model, the Doze state machine, the SDK level inflection points (API 23, 26, 29, 31, 34) that gate every subsequent piece of substrate. Day-1 read. Without these, "Coroutines" and "Compose" don't anchor to anything.

Code Organization. Concurrency, Architecture, and Dependency Injection. The shape of the code: Coroutines and structured concurrency, MVVM / MVI / Clean as architecture patterns, Hilt and Dagger as DI mechanics. Concurrency is the most cited prereq in the catalog - half the later pages assume you know what a StateFlow is and how viewModelScope cancellation works. Read it second.

UI and Rendering. Compose, State Management, Navigation, How Rendering Works, and Accessibility and i18n. What the user sees, how it gets on screen, who can use it. Recomposition skipping, the View tree to SurfaceFlinger pipeline, the navigation back stack and predictive back, SavedStateHandle and process death, TalkBack and the semantic tree. These five are tightly coupled and benefit from being read in subject order.

Data Layer. Network Protocols, Caching Strategies, Persistence, Pagination, Offline-First and Sync, and Image Loading Internals. How the app moves bytes across the network and onto disk, and how the design holds up when the network is unreliable. HTTP/2 vs WebSocket vs SSE, the layered cache model (memory LRU plus disk LRU plus HTTP cache plus CDN), Room and DataStore, the keyset vs offset trade-off in paginated lists, the offline-first playbook with its write strategies and conflict resolution. Offline-First sits above Persistence and Caching in the reading order; Image Loading Internals is the capstone - it pulls Network and Caching and Rendering together.

System Integration. Background Work and Scheduling, Push and Notifications, and IPC. Talking to the rest of the device through Android's system services. WorkManager constraint mappings, FCM token rotation and data-vs-notification messages, AIDL and bound services. These pages anchor every "what happens when the user backgrounds the app" question in a system-design interview.

Embedded and Native Surfaces. WebView and Custom Tabs and NDK and JNI. When the app is not just Kotlin - embedded web content, third-party render engines, your own C and C++ via JNI. Smaller subject; relevant only when a system-design prompt forces it (a documents app embedding a renderer, a crash reporter installing a SIGSEGV handler).

Runtime Quality. Security and Crypto, Memory and GC, and Performance and Profiling. Properties of a shipped app: threat model, memory budget, frame budget. These are the runtime capstone - every system-design problem ends up pulling at least one of them in for trade-offs. Memory and GC is the most cited of the three from inside other pages.

Build and Delivery. Build Systems, App Size and Delivery, and Testing. How the source becomes a shipped APK / AAB and what gates each release. Gradle and the Android Gradle Plugin, KSP vs KAPT, R8 shrinking, App Bundle delivery and the Play download-size caps, and the test pyramid from unit through Macrobenchmark. The terminal subject; its testing surface pulls from every other subject, which is why it reads last.

How to read this catalog

Two valid paths.

Subject order, top to bottom. The full catalog walk, best for first-time prep. Read every page in every subject in the catalog order above. After Code Organization, the three application subjects (UI, Data, System Integration) can be read in any internal order; the dependencies allow it. Finish with Runtime Quality, then Build and Delivery.

Cross-link driven, starting from a system-design problem. Start reading and practicing the system-design problems. Every time one cites a Core Concept you don't know, open that page in a new tab, read the relevant section, then go back to the problem.