Mobile App Development Terminology

Fundamental concepts related to mobile device hardware, screen characteristics, and display rendering that every mobile developer must understand.

// Screen scale factor (1.0, 2.0, or 3.0)
let scale = UIScreen.main.scale

// Safe area insets for notch/home indicator
let insets = UIApplication.shared
    .connectedScenes
    .compactMap { $0 as? UIWindowScene }
    .first?.windows.first?.safeAreaInsets

print("Top: \(insets?.top ?? 0)")    // e.g. 59 for Dynamic Island
print("Bottom: \(insets?.bottom ?? 0)") // e.g. 34 for home indicator

Viewport

The visible area of a web page or app on a device screen. On mobile, the viewport is typically narrower than on desktop, requiring responsive design adjustments.

Safe Area

The portion of the screen guaranteed not to be obscured by device hardware (notches, rounded corners, home indicators). iOS introduced safe area layout guides; Android followed with display cutout APIs.

Notch

A cutout at the top of the display housing front-facing cameras and sensors. Popularized by iPhone X (2017) and adopted by many Android OEMs. Apps must account for notch insets.

Dynamic Island

Apple's interactive pill-shaped cutout (iPhone 14 Pro+) that expands to show real-time activities like timers, music playback, and navigation. Developers integrate via the Live Activities API.

DPI (Dots Per Inch)

A measure of pixel density on a screen. Higher DPI means sharper text and images. Common mobile DPI buckets: mdpi (160), hdpi (240), xhdpi (320), xxhdpi (480), xxxhdpi (640).

PPI (Pixels Per Inch)

The actual pixel density of a display, calculated from resolution and screen size. Often used interchangeably with DPI in mobile contexts, though DPI technically refers to print.

Retina Display

Apple's marketing term for screens with pixel density high enough (typically 326+ PPI) that individual pixels are indistinguishable at normal viewing distance. Requires @2x and @3x image assets.

Screen Density

The number of pixels within a physical area of the screen. Android categorizes density into buckets (ldpi, mdpi, hdpi, xhdpi, xxhdpi, xxxhdpi) to serve appropriately sized resources.

Resolution

The total number of pixels on a display, expressed as width x height (e.g., 1170 x 2532 for iPhone 14). Higher resolution enables sharper visuals but requires more GPU resources.

Aspect Ratio

The proportional relationship between screen width and height (e.g., 16:9, 19.5:9). Modern phones use taller ratios, requiring apps to handle varying aspect ratios gracefully.

Density-Independent Pixels (dp/dip)

An abstract unit on Android that normalizes pixel values across different screen densities. 1 dp equals 1 physical pixel at 160 DPI (mdpi). UI layouts should use dp for consistent sizing.

Points (pt)

iOS's density-independent unit. 1 point equals 1 pixel on non-Retina, 2 pixels on @2x Retina, and 3 pixels on @3x Retina displays. All iOS layout dimensions are specified in points.

Logical Pixels

A platform-agnostic term for density-independent units (dp on Android, pt on iOS, logical pixels in Flutter). They abstract away physical pixel density for consistent cross-device layouts.

Foldable Display

A screen that physically folds, enabling devices to transform between phone and tablet form factors. Requires apps to handle continuity, multi-window states, and hinge-aware layouts.

Refresh Rate

How many times per second the display updates its image, measured in Hz. Standard is 60 Hz; ProMotion (Apple) and high-refresh Android phones support 90-120 Hz for smoother animations.

Always-On Display (AOD)

A low-power mode showing essential info (time, notifications) on the lock screen without fully waking the device. Supported on OLED screens via selective pixel illumination.

Navigation defines how users move between screens and content in mobile apps. Choosing the right pattern impacts usability, discoverability, and user satisfaction.

import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
import { createNativeStackNavigator } from '@react-navigation/native-stack';

const Tab = createBottomTabNavigator();
const HomeStack = createNativeStackNavigator();

function HomeStackScreen() {
  return (
    <HomeStack.Navigator>
      <HomeStack.Screen name="Feed" component={FeedScreen} />
      <HomeStack.Screen name="Detail" component={DetailScreen} />
    </HomeStack.Navigator>
  );
}

export default function App() {
  return (
    <Tab.Navigator>
      <Tab.Screen name="Home" component={HomeStackScreen} />
      <Tab.Screen name="Search" component={SearchScreen} />
      <Tab.Screen name="Profile" component={ProfileScreen} />
    </Tab.Navigator>
  );
}

Tab Bar / Bottom Navigation

A bar at the bottom of the screen with 3-5 icons representing top-level destinations. The most common mobile navigation pattern. Each tab typically maintains its own navigation stack.

Stack Navigation

A LIFO (last-in, first-out) navigation model where screens are pushed onto and popped off a stack. The back button/gesture returns to the previous screen. Foundation of mobile navigation.

Drawer / Hamburger Menu

A side panel (typically from the left) containing navigation links, revealed by tapping a three-line (hamburger) icon. Common for apps with many destinations but criticized for hiding navigation.

Deep Linking

A URL or URI that opens a specific screen or content within an app rather than the home screen. Enables sharing, marketing, and cross-app navigation. Requires URL scheme or universal link configuration.

Universal Links (iOS)

Apple's deep linking mechanism using standard HTTPS URLs. When the app is installed, tapping a universal link opens the app directly; otherwise, it falls back to the website.

App Links (Android)

Android's verified deep linking system using HTTPS URLs with Digital Asset Links verification. Provides direct app opening without disambiguation dialogs when properly configured.

Modal

A screen or dialog that overlays the current content, requiring user interaction before returning. Used for focused tasks like login, compose, or confirmations. Presented modally rather than pushed onto the stack.

Bottom Sheet

A panel that slides up from the bottom of the screen, partially or fully covering content. Used for contextual actions, details, or secondary navigation. Can be dismissible or persistent.

Gesture Navigation

System-level navigation using swipe gestures instead of on-screen buttons. iOS uses edge swipes for back and home; Android 10+ offers a fully gestural navigation mode.

Breadcrumb Navigation

A trail showing the user's path through hierarchical content (e.g., Home > Category > Item). Less common in mobile than web, but useful in content-heavy or settings screens.

Segmented Control

A horizontal bar of two or more segments that act as mutually exclusive tabs within a single screen. Used for filtering content or switching views without full navigation.

Nested Navigation

Multiple navigation stacks or navigators embedded within each other (e.g., tabs containing stacks). Common in React Navigation and SwiftUI NavigationSplitView patterns.

The building blocks of mobile interfaces. These reusable elements provide consistent interaction patterns across your app.

