Learn Android as an engineering discipline.
This curriculum teaches the contracts that govern a production Android application: lifecycle ownership, state, concurrency, storage, process lifetime, rendering, security, and delivery. It is designed for deliberate study and interview preparation, not passive browsing.
Foundation curriculum
Build a precise model of the Android runtime before adding architecture patterns. The sequence moves from Kotlin types to components, ownership, rendering, data, and platform permissions.
Who this is for: For developers new to Android and candidates preparing for an entry-level role.
Entry check: Begin here unless you can explain configuration change, process death, and Context without notes.
Outcome: Implement a small feature that survives recreation, renders explicit state, and handles data and permission boundaries correctly.
Completion evidence: a lifecycle-safe detail screen with loading, error, empty, and content states.
- Kotlin: types, state, and program structure Establish the Kotlin type-system, state-modeling, and collection skills required to reason accurately about Android code. 50 min
- Activities, intents, tasks, and window ownership Understand how the system creates an Activity, delivers input, manages tasks, and defines the boundary of a screen host. 45 min
- Fragments and the view-lifecycle boundary Learn the separate lifetimes of a Fragment and its view, then apply that distinction to bindings, observers, and navigation. 45 min
- Lifecycle, recreation, and durable state Classify configuration change and process death correctly, then place UI state and durable data in the owner that can recover it. 50 min
- UI state, events, and rendering models Model the valid states of a screen, distinguish state from one-time work, and map application data into renderable UI models. 50 min
- Context, resources, process lifetime, and memory ownership Choose the correct Android Context, predict resource resolution, and prevent leaks by matching every reference to its proper lifetime. 55 min
- UI rendering, lists, and accessible interaction Build responsive Android interfaces that preserve item identity, expose semantic meaning, and remain usable across input methods. 65 min
- Storage, networking, files, and runtime permissions Select a durable data boundary, interpret network outcomes, handle user-owned files, and request sensitive access only when it is needed. 70 min
- Debugging, inspection, and Android platform tools Build a repeatable method for reproducing failures, reading evidence, inspecting application state, and verifying a fix on a real device. 55 min
Production engineering curriculum
Turn platform knowledge into a reliable production feature. These lessons connect asynchronous state, Compose, data ownership, tests, background execution, navigation, dependency graphs, and release artifacts.
Who this is for: For Android engineers who can already build screens and want to own features end to end.
Entry check: Start here only after the foundation curriculum feels routine in both Views and Compose.
Outcome: Design, implement, test, and release a feature with a clear source of truth and known failure behavior.
Completion evidence: an offline-capable paged screen with tests, deep links, and a release-ready build.
- Coroutines, Flow, cancellation, and state streams Use structured concurrency and observable streams to perform asynchronous work without losing cancellation, ownership, or failure semantics. 55 min
- Compose state, recomposition, identity, and effects Make declarative UI predictable by choosing state ownership, stable identity, and effect scope from the composition lifecycle. 55 min
- Android architecture, repositories, and unidirectional data flow Structure a feature around explicit data ownership, repositories, UI state, and boundaries that improve correctness and testability. 55 min
- Testing strategy, performance measurement, and diagnosis Test observable behavior at the appropriate layer and use evidence to diagnose rendering, startup, memory, and responsiveness problems. 50 min
- Persistence, HTTP, caching, and Paging Build a data flow that remains correct through refresh, pagination, cache invalidation, duplicate work, and credential changes. 75 min
- Background execution, services, and notifications Choose an Android execution model from requirements for durability, urgency, user visibility, constraints, and cancellation. 75 min
- Navigation, deep links, adaptive layouts, and window state Preserve user intent across navigation and deep links while adapting information architecture to available window space. 70 min
- Dependency injection, Gradle, artifacts, and release safety Understand object graphs, build variants, packaging, shrinking, and release verification as one delivery system. 75 min
Technical leadership curriculum
Make decisions for systems rather than isolated screens. The focus is on architecture boundaries, synchronization, operational safety, platform behavior, security, and the communication expected from a technical lead.
Who this is for: For engineers designing cross-team work, leading delivery, or preparing for senior and staff interviews.
Entry check: Begin after you can explain the mid-level choices as tradeoffs rather than library preferences.
Outcome: Defend a design in terms of constraints, recovery paths, observability, rollout safety, and user impact.
Completion evidence: a written design for a synchronizing mobile feature and an incident-aware release plan.
- Modularization, ownership, and architectural boundaries Define Android modules from ownership and change patterns, then enforce dependency direction without creating ceremonial abstraction. 55 min
- Offline synchronization and mobile source-of-truth design Design mobile features around unreliable transport, durable intent, retries, conflicts, and user-visible truth. 60 min
- Reliability, observability, rollouts, and technical decisions Connect an engineering decision to measurable signals, controlled rollout, incident response, and explicit consequences. 55 min
- Android runtime internals and performance engineering Trace startup, the main thread, Binder, rendering, memory, ANRs, and compilation so performance work begins with evidence. 85 min
- Android security, privacy, and client trust boundaries Threat-model entry points, credentials, storage, network behavior, WebView, telemetry, and dependencies without trusting the client as authority. 85 min
- Mobile system design: requirements, state, recovery, and scale Turn an ambiguous mobile feature into requirements, ownership, APIs, persistence, synchronization, security, recovery, and measurable tradeoffs. 95 min
- Senior interview execution and engineering leadership Communicate scope, technical judgment, incidents, migrations, disagreement, mentoring, and impact with evidence and precision. 80 min