Become a Mobile Engineer. Not just an app builder.

Why mobile is a distinct engineering discipline - the device, the network, the OS and the store - not a UI layer.

• - Why mobile is a distinct engineering discipline, not a UI layer
• - The four constraints: device, network, OS, and the store
• - Modelling domains with sealed hierarchies & value types
• - Declarative UI: describing state, not mutating views
• - Composition, state hoisting, and the rendering contract
• - Project anatomy, build tooling & running on a real device vs emulator
• - Git and branching as an engineering discipline

Processes, process death, the sacred main thread, background limits and the runtime consent model.

• - Processes, threads, and the main loop
• - App lifecycle, process death & state restoration
• - The frame budget: why the main thread is sacred
• - Activities, fragments & the UI host
• - Background execution, scheduling, doze & battery limits
• - Memory pressure and how the OS decides to kill you
• - Permissions and the runtime consent model

Kotlin as an engineering language: coroutines, structured concurrency, Flows and the hard parts of shared state.

• - The advantages of the Kotlin language
• - Functional programming with Kotlin
• - ViewModel & state holders
• - Coroutines
• - Flows, back-pressure & reactive streams
• - StateFlow and SharedFlow
• - Coroutines & structured concurrency
• - Cancellation and scope ownership
• - Shared mutable state, races, and deadlocks

Boundaries, dependency inversion, unidirectional state, modularization and mobile system design.

• - Architecture as a response to change, not a template
• - Layering, boundaries & dependency inversion
• - State management & unidirectional data flow
• - Dependency injection and composition roots
• - Modularization and scaling a codebase across a team
• - Deciding what to share - and what never to share
• - Navigation, deep linking & app-to-app integration
• - Mobile system design: requirements, constraints, estimation

Single source of truth, persistence, migrations, layered caching, offline-first and sync with conflict resolution.

• - Single source of truth & data ownership
• - Local persistence: key-value, relational, file storage
• - Schema design and migrations without data loss
• - Layered caching: memory, disk, network
• - Cache invalidation and staleness policy
• - Offline-first architecture
• - Sync engines and conflict resolution

REST/HTTP contracts, auth & token refresh, retries & backoff, optimistic updates, realtime and idempotency.

• - REST, HTTP semantics, and API contracts
• - Serialization, schema evolution & backward compatibility
• - Authentication, token refresh & session lifecycle
• - Timeouts, retries & exponential backoff
• - Graceful degradation and partial failure
• - Pagination & infinite scrolling at scale
• - Optimistic updates and rollback semantics
• - Realtime: sockets, push notifications, delivery guarantees
• - Idempotency and duplicate-request handling

Jank, memory leaks, profiling & performance budgets, the mobile test pyramid, CI/CD, staged rollout and security.

• - Recomposition cost, jank, and startup time
• - Memory leaks: detection, causes, prevention
• - Feature flags, remote config & kill switches
• - Profiling, tracing, and performance budgets
• - Testing as design feedback: the mobile test pyramid
• - Unit, integration & instrumented UI testing
• - Testing coroutines, flows, and time
• - Build variants, flavors & environments
• - CI/CD with GitHub Actions and Fastlane
• - Signing, semantic versioning & staged rollout
• - Crash reporting, symbolication & triage
• - Encryption at rest & secure credential storage
• - Analytics, event schema design & release health
• - Static analysis, linting & code review practice

One Kotlin Multiplatform core → Android + iOS, engineered end to end: offline-first, resilient networking, tests and CI/CD to the store.

• - System design first: requirements, constraints, estimation
• - Multi-module architecture with a shared KMP core
• - Android and iOS from one engineered core
• - Authentication & full session lifecycle
• - Offline-first data layer with sync & conflict resolution
• - Pagination, layered caching & optimistic updates
• - Resilient networking: retry, backoff, idempotency
• - Push notifications & deep linking
• - Analytics & crash monitoring wired end to end
• - A real profiling and performance pass
• - Automated tests across the pyramid
• - Full CI/CD pipeline and store deployment

The mobile engineering interview map, 100 real questions, and a CV/LinkedIn/career arc.

• - The mobile engineering interview map
• - 100 questions from multiple sources, based on real experience
• - CV & LinkedIn that get callbacks
• - Career coaching: how to land the offer