@Composable
fun HomeScreen() {
    val snackbarHostState = remember { SnackbarHostState() }
    val scope = rememberCoroutineScope()

    Scaffold(
        topBar = { TopAppBar(title = { Text("Home") }) },
        floatingActionButton = {
            FloatingActionButton(onClick = {
                scope.launch {
                    snackbarHostState.showSnackbar(
                        message = "Item added",
                        actionLabel = "Undo"
                    )
                }
            }) { Icon(Icons.Default.Add, "Add") }
        },
        snackbarHost = { SnackbarHost(snackbarHostState) }
    ) { padding ->
        LazyColumn(Modifier.padding(padding)) {
            items(50) { Text("Item #$it") }
        }
    }
}

App Bar / Navigation Bar

The horizontal bar at the top of a screen showing the title, back button, and action items. Called UINavigationBar on iOS and TopAppBar on Android (Material Design).

Floating Action Button (FAB)

A circular button floating above content, representing the primary action on a screen. A Material Design pattern (e.g., compose in email, add in lists). Typically positioned at the bottom-right.

Scaffold

A structural layout component (Flutter/Jetpack Compose) that provides slots for app bar, body, FAB, drawer, bottom bar, and snackbar. Establishes the basic visual structure of a screen.

Pull-to-Refresh

A gesture where pulling down on scrollable content triggers a data refresh. Indicated by a spinner or animation. Implemented via UIRefreshControl (iOS) or SwipeRefreshLayout (Android).

Snackbar / Toast

Brief messages shown at the bottom (Snackbar, Material) or center (Toast, Android) of the screen. Snackbars may include an action button; toasts are purely informational and auto-dismiss.

Skeleton Screen

Placeholder shapes (gray boxes, lines) mimicking the page layout shown while content loads. Provides better perceived performance than spinners by giving users a preview of the upcoming content.

Shimmer Effect

An animated gradient sweep over skeleton placeholders, creating a "loading" visual cue. Popularized by Facebook's content loading pattern. Signals that content is actively being fetched.

Carousel / Horizontal Scroll

A horizontally scrollable set of cards or images. Used for featured content, onboarding, or galleries. Requires careful handling of paging, snapping, and accessibility.

Action Sheet

An iOS-style panel sliding up from the bottom presenting a set of actions related to the current context. Similar to a bottom sheet but specifically for action choices.

Chip

A compact UI element representing an input, attribute, or action (e.g., filter tags, contact names). Can be selectable, deletable, or actionable. Part of Material Design component library.

Badge

A small indicator (often a red circle with a number) overlaid on an icon or element to signal unread items, notifications, or status. Used on tab bar icons, app icons, and list items.

Stepper

A UI control for incrementing or decrementing a numeric value with +/- buttons. Common in e-commerce (quantity), settings (font size), and forms.

Switch / Toggle

A two-state control (on/off) used for binary settings. Provides immediate visual feedback. Called UISwitch on iOS and Switch/SwitchCompat on Android.

Date/Time Picker

A specialized input for selecting dates, times, or both. Platform-specific implementations include iOS wheel pickers and Material Design calendar/clock pickers.

Search Bar

A text input field for searching content within an app. Often includes suggestions, recent searches, and voice input. UISearchController (iOS) or SearchView (Android).

Layout systems determine how UI elements are sized and positioned. Understanding these concepts is essential for building responsive, adaptive interfaces.

class ResponsiveLayout extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return LayoutBuilder(
      builder: (context, constraints) {
        if (constraints.maxWidth > 900) {
          // Desktop: side-by-side
          return Row(children: [
            Expanded(flex: 1, child: Sidebar()),
            Expanded(flex: 3, child: ContentArea()),
          ]);
        } else if (constraints.maxWidth > 600) {
          // Tablet: narrower sidebar
          return Row(children: [
            SizedBox(width: 200, child: Sidebar()),
            Expanded(child: ContentArea()),
          ]);
        }
        // Phone: stacked
        return Column(children: [ContentArea()]);
      },
    );
  }
}

Responsive Design

An approach where the UI fluidly adapts to different screen sizes using flexible grids, relative units, and breakpoints. Content reflows rather than being redesigned for each screen size.

Adaptive Design

An approach that provides distinct layouts for specific screen sizes or device types rather than fluid reflow. The app detects the device class and serves the appropriate layout.

Auto Layout (iOS)

Apple's constraint-based layout system where UI elements are positioned by defining relationships (constraints) between them. Handles rotation, dynamic type, and varying screen sizes automatically.

ConstraintLayout (Android)

Android's flexible layout manager that positions child views using constraints relative to siblings or the parent. Enables flat view hierarchies and complex responsive layouts without nesting.

Flexbox

A one-dimensional layout model that distributes space among items in a container. Used in React Native and CSS. Defines how items grow, shrink, and align along a main axis and cross axis.

Grid Layout

A two-dimensional layout system that organizes elements into rows and columns. Used in CSS Grid, LazyVerticalGrid (Compose), and UICollectionView compositional layouts.

Material Design

Google's design system providing guidelines, components, and patterns for Android and cross-platform apps. Material 3 (Material You) introduces dynamic color theming and updated components.

Human Interface Guidelines (HIG)

Apple's comprehensive design guidelines for iOS, iPadOS, macOS, watchOS, and visionOS. Covers navigation, typography, iconography, accessibility, and platform-specific patterns.

Design Tokens

Named entities storing visual design attributes (colors, spacing, typography, shadows) as platform-agnostic values. Enable consistent theming across platforms and design-to-code workflows.

Dark Mode

An alternate color scheme using dark backgrounds and light text. Reduces eye strain in low light and saves battery on OLED screens. Must be supported system-wide and in-app.

Dynamic Color / Material You

Android 12+ feature that generates a personalized color palette from the user's wallpaper. Apps using Material 3 can adopt these dynamic colors for a cohesive system-wide look.

Safe Area Insets

Padding values representing areas of the screen obscured by hardware (notches, home indicators, status bars). APIs provide these insets so content remains fully visible and interactive.

Concepts, frameworks, and tools specific to Apple's ecosystem including iOS, iPadOS, watchOS, and visionOS development.

import SwiftUI
import SwiftData

@Model
class Task {
    var title: String
    var isComplete: Bool = false
    var createdAt: Date = .now

    init(title: String) { self.title = title }
}

struct TaskListView: View {
    @Query(sort: Task.createdAt, order: .reverse)
    private var tasks: [Task]

    @Environment(.modelContext) private var context

    var body: some View {
        List(tasks) { task in
            HStack {
                Text(task.title)
                Spacer()
                Image(systemName: task.isComplete
                    ? "checkmark.circle.fill" : "circle")
            }
        }
        .toolbar {
            Button("Add") {
                context.insert(Task(title: "New Task"))
            }
        }
    }
}

UIKit

Apple's imperative, event-driven UI framework for iOS. Uses view controllers, storyboards, and Auto Layout. Mature and feature-complete, still used for complex custom interfaces.

SwiftUI

Apple's declarative UI framework (2019+). Build interfaces using Swift code with automatic state management, previews, and cross-Apple-platform support. Increasingly the default for new iOS projects.

