Gestures To Screens

How to Design Mobile Applications

47 modules

190 lessons

—

Part 1

Appendices

Appendix A - Diagram Templates by StepSign in
Appendix B - Mapping Concepts to Platforms and FrameworksSign in
Appendix C - Readiness Checklists for Moving Up the LadderSign in
Appendix D - GlossarySign in

Part 2

Course Setup and the Incremental Ladder

Course Setup and the Incremental LadderSign in
Why Gestures to ScreensSign in
How to Use This CourseSign in
The Incremental Ladder (Step 0 to Step 7)Sign in
The Course LensesSign in
Diagram Legend and Notation TypesSign in

Part 3

What Is a Mobile Application System?

What Is a Mobile Application System?Sign in
Mobile Apps as Client-Side SystemsSign in
App vs Backend vs Store EcosystemSign in
The Little OS-Native Client ModelSign in

Part 4

Mobile Operating Systems and Process Models

Mobile Operating Systems and Process ModelsSign in
OS Lifecycle IntuitionSign in
Processes, Screens, TasksSign in
Sandboxing and App ContainersSign in

Part 5

App Lifecycles and States

App Lifecycles and StatesSign in
Foreground, Background, Suspended, TerminatedSign in
Lifecycle Callbacks and Safe TransitionsSign in
Preserving State Across RecreationSign in

Part 6

Touch Input and Mobile UI Basics

Touch Input and Mobile UI BasicsSign in
Touch Events and GesturesSign in
Controls and Interaction PrimitivesSign in
Layout SystemsSign in

Part 7

Diagramming Mobile Architectures

Diagramming Mobile ArchitecturesSign in
Navigation Graphs and Screen MapsSign in
Layer and Module DiagramsSign in
Data-Flow DiagramsSign in

Part 8

Building a Single-Screen Experience

Building a Single-Screen ExperienceSign in
One Screen, One ResponsibilitySign in
Orientation, Safe Areas, Accessibility BasicsSign in
Emergent Complexity in "Simple" AppsSign in

Part 9

Lifecycle-Aware UI and State

Lifecycle-Aware UI and StateSign in
Rotation and Process DeathSign in
View State vs Model State vs Persisted StateSign in
Keeping State Minimal but RobustSign in

Part 10

Local-Only Data and Simple Preferences

Local-Only Data and Simple PreferencesSign in
Key-Value StorageSign in
Validation and Feedback LoopsSign in
When Not to NetworkSign in

Part 11

Navigation Primitives

Navigation PrimitivesSign in
Navigation StructuresSign in
Back Behavior and ConventionsSign in
Deep Links and Initial RoutingSign in

Part 12

Passing Data Between Screens

Passing Data Between ScreensSign in
Parameter Passing PatternsSign in
Avoiding Global StateSign in
Back vs Up SemanticsSign in

Part 13

Designing User Flows

Designing User FlowsSign in
Onboarding and Progressive DisclosureSign in
Forms and Multi-Step TasksSign in
Error and Edge-Case FlowsSign in

Part 14

Basic Navigation Architecture Patterns

Basic Navigation Architecture PatternsSign in
Coordinators/Routers/Nav Controllers: separating navigation decisions from rendering logicSign in
Structural Choices (Conceptual): single-activity vs multi-activity-style splits and the coupling they createSign in
Early Navigation Boundaries: preventing navigation from becoming an untestable global side effectSign in

Part 15

Architecture Styles for Mobile Apps

Architecture Styles for Mobile AppsSign in
MVC/MVP/MVVM/MVI and Redux-Like Patterns: what each assumes about state and eventsSign in
Trade-offs: testability, clarity, and performance under real UX constraintsSign in
Choosing for Your Team and Product: matching architecture to iteration speed, risk, and staffing realitySign in

Part 16

Layered Architecture

Layered ArchitectureSign in
Presentation, Domain, Data: defining contracts so refactors don't become rewritesSign in
Boundaries and Interfaces: what crosses layers and what must notSign in
Keeping UI "Dumb": pushing logic downward to reduce lifecycle-driven bugsSign in

Part 17

State Management and View Models

State Management and View ModelsSign in
View Models as State Holders: ownership of screen state and lifecycle-aware computationSign in
Unidirectional Data Flow: reactive patterns and why they tame complexitySign in
Events, Side Effects, Navigation: keeping effects explicit so behavior is testableSign in

Part 18

Local Storage and Caching

Local Storage and CachingSign in
Storage Options: key-value, files, databases and choosing based on access patternsSign in
Schemas and Migrations: evolving stored data without breaking usersSign in
Cache Invalidation on Device: freshness, staleness, and device-local truthSign in

Part 19

Testing and Developer Experience at the Architecture Level

