Back to posts

Mobile System Design, In Layers

·4 min read
MobileArchitectureSystem Design

Mobile system design is rarely about screens. It is about the choices you make when the constraints are real and the tradeoffs are uncomfortable. I like to think in layers. It keeps the conversation grounded and makes the gaps obvious.

The Layered Lens

When you are designing a mobile system, step through the stack in order. Each layer depends on the one above, and each one has different failure modes.

Network

Protocols, retries, offline-first behavior, and real-time updates. Decide how hard you will lean on connectivity and how graceful the app is when it disappears.

Data

Storage, caching, sync, and the source of truth. You should be able to point to exactly where a piece of data is authoritative and when it is safe to read it locally.

UI

States like loading, error, and empty. Also responsiveness, not only in layout, but in perceived latency. What does the user see while the system catches up?

Security

Auth, tokens, PII, and compliance. The architecture should make it hard to do the wrong thing by default.

Performance

Startup time, battery, memory, and app size. If you do not have budgets, you do not have a system, just a prototype.

Rollouts

Feature flags, backward compatibility, and CI/CD. Real systems evolve, and the upgrade path is part of the design.

Monitoring

Crashes, metrics, and user funnels. Observability is not a nice-to-have; it is the feedback loop that makes the rest of the system trustworthy.

Team Context

Scale, tradeoffs, and constraints. A design that ignores your team’s reality is a design that will not ship.

The Interview Reality

Mobile system design interviews are not about screens. They are about how you reason through the constraints, and how explicit you are about the tradeoffs you accept.

If you can walk the interviewer through these layers, you can usually find the right level of detail without getting lost in implementation.

Quick Reference Cheat Sheet

A compact checklist I use to stay crisp in mobile system design interviews. It is not exhaustive, but it is a reliable baseline.

Network

  • Protocols and formats: REST, GraphQL, gRPC, protocol buffers.
  • Real-time: polling, SSE, WebSockets.
  • Request management: idempotency, rate limits, priority, retries.
  • Pagination: offset vs. cursor.
  • Offline and resilience: offline-first, optimistic updates, conflict resolution, exponential backoff.

Data Management

  • Data flow: layer responsibilities, error handling and propagation.
  • Storage: key-value, relational, custom/binary, secure storage.
  • Caching: memory vs. disk, eviction (TTL, size, priority).
  • Sync: delta sync, conflict resolution, source of truth.
  • Privacy: PII handling, GDPR, retention.
  • Background work: prefetching, OS limits, battery tradeoffs.

UI and Interactions

  • State coverage: loading, empty, error, content.
  • Input: validation, sanitization, error feedback.
  • Search: local vs. server, indexing, typo tolerance.

Feature Development

  • Versioning: soft vs. hard upgrades, compatibility.
  • Rollouts: feature flags, phased release, rollback.
  • CI/CD: build and test automation, reproducibility.
  • Dynamic config: remote config defaults for offline.
  • Experiments: A/B tests, segmentation, success metrics.
  • Analytics: crash monitoring, logs, performance metrics.
  • Code architecture: modularization, DI, third-party risk and size.

Performance

  • Startup: cold and warm start budgets, deferred init.
  • Stability: error boundaries, crash prevention.
  • Battery and CPU: batch work, minimize background.
  • Network efficiency: compression, fewer requests, adaptive quality.
  • App size: asset optimization, app bundles, prune dead code.
  • Caching and lazy loading: invalidation, on-demand loading.
  • Concurrency: threading, contention, race conditions.
  • Rendering: GPU acceleration and animation cost.

Monitoring

  • Observability: metrics, traces, alerts.
  • Business impact: funnels, engagement, revenue bottlenecks.

Team and Organization

  • Design system: reusable components, consistency.
  • Developer experience: build speed, docs, review standards.
  • Quality and risk: tests, static analysis, tech debt, contingency plans.
  • Company context: resources, priorities, stack constraints.
  • Operations: incident response, recovery playbooks, redundancy.