Xcode

Apple's integrated development environment (IDE) for building apps across all Apple platforms. Includes Interface Builder, Instruments profiler, Simulator, and the Swift/Objective-C compiler toolchain.

TestFlight

Apple's beta testing platform. Distribute pre-release builds to up to 10,000 external testers. Provides crash reports, feedback, and automatic update delivery.

Keychain

iOS's secure, encrypted storage for sensitive data (passwords, tokens, certificates). Data persists across app reinstalls and can be shared between apps via Keychain Access Groups.

Core Data

Apple's object graph and persistence framework. Provides data modeling, lazy loading, undo support, and iCloud sync (via NSPersistentCloudKitContainer). More than a database—it's an object lifecycle manager.

SwiftData

Apple's modern persistence framework (2023+), replacing Core Data's complexity with Swift macros (@Model, @Query). Uses the same underlying SQLite engine with a vastly simplified API.

Combine

Apple's reactive programming framework for processing asynchronous events over time. Provides publishers, subscribers, and operators for composing event-driven data pipelines.

App Clips

Lightweight portions of an iOS app (<15 MB) that launch instantly via NFC tags, QR codes, or App Clip links. Enable quick tasks without downloading the full app.

StoreKit 2

Apple's modernized in-app purchase framework using Swift concurrency (async/await). Handles subscriptions, consumables, and non-consumables with server-side receipt verification.

WidgetKit

Framework for building Home Screen, Lock Screen, and StandBy widgets on iOS. Widgets use SwiftUI and a timeline-based refresh mechanism, not live views.

Live Activities

Real-time, glanceable UI on the Lock Screen and Dynamic Island showing ongoing events (sports scores, deliveries, timers). Updated via push notifications or ActivityKit.

Provisioning Profile

A file linking an app ID, development certificates, and device UDIDs, enabling code to run on specific devices. Required for development, ad hoc, and enterprise distribution.

Info.plist

A property list file containing app configuration metadata: bundle ID, required permissions, supported orientations, URL schemes, and more. Read by the system at install and launch time.

Key concepts, components, and tools in the Android ecosystem including Jetpack libraries, Kotlin, and Google Play services.

// Entity
@Entity(tableName = "tasks")
data class Task(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val title: String,
    val isComplete: Boolean = false
)

// DAO
@Dao
interface TaskDao {
    @Query("SELECT * FROM tasks ORDER BY id DESC")
    fun getAll(): Flow<List<Task>>

    @Insert
    suspend fun insert(task: Task)
}

// ViewModel
@HiltViewModel
class TaskViewModel @Inject constructor(
    private val dao: TaskDao
) : ViewModel() {
    val tasks = dao.getAll()
        .stateIn(viewModelScope, SharingStarted.Lazily, emptyList())

    fun addTask(title: String) = viewModelScope.launch {
        dao.insert(Task(title = title))
    }
}

Activity

A single, focused screen in an Android app. Activities manage their own lifecycle (created, started, resumed, paused, stopped, destroyed) and serve as entry points for user interaction.

Fragment

A reusable UI component within an Activity, with its own lifecycle. Fragments enable modular screen design, multi-pane layouts, and navigation component integration.

Jetpack Compose

Android's modern declarative UI toolkit built in Kotlin. Replaces XML layouts with composable functions, offering reactive state management, theming, and animation with less boilerplate.

Room Database

A Jetpack persistence library providing an abstraction layer over SQLite. Uses annotations (@Entity, @Dao, @Database) to generate boilerplate code for type-safe database access.

ViewModel

A Jetpack architecture component that stores and manages UI-related data, surviving configuration changes (e.g., screen rotation). Scoped to an Activity or Fragment lifecycle.

Intent

A messaging object for requesting an action from another component. Explicit intents target specific components; implicit intents declare an action and let the system find suitable handlers.

Broadcast Receiver

A component that listens for and responds to system-wide broadcast announcements (battery low, network change, boot completed). Can be registered in the manifest or dynamically at runtime.

Content Provider

A component that manages shared app data (contacts, media, files) via a structured interface. Other apps access data through ContentResolver using URIs, enabling secure data sharing.

Service

A component that performs long-running operations in the background without a UI. Foreground services show a notification; WorkManager is preferred for deferrable background tasks.

WorkManager

A Jetpack library for scheduling deferrable, guaranteed background work (sync, uploads, cleanup). Respects system constraints (network, battery) and survives app restarts and device reboots.

Gradle

Android's build automation tool. Manages dependencies, build variants (debug/release), product flavors, code signing, and the entire compilation pipeline via build.gradle(.kts) scripts.

AndroidManifest.xml

The app's declaration file specifying package name, components (activities, services, receivers), permissions, hardware requirements, and minimum SDK version. Required for every Android app.

Hilt

A dependency injection library built on top of Dagger, designed specifically for Android. Provides standard component scopes (Activity, Fragment, ViewModel) with annotation-based configuration.

Jetpack Navigation

A framework for implementing navigation across fragments, activities, and composables. Uses a navigation graph (XML or Kotlin DSL) with built-in support for deep links and safe args.

Frameworks and tools that enable building mobile apps for multiple platforms from a single codebase, balancing development speed with native capabilities.

class CounterPage extends StatefulWidget {
  const CounterPage({super.key});

  @override
  State<CounterPage> createState() => _CounterPageState();
}

class _CounterPageState extends State<CounterPage> {
  int _count = 0;

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Counter')),
      body: Center(
        child: Text(
          '$_count',
          style: Theme.of(context).textTheme.displayLarge,
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => setState(() => _count++),
        child: const Icon(Icons.add),
      ),
    );
  }
}

React Native

Meta's framework for building native mobile apps using React and JavaScript/TypeScript. Renders actual native UI components (not WebViews). The New Architecture (Fabric, TurboModules) improves performance.

Flutter

Google's UI toolkit for building natively compiled apps from a single Dart codebase. Uses its own Skia/Impeller rendering engine for pixel-perfect control across iOS, Android, web, and desktop.

Kotlin Multiplatform (KMP)

JetBrains' technology for sharing Kotlin business logic across Android, iOS, web, and server while using native UI on each platform. Endorsed by Google as the recommended approach for shared mobile logic.

Expo

A platform built around React Native that simplifies development with managed workflows, over-the-air updates (EAS Update), cloud builds (EAS Build), and a curated module ecosystem.

Capacitor

Ionic's cross-platform runtime that wraps web apps in a native container. Provides access to native APIs via plugins. Successor to Apache Cordova with a modern plugin architecture.

.NET MAUI

Microsoft's framework (successor to Xamarin.Forms) for building native apps using C# and .NET. Single project targets Android, iOS, macOS, and Windows with shared UI and logic.

Bridge (React Native)

