This chapter is useful because it quickly shifts the conversation away from server-side assumptions and into an environment where battery, memory, networking, and app lifecycle continuously shape architecture.
In real engineering work, it helps you design mobile clients and APIs around background limits, unstable connectivity, offline-first behavior, and expensive sync mistakes.
In interviews and design reviews, it is especially valuable when you need to show that mobile architecture is not a smaller backend, but a different set of constraints and trade-offs.
Practical value of this chapter
Mobile constraints
Supports architecture choices under battery, memory, network, and background limitations.
Client-server contracts
Improves API and sync design for unstable networks and offline user behavior.
Runtime behavior
Explains how app lifecycle constraints shape reliability and user experience.
Interview realism
Adds practical depth for mobile system design scenarios with device-level constraints.
Source
Android
Android architecture, features and application scenarios.
Android is a mobile operating system built on top of the Linux kernel and adapted for smartphones and tablets. It defines the architecture, security and lifecycle of applications.
Basic Android architecture
At the top are the applications and the framework, at the bottom are the layers that are closest to the hardware.
App layer
Applications and framework
Applications
User applications and System UI.
- System UI
- Launcher
- Apps
Application Framework
System services, activity management, and notifications.
- ActivityManager
- WindowManager
- Content Providers
Runtime layer
Runtime and native libraries
Android Runtime (ART)
App runtime, garbage collection, and code optimization.
- ART
- GC
- Class Loader
Native libraries
Platform C/C++ libraries: graphics, media, SQLite.
- Graphics
- Media
- SQLite
Platform layer
HAL and Linux kernel
Hardware Abstraction Layer (HAL)
Access abstraction for camera, audio, sensors, GPS, and modem.
- Camera
- Audio
- Sensors
Linux kernel
Scheduling, memory, networking, and device drivers.
- Scheduler
- Memory
- Drivers
Hardware
Hardware
How to launch a mobile application
An example chain: the user launches the application, Android picks up the process and gives control to system services, after which the UI is rendered through the graphics stack.
Mobile application launch
From Intent to rendering: how the request moves through Android layers
Apps
Layer 1App Framework
Layer 2Android Runtime
Layer 3Native libs
Layer 4Linux kernel
Layer 5Hardware
Layer 6Active step
Click "Start" to walk through the launch chain.
How it works and key features
- Strict application isolation and permissions model.
- Lifecycle management of applications and activities.
- Optimization for battery and background restrictions.
- Deep integration with mobile sensors and radio modem.
- Unified application store and distribution model.
Differences between Android and classic Linux
Uses the Linux kernel, but with its own user space and the bionic library instead of glibc.
Applications run on ART with a managed runtime and their own lifecycle.
The model of sandboxes and permissions at the OS level is more pronounced.
Deep focus on mobile devices, energy efficiency and sensors.
Why is this important for systems design?
- Mobile devices are limited by battery, CPU and memory - this affects application architecture.
- Network conditions are unstable: offline modes, caching and retrays are needed.
- Background tasks and notifications are managed by the OS, which affects data synchronization.
- Sensors, geolocation and cameras provide new product opportunities.
- Security and privacy require careful handling of permissions.
Related chapters
- Why foundational knowledge matters - gives context for how hardware and OS limits shape mobile architecture decisions.
- Operating system: overview - reinforces the user space/kernel space model and syscall boundaries.
- Linux: architecture and popularity - explains the Linux-kernel basis behind Android system behavior.
- Linux and UNIX or who gave birth to ALL modern systems! - adds historical context for Unix/Linux lineage behind mobile platforms.
- Containerization - connects Android process isolation with common Linux namespace/cgroup concepts.
- RAM and persistent storage - shows why memory and storage I/O limits dominate mobile runtime behavior.
- OSI model - helps reason about mobile networking paths and latency contributors.
- Engineering Reliable Mobile Applications (short summary) - extends reliability, observability, and rollout practices for mobile clients.