Mobile Core Concepts

System-design pages in this catalog assume the Android platform vocabulary. Core Concepts are the primers that fill those gaps: each covers a piece of substrate or an architectural pattern the problem pages do not stop to re-explain. This page is the map of subjects, dependency order, and the two reading paths through them. Start with Introduction; this page assumes you already know what the interview grades.

The subjects

Catalog order is intentional. Earlier subjects are substrate for later ones, so reading top to bottom never hits a concept that has not been introduced.

Platform Foundations

Android Compatibility, Process and Lifecycles, and Security and Crypto. Meta-knowledge every later entry assumes: the SDK level inflection points (API 23, 26, 29, 31, 34) that gate later substrate, what an Activity is, what a Service is, the App Standby bucket model and the Doze state machine, and the threat-model primitives (Keystore, crypto, signing, pinning) that network, persistence, and IPC all build on. Read these on day one. Without them, Coroutines and Compose have nothing to anchor to.

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, How Rendering Works, Navigation, and Accessibility and i18n. What the user sees, how it gets on screen, and 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 pages are tightly coupled; read them in subject order.

Data Layer

Network Protocols, Caching Strategies, Persistence, Pagination, Image Loading, and Offline-First. How the app moves bytes across the network and onto disk, and how the design holds 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, and the offline-first playbook with its write strategies and conflict resolution. Image Loading pulls Network, Caching, and Rendering together; Offline-First is the capstone, sitting above Persistence, Caching, and Background Work.

System Integration

Background Work, 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, and your own C and C++ via JNI. Smaller subject; relevant when a system-design prompt forces it (a documents app embedding a renderer, a crash reporter installing a SIGSEGV handler).

Runtime Quality

Memory and GC and Performance. Properties of a shipped app: memory budget and frame budget. Runtime capstone; every system-design problem ends up pulling at least one of them for trade-offs. Memory and GC is the most cited of the two from inside other pages.

Build and Delivery

Build Systems, App Size and Delivery, and Testing. How 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. 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 and Rendering, Data Layer, 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 do not know, open that page in a new tab, read the relevant section, then go back to the problem.

See also

• Introduction - rubric, interview types, and how the design catalog is organized. Read it before this map.

Used in

This page is the Start Here map, not a primer a design deep-dive cites by slug. Individual Core Concepts under each subject above are what the system-design problems link as prereqs.