The communication layer between JavaScript and native code in React Native's classic architecture. Serializes data as JSON for cross-boundary calls. Being replaced by JSI (JavaScript Interface) in the New Architecture.

JSI (JavaScript Interface)

A C++ API in React Native's New Architecture enabling synchronous, direct communication between JS and native code without JSON serialization. Powers Fabric renderer and TurboModules.

Dart

The programming language used by Flutter. Features ahead-of-time (AOT) compilation for fast startup, JIT compilation for hot reload during development, null safety, and async/await support.

Hot Reload

A development feature that injects code changes into a running app without losing state. Flutter and React Native both support hot reload, dramatically accelerating development iteration.

Platform Channel

Flutter's mechanism for communicating between Dart code and platform-specific native code (Kotlin/Java for Android, Swift/ObjC for iOS). Uses message passing with MethodChannel, EventChannel, or BasicMessageChannel.

Hermes

Meta's JavaScript engine optimized for React Native. Features bytecode precompilation for faster startup, reduced memory usage, and smaller app size compared to JavaScriptCore.

Fabric (React Native)

React Native's new rendering system enabling synchronous communication with the host platform, concurrent rendering support, and better integration with platform-specific features.

Understanding how mobile apps transition between states is critical for managing resources, preserving user data, and delivering seamless experiences.

@main
struct MyApp: App {
    @Environment(.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { oldPhase, newPhase in
            switch newPhase {
            case .active:
                print("App is active — resume tasks")
            case .inactive:
                print("App inactive — pause timers")
            case .background:
                print("App backgrounded — save state")
                saveAppState()
            @unknown default:
                break
            }
        }
    }

    private func saveAppState() {
        UserDefaults.standard.set(Date(), forKey: "lastBackground")
    }
}

Cold Start

Launching an app from scratch when it's not in memory. The slowest startup type: the system creates the process, initializes the runtime, and loads the app. Optimize by deferring non-essential work.

Warm Start

Relaunching an app whose process is still in memory but the activity/UI was destroyed. Faster than cold start since the process and some objects are already initialized.

Hot Start

Bringing a backgrounded app to the foreground. The fastest resume—the app's activity is still in memory and only needs to redraw. No initialization or data reloading required.

Foreground

The app state where the app is visible, interactive, and receiving user input. The app has the highest priority for system resources when in the foreground.

Background

The app state where the app is not visible but may still execute limited tasks (audio playback, location tracking, data sync). Heavily restricted on both iOS and Android to preserve battery.

Suspended

An iOS app state where the app is in memory but not executing code. The system may terminate suspended apps without notice to reclaim memory. No background execution occurs in this state.

App Not Running

The state before any launch or after the system/user terminates the app. No process exists in memory. Next launch will be a cold start.

State Restoration

The process of saving and restoring an app's UI state across termination and relaunch. Ensures users return to exactly where they left off, even if the system killed the app.

Process Death

When the OS terminates an app's process (usually while backgrounded) to reclaim memory. Apps must save critical state to persist through process death and restore it on relaunch.

Lifecycle Observer

An API for monitoring app/component lifecycle events. Android offers ProcessLifecycleOwner (app-level) and LifecycleObserver (component-level); iOS uses UIApplicationDelegate and SceneDelegate methods.

Scene Delegate (iOS)

An iOS 13+ API for managing app UI lifecycle per window/scene. Supports multi-window on iPad and handles scene connection, disconnection, foreground, and background transitions.

Background Modes

Specific capabilities declared in the app manifest/Info.plist allowing limited background execution: audio, location, VoIP, Bluetooth, fetch, remote notifications, and processing tasks.

How mobile apps persist data locally on the device, from simple key-value pairs to full relational databases and cloud-synced solutions.

// OLD: SharedPreferences (synchronous, not type-safe)
val prefs = context.getSharedPreferences("app", Context.MODE_PRIVATE)
prefs.edit().putString("theme", "dark").apply()
val theme = prefs.getString("theme", "light") // nullable

// NEW: DataStore (async, type-safe, Flow-based)
val Context.dataStore by preferencesDataStore(name = "settings")

object PrefsKeys {
    val THEME = stringPreferencesKey("theme")
}

// Write
suspend fun saveTheme(context: Context, theme: String) {
    context.dataStore.edit { prefs ->
        prefs[PrefsKeys.THEME] = theme
    }
}

// Read (returns Flow)
fun getTheme(context: Context): Flow<String> =
    context.dataStore.data.map { prefs ->
        prefs[PrefsKeys.THEME] ?: "light"
    }

UserDefaults (iOS)

A simple key-value store for small amounts of user preferences and settings. Backed by a plist file. Not suitable for large datasets or sensitive data (use Keychain instead).

SharedPreferences (Android)

Android's key-value storage for primitive data types (strings, ints, booleans). Stored as XML files. DataStore (Preferences or Proto) is the modern, coroutines-based replacement.

SQLite

A lightweight, serverless, embedded relational database engine. The default local database on both iOS and Android. Accessed directly or via abstractions like Room (Android) or GRDB (iOS).

Realm

A mobile-first object database that stores data as native objects rather than rows. Features zero-copy architecture, live objects, reactive queries, and built-in sync capabilities.

DataStore (Android)

A Jetpack library replacing SharedPreferences. Offers Preferences DataStore (key-value) and Proto DataStore (typed schemas). Built on Kotlin coroutines and Flow for async, consistent data access.

File System Storage

Direct reading and writing of files to the device's file system. Used for documents, downloads, cached media, and app-specific data. Each app has a sandboxed directory.

CloudKit (Apple)

Apple's cloud backend service providing structured data storage, asset management, and user authentication. Enables seamless iCloud sync across Apple devices with public and private databases.

Firebase Realtime Database

Google's cloud-hosted NoSQL database that syncs data in real time across connected clients. Data is stored as JSON and accessible via SDKs. Ideal for chat, collaboration, and live dashboards.

Cloud Firestore

Google's scalable NoSQL document database for mobile and web. Supports rich queries, real-time listeners, offline persistence, and automatic multi-region replication. Firebase's recommended database.

MMKV

A high-performance key-value storage framework by Tencent using memory-mapped files. Significantly faster than SharedPreferences/UserDefaults. Popular in React Native via react-native-mmkv.

Encrypted Storage

Storing sensitive data using encryption (AES-256, EncryptedSharedPreferences on Android, Keychain on iOS). Essential for tokens, credentials, and personal data to meet security requirements.

How mobile apps communicate with servers, handle network conditions, and enable real-time data exchange.

struct User: Codable {
    let id: Int
    let name: String
    let email: String
}

func fetchUsers() async throws -> [User] {
    let url = URL(string: "https://api.example.com/users")!
    var request = URLRequest(url: url)
    request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")

    let (data, response) = try await URLSession.shared.data(for: request)

    guard let http = response as? HTTPURLResponse,
          (200...299).contains(http.statusCode) else {
        throw APIError.invalidResponse
    }

    return try JSONDecoder().decode([User].self, from: data)
}

