Note

Quick Reference Cheat Sheet

Every consideration worth raising in a mobile design interview, grouped by domain — a scannable prompt sheet, not a checklist to recite.

5 min read

Mobile System Design · Chapter 11

Every consideration worth raising in a mobile system design interview, grouped by domain — a scannable prompt sheet, not a checklist to recite.

📖 How to read this

This is a recall aid for the topics in Chapters 1–10, organized so you can scan a domain mid-interview and pull the thread that fits. Depth on each lives in its own chapter. A [+] badge marks context added beyond the source. It is not a checklist — covering everything signals less design maturity than choosing the few things that matter for the problem in front of you.

Network — how the app talks to the backend#

Start every list-or-fetch discussion here. The first fork is almost always which transport, and the second is how the connection behaves when the network is bad.

Figure 1 — The real-time transport fork, the most common opening decision. [+]

Area	Raise these
Core protocols	Communication: REST, GraphQL, Protocol Buffers, gRPC Real-time: HTTP polling, SSE, WebSockets Request management: idempotency keys, priority queuing, rate limiting, throttling
Data flow	Pagination: offset vs. cursor Offline: offline-first design, optimistic UI, conflict resolution Resilience: connectivity handling, exponential backoff
Security	Auth: token lifecycle, biometric auth, recovery flows Infrastructure: encryption in transit and at rest, certificate pinning, compliance

Data management — architecture, storage, and state#

Everything from how data flows through the layers to what's cached where. Eviction and privacy are the details that separate a strong answer from a shallow one.

Area	Raise these
Architecture	Core data flow: flow patterns, layer responsibilities, error handling and propagation
Storage & caching	Storage options: key-value, relational/non-relational DB, custom/binary, secure storage Caching: in-memory vs. disk trade-offs Eviction: TTL, size-based, priority-based Privacy: PII handling, GDPR, data retention Sync: sync strategies, conflict resolution, delta sync
Data performance	Pre-fetching: predictive fetch, resource trade-offs, prioritize critical paths Background work: task efficiency, battery impact, OS execution limits
UI & interactions	UI states: loading, empty, error, content Input: client- and server-side validation, sanitization, error feedback Search: local vs. server-side, indexing, typo tolerance

Cache eviction, at a glance#

TTLExpire entries after a fixed lifetime — best when freshness is time-bound.

Size-based (LRU/LFU)Evict least-recently/-frequently used when a capacity cap is hit. [+]

Priority-basedKeep high-value entries; drop low-value ones first under pressure.

Delta syncFetch only what changed since the last sync to cut payloads.

Feature development — shipping and evolving safely#

How features reach users and how the codebase stays maintainable while they do. Strong signals of lifecycle thinking beyond pure implementation.

Area	Raise these
Version management	Force upgrading: soft vs. hard, when to require, graceful prompts, compatibility policy Safe rollout: phased rollouts, feature flags, rollback CI/CD: automated build/test/deploy, quality and security checks, reproducible builds
Dynamic config	Remote config: control features without app updates, offline defaults A/B testing: clear metrics, user segmentation Analytics: performance and business metrics, crash monitoring, logging
Code architecture	Modularization: separation of concerns, clear interfaces, right granularity Dependency injection: testability, lifecycle, minimal global state Third-party libraries: security, maintenance, size impact
User experience	Localization: text expansion/contraction, cultural and regional differences Accessibility: screen readers, contrast, touch targets, testing tools Crash reporting: automated collection, prioritize by impact/frequency, PII care

Performance — responsiveness within budget#

Universally relevant, critical on low-end devices and poor networks. Frame it as spending a fixed budget of CPU, memory, battery, and bandwidth wisely.

Area	Raise these
User experience	Pre-fetching: predictive fetch, resource trade-offs, critical paths first App startup: optimize init, defer non-critical work, measure cold/warm start Stability: prevent crashes, error boundaries
Resource management	Battery & CPU: minimize background work, batch operations Network: compress payloads, fewer requests, adapt quality to connection App size: optimize assets, app bundles, remove unused code
Technical	Caching: cache the right responses, invalidation, multi-level Lazy loading: on-demand components/data, defer heavy work, visible content first Concurrency: sound threading, never block the main thread, avoid races Hardware acceleration: GPU for animation/rendering
Monitoring	Observability: metrics, proactive alerting, traces for complex ops Business metrics: tie performance to engagement, funnels, revenue

Team & organization — the context around the design#

Senior interviews reward awareness that a design lives inside a team, a budget, and a business. Reach for these when asked how the system would be built and operated, not just how it works.

Area	Raise these
Technical infrastructure	Design system: consistent visual language, reusable components Dev efficiency: optimized builds, coding standards, effective reviews
Process & quality	Code quality: static analysis, automated testing, technical debt Risk management: early identification, contingency plans
Team & culture	Developer experience: efficient workflows, documentation Team growth: onboarding, knowledge sharing, continuous learning
Company context	Resources: infra constraints, team size and expertise, budget, build vs. buy Business priorities: objectives, target markets, monetization, short- vs. long-term Outage handling: escalation, recovery playbooks, redundancy Tech stack: integration with existing systems, platform consistency, standardization vs. specialization

How to use it#

Scan by domainNetwork, data, features, performance, org — pull the thread that fits the prompt.

Lead with the forkMost domains open on one decision (transport, storage, rollout) — name it first.

Justify, don't listSay why a consideration matters here; a bare enumeration reads as memorized.

Depth on demandEach line expands into its own chapter — go deep only where the interviewer leans in.

🎯 The single idea underneath it all

A cheat sheet is for recall, not coverage. The candidates who stand out don't touch every box — they pick the handful of considerations the specific system demands and defend the trade-offs. Strategic selection is the signal.