Testing and Developer Experience at the Architecture LevelSign in
Unit Testing View Models and Domain Logic: what to test when UI is mostly plumbingSign in
Mocking Data and Network Sources: isolating layers without losing realismSign in
Test Harnesses and Guardrails: keeping the architecture healthy as features accumulateSign in

Part 20

Networking Fundamentals on Mobile

Networking Fundamentals on MobileSign in
HTTP(S) and Serialization: request/response basics and the shape of mobile API clientsSign in
Request Queues and Retry: background fetch, retry logic and where it can harm UXSign in
Timeouts and Error Mapping: turning technical failures into user-safe messagesSign in

Part 21

Authentication and Sessions

Authentication and SessionsSign in
Token-Based Auth (High Level): sessions, refresh flows, and failure handlingSign in
Secure Storage of Secrets: what belongs in secure storage and whySign in
UX for Expiry: re-auth, degraded mode, and preventing data lossSign in

Part 22

Data Synchronization and Caching

Data Synchronization and CachingSign in
Online-Only vs Cache-Then-Network vs Offline-First: selecting a strategy by product requirementsSign in
Freshness and Timestamps: stale/fresh rules and user-visible consistencySign in
Pull-to-Refresh and Background Sync: manual and automatic refresh as complementary controlsSign in

Part 23

Offline-First Design

Offline-First DesignSign in
Screens Under Partial Connectivity: designing UI that remains coherent when the network disappearsSign in
Write Queues and Replay: capturing intent and applying it safely when onlineSign in
Conflicts and Merge Rules: simple, explicit resolution strategies that preserve user trustSign in

Part 24

Error Handling and Resilience

Error Handling and ResilienceSign in
Error Taxonomy: network/server/local validation and the different remedies each needsSign in
Backoff and Circuit Breaking: preventing cascading failure and battery/network wasteSign in
Communicating Without Overwhelming: resilient UX patterns that keep users orientedSign in

Part 25

Permissions and Privacy

Permissions and PrivacySign in
Permission Flows: rationale prompts, timing, and avoiding "permission fatigue"Sign in
Least Privilege in Product Terms: requesting only what you need and preserving optionalitySign in
Denial and Revocation: designing for changing consent and platform behaviorsSign in

Part 26

Location, Motion, and Orientation

Location, Motion, and OrientationSign in
Location Modes: coarse vs fine, and product accuracy requirementsSign in
Motion Sensors: accelerometer/gyroscope patterns and orientation handlingSign in
Power and Privacy Implications: treating sensor use as an operational budget and consent surfaceSign in

Part 27

Camera, Photos, and Media

Camera, Photos, and MediaSign in
Capture and Gallery Integration: working with system media surfaces safelySign in
Codecs and Processing Basics: compression, resizing, and performance constraintsSign in
UX Around Permissions: expectation-setting and trust when accessing personal mediaSign in

Part 28

Notifications and Background Tasks

Notifications and Background TasksSign in
Local vs Push Notifications: channels, scheduling, and product semanticsSign in
Background Processing Limits: platform constraints and reliable work schedulingSign in
Notifications as Product UX: designing alerts that support outcomes rather than spamSign in

Part 29

Platform Integrations and Extensions

Platform Integrations and ExtensionsSign in
Share Sheets and System Sharing: integrating with OS affordances as part of workflow designSign in
Extensions, Intents, and Custom URLs: deep integration surfaces and their security implicationsSign in
Cross-App Integrations (High Level): auth, payments, and system services as boundary-heavy featuresSign in

Part 30

Performance Fundamentals

Performance FundamentalsSign in
Main Thread vs Background: responsiveness as a hard constraintSign in
Common UI Pitfalls: blocking work, layout churn, and event stormsSign in
Performance Budgets: establishing budgets for views and operations before you need themSign in

Part 31

Rendering, Lists, and Smooth Scrolling

Rendering, Lists, and Smooth ScrollingSign in
Efficient Lists and Recycling: stable scrolling as a "must not regress" featureSign in
Images: loading, decoding, caching and avoiding jankSign in
Layout Thrash and Jank: diagnosing and preventing frame dropsSign in

Part 32

Memory Management and Leaks

Memory Management and LeaksSign in
Object Lifecycles: retention as a hidden system behaviorSign in
Leak Detection Tooling: spotting heavy allocations and long-lived referencesSign in
Anti-Leak Patterns: weak references, scopes, and explicit lifetimesSign in

Part 33

Battery and Network Usage Optimization

Battery and Network Usage OptimizationSign in
Radio Cost Models: cellular and Wi-Fi as energy consumers, not free pipesSign in
Scheduling Background Work: batching, throttling, and cooperating with platform schedulersSign in
Practical Network Discipline: retries, polling avoidance, and cost-aware sync strategiesSign in