REST API

An architectural style using HTTP methods (GET, POST, PUT, DELETE) on resource URLs. The most common API pattern for mobile apps. Stateless, cacheable, and well-tooled across platforms.

GraphQL

A query language for APIs where clients request exactly the data they need. Reduces over-fetching and under-fetching common with REST. Single endpoint serves all queries.

WebSocket

A protocol providing full-duplex communication over a single TCP connection. Enables real-time features like chat, live updates, and multiplayer. Lower overhead than HTTP polling.

gRPC

A high-performance RPC framework using Protocol Buffers for serialization. Supports streaming, strongly-typed contracts, and efficient binary encoding. Used in backend-to-backend and mobile-to-backend communication.

SSL/TLS

Cryptographic protocols securing data in transit between client and server. All modern mobile APIs require HTTPS. TLS 1.3 is the current standard with faster handshakes.

Certificate Pinning

A security technique that restricts which certificates the app trusts for a specific server. Prevents man-in-the-middle attacks even if a CA is compromised. Can be hash-based or certificate-based.

Offline-First

An architecture where the app stores data locally and syncs with the server when connectivity is available. Ensures full functionality without network access. Requires conflict resolution strategies.

Caching Strategy

Techniques for storing API responses locally to reduce network requests and improve performance. Common strategies: cache-first, network-first, stale-while-revalidate, and cache-then-network.

Retry Logic / Exponential Backoff

Automatically retrying failed network requests with increasing delays (1s, 2s, 4s, 8s...) and optional jitter. Prevents overwhelming servers during outages and handles transient failures gracefully.

Server-Sent Events (SSE)

A standard for servers to push updates to clients over HTTP. Simpler than WebSocket (one-way), auto-reconnects, and works through HTTP/2. Ideal for news feeds, notifications, and status updates.

URLSession (iOS)

Apple's networking framework for HTTP/HTTPS requests. Supports data tasks, download tasks, upload tasks, background transfers, and WebSocket connections with built-in caching.

OkHttp (Android)

Square's HTTP client for Android and Java. Features connection pooling, transparent GZIP, response caching, interceptors, and WebSocket support. The foundation for Retrofit.

Retrofit

A type-safe HTTP client for Android by Square. Turns REST API interfaces into callable Kotlin/Java methods using annotations. Built on OkHttp with support for coroutines and RxJava.

Techniques and metrics for ensuring mobile apps run smoothly, use resources efficiently, and deliver responsive user experiences.

import React, { memo, useCallback, useState } from 'react';
import { FlatList, Text, Pressable, View } from 'react-native';

// Memoized row — only re-renders if props change
const TaskRow = memo(({ task, onToggle }) => (
  <Pressable onPress={() => onToggle(task.id)}>
    <Text>{task.done ? '✓' : '○'} {task.title}</Text>
  </Pressable>
));

export function TaskList() {
  const [tasks, setTasks] = useState(initialTasks);

  // Stable reference — won't cause child re-renders
  const handleToggle = useCallback((id) => {
    setTasks(prev =>
      prev.map(t => t.id === id ? { ...t, done: !t.done } : t)
    );
  }, []);

  return (
    <FlatList
      data={tasks}
      keyExtractor={t => t.id}
      renderItem={({ item }) => (
        <TaskRow task={item} onToggle={handleToggle} />
      )}
    />
  );
}

Frame Rate (FPS)

The number of frames rendered per second. Mobile apps target 60 FPS (16.67ms per frame) or 120 FPS on high-refresh displays. Dropped frames cause visible stuttering (jank).

Jank

Visible stuttering or hitching when the app fails to render a frame within the target time. Caused by heavy main-thread work, excessive layout passes, or garbage collection pauses.

Lazy Loading

Deferring the loading of resources until they're actually needed. Applied to images, list items, modules, and data. Reduces initial load time and memory usage. LazyColumn (Compose), UITableView (iOS).

Tree Shaking

A build-time optimization that removes unused code (dead code elimination) from the final bundle. Reduces app size. Common in Dart (Flutter), JavaScript (React Native), and Kotlin.

Code Splitting

Breaking the app bundle into smaller chunks loaded on demand. In React Native, achieved via lazy imports and dynamic require(). Reduces initial load time for large apps.

Image Optimization

Techniques for reducing image payload: compression, responsive sizing, WebP/AVIF formats, lazy loading, caching, and progressive loading. Images are often the largest assets in mobile apps.

Memory Leak

When allocated memory is never released, causing the app's memory footprint to grow until the OS kills it. Common causes: retained references, uncancelled observers, and closure capture cycles.

Profiling

Analyzing app performance to identify bottlenecks. Tools: Xcode Instruments (iOS), Android Studio Profiler (CPU, memory, network), Flutter DevTools, and React Native Flipper.

App Size Optimization

Reducing the download and install size of an app. Techniques: asset compression, code shrinking (R8/ProGuard), app bundles (AAB), on-demand resources, and removing unused dependencies.

ProGuard / R8

Code shrinking, obfuscation, and optimization tools for Android. R8 (the modern replacement for ProGuard) removes unused code, renames identifiers, and optimizes bytecode in release builds.

Render Optimization

Minimizing unnecessary UI re-renders. React Native uses React.memo, useMemo, useCallback. Flutter uses const constructors, RepaintBoundary, and keys. Compose uses stable types and remember.

Battery Optimization

Reducing power consumption by limiting background work, batching network requests, using efficient location strategies, and leveraging system scheduling APIs (WorkManager, BGTaskScheduler).

ANR (Application Not Responding)

An Android dialog shown when the main thread is blocked for 5+ seconds. Caused by long-running operations on the UI thread. Monitored via Google Play Vitals. Always move heavy work to background threads.

The pipeline from source code to a published app on the App Store or Google Play, including build systems, code signing, and release management.

android {
    compileSdk = 35
    defaultConfig {
        applicationId = "com.example.myapp"
        minSdk = 26
        targetSdk = 35
        versionCode = 12
        versionName = "2.1.0"
    }

    signingConfigs {
        create("release") {
            storeFile = file("keystore.jks")
            storePassword = System.getenv("KEYSTORE_PASS")
            keyAlias = "release"
            keyPassword = System.getenv("KEY_PASS")
        }
    }

    buildTypes {
        release {
            isMinifyEnabled = true
            proguardFiles(getDefaultProguardFile("proguard-android.txt"))
            signingConfig = signingConfigs.getByName("release")
        }
    }

    flavorDimensions += "env"
    productFlavors {
        create("dev") { applicationIdSuffix = ".dev" }
        create("prod") { /* default */ }
    }
}

APK (Android Package Kit)

The legacy Android app package format containing compiled code, resources, and manifest. APKs bundle everything for all device configurations, resulting in larger downloads.

AAB (Android App Bundle)

The modern Android publishing format. Google Play generates optimized APKs per device configuration (screen density, CPU architecture, language), reducing download size by ~15% on average.

IPA (iOS App Store Package)

The package format for iOS apps, containing the compiled binary, resources, and provisioning profile. Created by archiving in Xcode and distributed via App Store Connect or ad hoc.

Code Signing

Cryptographically signing app binaries to verify the developer's identity and ensure the code hasn't been tampered with. Required for both iOS (certificates) and Android (keystores).

Keystore (Android)

A file containing cryptographic keys used to sign Android apps. The upload key signs bundles for Google Play; the app signing key (managed by Play) signs the final APKs delivered to users.

App Store Connect

Apple's portal for managing app submissions, metadata, pricing, TestFlight, analytics, and App Store presence. Where developers submit builds for review and manage app lifecycle.

Google Play Console

Google's portal for publishing and managing Android apps. Handles app listings, release tracks (internal, closed, open, production), pricing, statistics, and policy compliance.

OTA Updates (Over-the-Air)

Delivering code updates to the app without requiring a full app store release. React Native (CodePush, EAS Update) and Capacitor support JS bundle updates; native code changes require store releases.

CI/CD for Mobile

Continuous Integration/Continuous Delivery pipelines that automate building, testing, and deploying mobile apps. Tools: Fastlane, GitHub Actions, Bitrise, Codemagic, App Center, and EAS Build.

Fastlane

An open-source tool automating mobile app deployment tasks: screenshots, code signing, beta distribution, and App Store/Play Store submissions. Uses Ruby-based Fastfiles for configuration.

Build Variants / Flavors

Different configurations of the same app (debug, staging, production) with varying API endpoints, features, or branding. Android uses build types + product flavors; iOS uses schemes and configurations.

App Thinning (iOS)

Apple's suite of optimizations (slicing, bitcode, on-demand resources) that deliver only the resources needed for a specific device, reducing download and install size.

How mobile apps request access to device capabilities and protect user data through authentication, encryption, and secure coding practices.

import LocalAuthentication

func authenticateWithBiometrics() async -> Bool {
    let context = LAContext()
    var error: NSError?

    guard context.canEvaluatePolicy(
        .deviceOwnerAuthenticationWithBiometrics,
        error: &error
    ) else {
        print("Biometrics unavailable: \(error?.localizedDescription ?? "")")
        return false
    }

    do {
        let success = try await context.evaluatePolicy(
            .deviceOwnerAuthenticationWithBiometrics,
            localizedReason: "Authenticate to access your account"
        )
        return success
    } catch {
        print("Auth failed: \(error.localizedDescription)")
        return false
    }
}

Runtime Permissions

Permissions requested while the app is running, not at install time. Android 6.0+ and iOS require runtime prompts for sensitive capabilities (camera, location, contacts, microphone).

OAuth 2.0

An authorization framework enabling third-party apps to access user resources without exposing credentials. Uses access tokens and refresh tokens. The foundation for "Sign in with Google/Apple/Facebook."

PKCE (Proof Key for Code Exchange)

An OAuth 2.0 extension preventing authorization code interception attacks in public clients (mobile apps). Uses a code_verifier and code_challenge pair. Required for mobile OAuth implementations.

Biometric Authentication

Using fingerprint (Touch ID, Android BiometricPrompt), face recognition (Face ID), or iris scanning to authenticate users. Provides convenient security without password entry.

App Transport Security (ATS)

An iOS security feature requiring all HTTP connections to use HTTPS with modern TLS configurations. Exceptions must be explicitly declared in Info.plist and justified during App Store review.

Network Security Config (Android)

An XML configuration file defining network security policies: trusted CAs, certificate pinning, cleartext traffic permissions, and debug overrides. Applied globally or per domain.

App Sandbox

An OS-level security model isolating each app's files, preferences, and network connections from other apps. Limits the damage from security vulnerabilities. Default on both iOS and Android.

Jailbreak / Root Detection

Techniques for detecting if a device has been jailbroken (iOS) or rooted (Android), which bypasses OS security restrictions. Financial and security-sensitive apps may refuse to run on compromised devices.

Data Encryption at Rest

Encrypting stored data so it's unreadable without the decryption key. iOS enables full-disk encryption by default; Android offers file-based encryption (FBE) with per-user and per-device keys.

Secure Enclave / TEE

A hardware-isolated processor for cryptographic operations. Apple's Secure Enclave stores biometric data and encryption keys; Android's Trusted Execution Environment (TEE) provides similar isolation.

Sign in with Apple

Apple's privacy-focused authentication service. Required for iOS apps offering third-party social login. Provides a unique, relay email address to protect user privacy.

JWT (JSON Web Token)

A compact, URL-safe token format for transmitting claims between parties. Commonly used for mobile API authentication. Contains header, payload, and signature sections encoded as Base64.

Tools and approaches for verifying mobile app correctness, from unit tests to end-to-end testing on real devices and simulators.

@RunWith(AndroidJUnit4::class)
class LoginScreenTest {

    @get:Rule
    val activityRule = ActivityScenarioRule(LoginActivity::class.java)

    @Test
    fun validLogin_navigatesToHome() {
        // Type email
        onView(withId(R.id.emailInput))
            .perform(typeText("user@example.com"), closeSoftKeyboard())

        // Type password
        onView(withId(R.id.passwordInput))
            .perform(typeText("secret123"), closeSoftKeyboard())

        // Click login button
        onView(withId(R.id.loginButton))
            .perform(click())

        // Verify navigation to home
        onView(withId(R.id.homeTitle))
            .check(matches(isDisplayed()))
            .check(matches(withText("Welcome")))
    }

    @Test
    fun emptyEmail_showsError() {
        onView(withId(R.id.loginButton)).perform(click())
        onView(withId(R.id.emailError))
            .check(matches(withText("Email is required")))
    }
}

XCTest

Apple's testing framework for unit tests, performance tests, and UI tests in Swift/Objective-C. Integrated into Xcode with test navigator, code coverage, and CI support.

Espresso

Google's UI testing framework for Android. Runs on real devices/emulators with automatic synchronization of UI events. Provides a fluent API for writing reliable, concise UI tests.

Detox

A gray-box end-to-end testing framework for React Native by Wix. Runs on real devices/simulators with automatic synchronization, replacing flaky wait-based approaches.

Maestro

A modern mobile UI testing framework using YAML-based test definitions. Platform-agnostic (iOS, Android, React Native, Flutter), easy to learn, with built-in waiting and tolerance for UI variations.

Appium

An open-source cross-platform test automation framework using the WebDriver protocol. Supports native, hybrid, and mobile web apps across iOS, Android, and Windows.

Jest