Part 34

Startup Time, App Size, and Perceived Performance

Startup Time, App Size, and Perceived PerformanceSign in
Cold, Warm, and Hot Starts: what dominates startup in each modeSign in
Lazy Loading and Modules: on-demand resources and architectural prerequisitesSign in
Perceived Speed: skeleton screens, microcopy, and aligning perception with real workSign in

Part 35

Observability and Performance Monitoring

Observability and Performance MonitoringSign in
Logs, Metrics, and Traces on Mobile: what you can measure and how it differs from server observabilitySign in
Quality Dashboards: ANR, jank, crash rates and turning them into engineering prioritiesSign in
Data-driven refactors: using telemetry to justify architectural and performance workSign in

Part 36

Packaging, Signing, and Store Submission

Packaging, Signing, and Store SubmissionSign in
Bundles, Signing, Provisioning: release artifacts as cryptographically controlled productsSign in
Store Metadata: icons, screenshots, descriptions and the operational workflow around themSign in
Reviews and Compliance: policy constraints as part of architecture and feature planningSign in

Part 37

Release Channels and Rollouts

Release Channels and RolloutsSign in
Tracks and Channels: internal, beta, production and controlling blast radiusSign in
Staged Rollouts and Rollback: designing rollback paths that actually workSign in
Feature Flags and Remote Config: decoupling product iteration from store releasesSign in

Part 38

CI/CD Pipelines for Mobile

CI/CD Pipelines for MobileSign in
Automated Builds and Checks: repeatability as the foundation of release confidenceSign in
Artifact and Config Management: environments, secrets, and build determinismSign in
Store Integration: automating submission and deployment without losing controlSign in

Part 39

Crash Reporting and Analytics

Crash Reporting and AnalyticsSign in
Crash Collection and Triage: symbolication, grouping, and prioritizing by user impactSign in
Analytics and Funnels: designing events that answer product questions without noiseSign in
Privacy and Consent: minimization, transparency, and compliance basicsSign in

Part 40

A/B Testing, Experimentation, and Remote Config

A/B Testing, Experimentation, and Remote ConfigSign in
Experimentation Without Releases: running controlled experiments safely on mobileSign in
Guardrails: preventing experiments from degrading performance, privacy, or user trustSign in
Closing the Loop: using results to drive product decisions and engineering roadmapsSign in

Part 41

Modularization and Large-App Architecture

Modularization and Large-App ArchitectureSign in
Multi-Module Structures: feature modules, core libraries, shared UI and why boundaries matterSign in
Domain Boundaries: aligning modules with product domains to reduce couplingSign in
Dependency Management: avoiding cycles and preventing "one change breaks everything"Sign in

Part 42

Cross-Platform Strategy

Cross-Platform StrategySign in
Native vs Cross-Platform vs Hybrid: capability, performance, and staffing trade-offsSign in
Sharing Business Logic vs UI: where reuse helps and where it creates frictionSign in
Consistency and Divergence: managing design consistency while respecting platform differencesSign in

Part 43

Design Systems, Branding, and Accessibility

Design Systems, Branding, and AccessibilitySign in
Design Tokens and Component Libraries: keeping UI consistent without slowing deliverySign in
Accessibility at Scale: inclusive design as an engineering disciplineSign in
Syncing Design and Implementation: workflows that keep system and product alignedSign in

Part 44

Localization, Internationalization, and Regionalization

Localization, Internationalization, and RegionalizationSign in
Strings, Dates, Numbers, Layouts: the practical surface area of i18nSign in
RTL and Multi-Locale Edge Cases: designing layouts and flows that survive language changesSign in
Release and QA Workflows: testing localized builds without multiplying riskSign in

Part 45

Security, Privacy, and Compliance

Security, Privacy, and ComplianceSign in
Data at Rest and in Transit: protecting user data across device and network boundariesSign in
PII and Permissions: minimizing collection and designing consent-aware data flowsSign in
Threat Modeling for Mobile: attacker models tailored to device compromise, network interception, and abuseSign in

Part 46

Long-Term Evolution and Migration

Long-Term Evolution and MigrationSign in
Handling Breaking Changes: data migrations and deprecations as planned operationsSign in
Managing Technical Debt: refactors, rewrites, and re-skins without resetting product valueSign in
Evolving v1 into a Platform: operational playbooks for long-lived mobile productsSign in

Part 47

Putting It All Together: Reference Mobile Architectures

Putting It All Together: Reference Mobile ArchitecturesSign in
Reference App Archetypes: content app, chat app, offline-first app and their dominant constraintsSign in
Mapping Ladder Steps to Roadmaps: planning growth without skipping necessary capabilitiesSign in
Strategy Checklists: planning and executing a mobile platform strategy end-to-endSign in

Course overview