A JavaScript testing framework by Meta, commonly used for React Native unit and snapshot testing. Features zero-config setup, mocking, code coverage, and parallel test execution.

UI Automator

Android's cross-app UI testing framework for system-level interactions (notifications, settings, multi-app flows). Works across application boundaries, unlike Espresso which is in-app only.

Snapshot Testing

Capturing a rendered UI component as an image or serialized output and comparing it against a stored reference. Detects unintended visual changes. Used in Jest, iOSSnapshotTestCase, and Paparazzi.

Device Farm

Cloud-hosted real devices for remote testing. Services: AWS Device Farm, Firebase Test Lab, BrowserStack, Sauce Labs, and LambdaTest. Enables testing across hundreds of device/OS combinations.

Integration Testing

Testing the interaction between multiple components or layers (UI + API, database + business logic). Verifies that connected parts work correctly together, broader than unit tests.

Mock / Stub

Test doubles that simulate dependencies. Mocks verify interactions (was this method called?); stubs provide predetermined responses. Essential for isolating units under test from external services.

Making mobile apps usable by everyone, including people with visual, auditory, motor, and cognitive disabilities. Both a moral imperative and often a legal requirement.

struct ProfileCard: View {
    let user: User

    var body: some View {
        HStack(spacing: 12) {
            Image(user.avatar)
                .resizable()
                .frame(width: 48, height: 48)
                .clipShape(Circle())
                .accessibilityLabel("Profile photo of \(user.name)")

            VStack(alignment: .leading) {
                Text(user.name)
                    .font(.headline)
                    .accessibilityAddTraits(.isHeader)

                Text(user.role)
                    .font(.subheadline)
                    .foregroundStyle(.secondary)
            }

            Spacer()

            Button("Edit") { showEditor = true }
                .accessibilityLabel("Edit profile")
                .accessibilityHint("Opens the profile editor")
        }
        .accessibilityElement(children: .combine)
    }
}

VoiceOver (iOS)

Apple's built-in screen reader that speaks UI elements aloud and enables gesture-based navigation for blind and low-vision users. Apps must provide proper accessibility labels and traits.

TalkBack (Android)

Android's screen reader providing spoken feedback and gesture navigation for visually impaired users. Apps must set contentDescription on images and ensure logical focus order.

Dynamic Type (iOS)

An iOS feature letting users choose their preferred text size system-wide. Apps should use semantic font styles (headline, body, caption) and test at all size categories, including accessibility sizes.

Accessibility Labels

Text descriptions attached to UI elements that screen readers announce. Should describe the element's purpose, not its visual appearance (e.g., "Delete message" not "Red trash icon").

Accessibility Traits / Roles

Metadata describing an element's behavior (button, link, header, image, adjustable). Helps assistive technologies communicate appropriate interaction patterns to users.

Contrast Ratio

The luminance ratio between foreground text and background color. WCAG requires 4.5:1 for normal text and 3:1 for large text. Higher contrast improves readability for everyone.

Focus Management

Controlling which element receives keyboard/screen reader focus and in what order. Critical for modals, dynamic content updates, and custom navigation patterns.

Reduce Motion

A system accessibility setting that minimizes animations and motion effects. Apps should check UIAccessibility.isReduceMotionEnabled (iOS) or ANIMATOR_DURATION_SCALE (Android) and provide alternatives.

Haptic Feedback

Vibration patterns providing tactile responses to user interactions. Used for confirmations, errors, and navigation. iOS uses UIFeedbackGenerator; Android uses HapticFeedbackConstants.

Semantic HTML / Semantic UI

Using proper element types that convey meaning (headings, buttons, lists) rather than styled generic containers. Ensures assistive technologies can correctly interpret and navigate the interface.

Switch Control

An accessibility feature enabling device operation via external switches, head movements, or sounds for users with severe motor disabilities. Apps must ensure all features are reachable via sequential focus.

Tools and metrics for understanding user behavior, monitoring app health, tracking performance, and making data-driven product decisions.

class AnalyticsManager(private val firebaseAnalytics: FirebaseAnalytics) {

    fun trackScreenView(screenName: String) {
        firebaseAnalytics.logEvent(FirebaseAnalytics.Event.SCREEN_VIEW) {
            param(FirebaseAnalytics.Param.SCREEN_NAME, screenName)
            param(FirebaseAnalytics.Param.SCREEN_CLASS, screenName)
        }
    }

    fun trackSignUp(method: String) {
        firebaseAnalytics.logEvent(FirebaseAnalytics.Event.SIGN_UP) {
            param(FirebaseAnalytics.Param.METHOD, method)
        }
    }

    fun trackPurchase(itemId: String, price: Double) {
        firebaseAnalytics.logEvent(FirebaseAnalytics.Event.PURCHASE) {
            param(FirebaseAnalytics.Param.ITEM_ID, itemId)
            param(FirebaseAnalytics.Param.VALUE, price)
            param(FirebaseAnalytics.Param.CURRENCY, "USD")
        }
    }

    fun setUserTier(tier: String) {
        firebaseAnalytics.setUserProperty("subscription_tier", tier)
    }
}

Firebase Crashlytics

Google's real-time crash reporting tool. Automatically captures crashes and non-fatal errors with stack traces, device info, and breadcrumbs. Prioritizes issues by user impact.

Sentry

An open-source error monitoring platform supporting mobile (iOS, Android, React Native, Flutter). Provides stack traces, breadcrumbs, user context, performance monitoring, and release health tracking.

DAU / MAU

Daily Active Users / Monthly Active Users — key engagement metrics. DAU/MAU ratio (stickiness) indicates how frequently users return. Industry benchmarks vary by app category.

Funnel Analysis

Tracking users through a sequence of steps (e.g., signup flow: open > enter email > verify > complete) to identify where users drop off. Critical for optimizing conversion rates.

Retention Rate

The percentage of users who return to the app after their first use. Typically measured at Day 1, Day 7, and Day 30. A key metric for evaluating product-market fit and engagement.

Session Duration

The length of time a user spends actively using the app in a single session. Varies by app type: social media (long), utilities (short). Used alongside session frequency for engagement analysis.

Event Tracking

Recording specific user actions (button taps, purchases, screen views) for analytics. Events have names and optional parameters. Implemented via Firebase Analytics, Mixpanel, Amplitude, or custom solutions.

Attribution

Identifying which marketing channel or campaign led to an app install or conversion. Platforms: AppsFlyer, Adjust, Branch, Singular. Challenged by privacy changes (ATT, SKAdNetwork).

ANR Rate / Crash Rate

The percentage of sessions or users experiencing ANRs (Android) or crashes. Google Play Vitals and App Store Connect provide these metrics. High rates lead to reduced store visibility.

Real User Monitoring (RUM)

Collecting performance data from actual user sessions in production (app startup time, screen load time, network latency). Provides real-world performance insights versus synthetic testing.

A/B Testing

Comparing two variants of a feature, design, or copy to determine which performs better. Firebase Remote Config + A/B Testing, LaunchDarkly, and Optimizely are common mobile A/B testing tools.

The latest trends, technologies, and paradigm shifts shaping mobile development in 2024–2026, from on-device AI to spatial computing.

import Vision
import CoreML

func classifyImage(_ image: CGImage) async throws -> String {
    // Load a compiled Core ML model
    let config = MLModelConfiguration()
    config.computeUnits = .cpuAndNeuralEngine
    let model = try await MobileNetV2(configuration: config)

    // Create Vision request with Core ML model
    let vnModel = try VNCoreMLModel(for: model.model)

    return try await withCheckedThrowingContinuation { cont in
        let request = VNCoreMLRequest(model: vnModel) { req, err in
            if let err { cont.resume(throwing: err); return }
            guard let results = req.results as? [VNClassificationObservation],
                  let top = results.first else {
                cont.resume(returning: "Unknown")
                return
            }
            cont.resume(returning: "\(top.identifier) (\(Int(top.confidence * 100))%)")
        }
        let handler = VNImageRequestHandler(cgImage: image)
        try? handler.perform([request])
    }
}

On-Device AI / Core ML

Running machine learning models directly on the device for real-time inference without network roundtrips. Apple's Core ML, Google's ML Kit, and TensorFlow Lite enable vision, NLP, and speech processing locally.

Kotlin Multiplatform Expansion

KMP maturing beyond shared business logic to include shared UI experiments (Compose Multiplatform). Major companies (Netflix, VMware, Philips) adopting KMP for iOS/Android code sharing in production.

Material 3 Expressive

Google's evolution of Material Design emphasizing personalization, fluid motion, and expressive components. Introduced in 2025, bringing more customizable shape, color, and animation systems.

visionOS / Spatial Computing

Apple's platform for Vision Pro headset, enabling spatial apps that blend with the user's environment. Uses SwiftUI, RealityKit, and ARKit for immersive, volumetric experiences.

Declarative UI Convergence

The industry-wide shift toward declarative UI patterns: SwiftUI (Apple), Jetpack Compose (Android), Flutter (Dart), React Native. Imperative frameworks (UIKit, Android Views) are in maintenance mode.

Edge Computing for Mobile

Processing data closer to the user (edge servers, CDN compute) to reduce latency for mobile apps. Enables real-time AI inference, game streaming, and AR experiences without distant cloud roundtrips.

Super Apps

A single app platform integrating multiple services (messaging, payments, shopping, transport). Prominent in Asia (WeChat, Grab, Gojek). Built using mini-app architectures within a host app.

Privacy-First Architecture

Designing apps with privacy as a core principle. Includes on-device processing, differential privacy, minimal data collection, App Tracking Transparency (ATT), and privacy nutrition labels.

Passkeys

A passwordless authentication standard using WebAuthn/FIDO2. Cryptographic key pairs replace passwords, synced via iCloud Keychain or Google Password Manager. Phishing-resistant and cross-platform.

App Intents / Shortcuts

Frameworks for exposing app functionality to Siri, Shortcuts, Spotlight, and the Action Button. Apple's App Intents framework (2022+) simplifies integration with system intelligence features.

Progressive Web App (PWA)

Web applications providing app-like experiences: offline support, push notifications, home screen install. Built with web technologies (HTML, CSS, JS) and service workers. An alternative to native for certain use cases.

Micro-Frontends for Mobile

An architectural pattern where different teams own independent, deployable feature modules within a single app. Enables parallel development and independent release cycles in large organizations.

The operational side of mobile development: app store optimization, feature management, configuration, release strategies, and infrastructure tooling.

class FeatureFlagManager(
    private val remoteConfig: FirebaseRemoteConfig
) {
    init {
        // Set defaults + fetch interval
        remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)
        remoteConfig.setConfigSettingsAsync(
            remoteConfigSettings { minimumFetchIntervalInSeconds = 3600 }
        )
    }

    suspend fun fetchAndActivate(): Boolean {
        return remoteConfig.fetchAndActivate().await()
    }

    fun isFeatureEnabled(key: String): Boolean =
        remoteConfig.getBoolean(key)

    fun getMinAppVersion(): String =
        remoteConfig.getString("min_app_version")
}

// Usage in Composable
@Composable
fun CheckoutScreen(flags: FeatureFlagManager) {
    if (flags.isFeatureEnabled("new_checkout_flow")) {
        NewCheckoutUI()
    } else {
        LegacyCheckoutUI()
    }
}

ASO (App Store Optimization)

Optimizing app store listings (title, keywords, description, screenshots, ratings) to improve search ranking and conversion rate. The mobile equivalent of SEO for app discoverability.

Feature Flags

Boolean or multivariate toggles controlling feature availability without deploying new code. Enable gradual rollouts, A/B tests, and instant kill switches. Tools: LaunchDarkly, Firebase Remote Config, Unleash.

Remote Config

Server-controlled key-value pairs that change app behavior without an update. Used for feature flags, UI text, thresholds, and emergency toggles. Firebase Remote Config is the most popular solution.

Phased Rollout

Gradually releasing an app update to increasing percentages of users (1% > 5% > 20% > 50% > 100%). Both App Store and Google Play support phased releases to catch issues before full rollout.

Canary Release

Deploying a new version to a small subset of users first to detect issues before wider release. Named after canaries in coal mines. Combined with monitoring to auto-halt on anomaly detection.

Blue-Green Deployment

Maintaining two identical environments (blue = current, green = new). Traffic switches from blue to green once validated. In mobile, this concept applies to backend APIs serving mobile clients.

Crash Reporting

Automated collection of crash data (stack traces, device info, user actions) when the app terminates unexpectedly. Essential for prioritizing bugs. Tools: Crashlytics, Sentry, Bugsnag, Datadog.

App Review Guidelines

Rules set by Apple and Google that apps must comply with for store acceptance. Cover content, privacy, security, performance, design, and business model requirements. Rejection requires addressing cited violations.

Push Notification Service

Platform infrastructure for delivering messages to devices: APNs (Apple Push Notification Service) for iOS and FCM (Firebase Cloud Messaging) for Android. Requires server-side integration and device token management.

Deep Link Routing

Server-side or in-app logic that maps incoming deep link URLs to specific screens or actions. Libraries like Branch.io and Firebase Dynamic Links handle deferred deep links (working even through app install).

Mobile DevOps

The practice of applying DevOps principles (automation, CI/CD, monitoring, collaboration) specifically to mobile app development. Addresses unique mobile challenges: code signing, device fragmentation, store reviews.

Backend-Driven UI

An architecture where the server sends UI component definitions (layout, content, actions) that the app renders dynamically. Enables UI updates without app releases. Used by Airbnb, Lyft, and server-driven rendering frameworks.