Mobile Offline-First Development Cheat Sheet

Updated 2026-05-16

Next Topic: Mobile State Management Patterns Cheat Sheet

🧠Study flashcards on this topic103 cards · spaced repetition→

Mobile offline-first development is an architectural approach where local data storage and offline functionality take priority over network connectivity, ensuring apps remain fully functional regardless of internet availability. This paradigm has become critical as mobile users increasingly expect seamless experiences across spotty networks, airplane mode, and areas with poor connectivity. The key insight: apps should sync with servers only when beneficial, not when required — treating the network as an enhancement rather than a dependency, which fundamentally changes how you architect data flow, state management, and user interactions.

What This Cheat Sheet Covers

This topic spans 14 focused tables and 102 indexed concepts, 103 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Local Database SolutionsTable 2: Conflict Resolution StrategiesTable 3: Background SynchronizationTable 4: Network State ManagementTable 5: Caching StrategiesTable 6: Optimistic UI UpdatesTable 7: Data Synchronization ProtocolsTable 8: Queue-Based Action DispatchingTable 9: State Management for OfflineTable 10: Testing Offline ScenariosTable 11: Authentication and Security OfflineTable 12: Performance OptimizationTable 13: File and Binary Data HandlingTable 14: Advanced Patterns

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Local Database Solutions

The local database is the heart of any offline-first app — it becomes the single source of truth the UI reads from, with the network merely topping it up. The right pick depends on your platform and data shape: relational stores like SQLite, Room, and Core Data give you ACID transactions and queryable schemas, while NoSQL options like Realm, Hive, and Isar trade some structure for raw speed and a simpler object model. SQLCipher sits alongside them as the encryption layer when the data at rest is sensitive.

Database	Example	Description
SQLite	`sqlite3_open("app.db", &db);` `sqlite3_exec(db, "CREATE TABLE...", 0, 0, 0);`	• Embedded relational database with zero-configuration file-based storage • industry standard for mobile apps with ACID transactions and cross-platform support (Android, iOS, desktop).
Room (Android)	`@Entity data class User(…)` `@Dao interface UserDao { @Query("SELECT…") }` `@Database abstract class AppDatabase : RoomDatabase()`	• Android's SQLite abstraction layer with compile-time query verification, LiveData/Flow integration, and built-in migration support • serves as single source of truth in offline-first architecture
CoreData (iOS)	`let entity = NSEntityDescription.entity(…)` `let newUser = NSManagedObject(entity: entity, …)` `try context.save()`	• Apple's object graph and persistence framework with automated change tracking, undo/redo support, and iCloud synchronization • uses SQLite as default backing store
Realm	`class User: Object { @Persisted var name: String }` `let realm = try! Realm()` `try! realm.write { realm.add(user) }`	• Mobile-first NoSQL database with zero-copy architecture for instant reads, automatic object-relational mapping, and built-in encryption • supports iOS, Android, React Native with live objects that update automatically
Hive (Flutter)	`var box = await Hive.openBox('users');` `box.put('key', User(name: 'John'));` `var user = box.get('key');`	• Lightweight, pure Dart NoSQL database with blazing fast performance (no native dependencies) • uses binary format with lazy loading and supports custom type adapters for complex objects
Isar (Flutter)	`final isar = await Isar.open([UserSchema]);` `await isar.writeTxn(() async {` `await isar.users.put(user); });`	• High-performance Flutter database with ACID transactions, multi-isolate support, and full-text search • up to 10x faster than Hive with composite indexes and query optimization
WatermelonDB (React Native)	`const users = database.collections.get('users');` `await database.write(async () => {` `await users.create(user => { user.name = 'John' }); });`	• Reactive offline-first database built on SQLite with lazy loading, multi-threaded performance, and automatic sync • optimized for complex React Native apps with thousands of records
IndexedDB (Web/PWA)	`const request = indexedDB.open('AppDB', 1);` `const store = db.transaction('users', 'readwrite').objectStore('users');` `store.add({ id: 1, name: 'John' });`	• Browser-native asynchronous NoSQL database with indexes, transactions, and version management • storage limits vary (Chrome: ~60% disk, Safari mobile: ~50MB) with quota management required
PouchDB	`const db = new PouchDB('todos');` `await db.put({ _id: 'todo1', text: 'Buy milk' });` `db.sync('http://server/todos');`	• JavaScript database inspired by CouchDB with automatic sync to remote servers • uses IndexedDB in browsers, SQLite in Node.js, and handles conflict resolution via revision trees
SQLCipher	`sqlite3_key(db, "passphrase", 10);`	• 256-bit AES encryption extension for SQLite providing transparent full-database encryption • protects sensitive data at rest with minimal performance overhead (5-15% slower than plain SQLite).

Table 2: Conflict Resolution Strategies

The moment two devices edit the same record offline, you have a conflict — and how you settle it shapes whether users lose work or trust the app. These strategies span a spectrum from dead-simple to mathematically rigorous: last-write-wins is trivial but lossy, CRDTs and operational transformation guarantee convergence for collaborative editing, and manual resolution hands the decision back to the user when correctness matters more than convenience. Match the strategy to how costly a wrong merge would be.

Strategy	Example	Description
Last-Write-Wins (LWW)	`if (incomingTimestamp > localTimestamp) {` `applyUpdate(incoming); }`	• Simplest strategy where most recent timestamp wins • easy to implement but risks data loss when concurrent edits occur — suitable for non-critical fields like user preferences or UI state

The rest of this section is part of the full cheat sheet

Table 3: Background Synchronization

Syncing only when the app is open isn't enough — you want changes to flow while the user is doing something else entirely. Each platform exposes its own constrained mechanism for deferred work: Android leans on WorkManager for guaranteed, constraint-aware jobs that survive reboots, iOS gives you the tightly time-boxed BGTaskScheduler, and the web relies on Service Workers. Silent push notifications add a server-initiated nudge to sync the instant fresh data exists.

Mechanism	Example	Description
WorkManager (Android)	`val work = OneTimeWorkRequestBuilder<SyncWorker>()` `.setConstraints(Constraints(networkType = CONNECTED))` `.build();` `WorkManager.enqueue(work);`	• Android's recommended API for deferrable, guaranteed background work • survives app restarts and device reboots with built-in retry, backoff, and constraint-based execution (network, battery, storage).

The rest of this section is part of the full cheat sheet

Table 4: Network State Management

Knowing whether you're online — and how good that connection is — drives every sync decision the app makes. The platform APIs here (ConnectivityManager, NWPathMonitor, NetInfo) report not just up-or-down but connection type and cost, so you can defer a big upload off cellular. One gotcha runs through all of them: the OS reporting "connected" only means a network exists, not that the internet is reachable, which is why polling a known endpoint is sometimes the only honest answer.

Technique	Example	Description
ConnectivityManager (Android)	`val cm = getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager;` `cm.registerDefaultNetworkCallback(object : NetworkCallback() {` `override fun onAvailable(network: Network) {} });`	• Android API for monitoring network availability and type with lifecycle-aware callbacks • provides onAvailable(), onLost(), onCapabilitiesChanged() for real-time connectivity tracking

The rest of this section is part of the full cheat sheet

Table 1: Local Database Solutions

Database	Example	Description
SQLite	`sqlite3_open("app.db", &db);` `sqlite3_exec(db, "CREATE TABLE...", 0, 0, 0);`	• Embedded relational database with zero-configuration file-based storage • industry standard for mobile apps with ACID transactions and cross-platform support (Android, iOS, desktop).
Room (Android)	`@Entity data class User(…)` `@Dao interface UserDao { @Query("SELECT…") }` `@Database abstract class AppDatabase : RoomDatabase()`	• Android's SQLite abstraction layer with compile-time query verification, LiveData/Flow integration, and built-in migration support • serves as single source of truth in offline-first architecture
CoreData (iOS)	`let entity = NSEntityDescription.entity(…)` `let newUser = NSManagedObject(entity: entity, …)` `try context.save()`	• Apple's object graph and persistence framework with automated change tracking, undo/redo support, and iCloud synchronization • uses SQLite as default backing store
Realm	`class User: Object { @Persisted var name: String }` `let realm = try! Realm()` `try! realm.write { realm.add(user) }`	• Mobile-first NoSQL database with zero-copy architecture for instant reads, automatic object-relational mapping, and built-in encryption • supports iOS, Android, React Native with live objects that update automatically
Hive (Flutter)	`var box = await Hive.openBox('users');` `box.put('key', User(name: 'John'));` `var user = box.get('key');`	• Lightweight, pure Dart NoSQL database with blazing fast performance (no native dependencies) • uses binary format with lazy loading and supports custom type adapters for complex objects
Isar (Flutter)	`final isar = await Isar.open([UserSchema]);` `await isar.writeTxn(() async {` `await isar.users.put(user); });`	• High-performance Flutter database with ACID transactions, multi-isolate support, and full-text search • up to 10x faster than Hive with composite indexes and query optimization
WatermelonDB (React Native)	`const users = database.collections.get('users');` `await database.write(async () => {` `await users.create(user => { user.name = 'John' }); });`	• Reactive offline-first database built on SQLite with lazy loading, multi-threaded performance, and automatic sync • optimized for complex React Native apps with thousands of records
IndexedDB (Web/PWA)	`const request = indexedDB.open('AppDB', 1);` `const store = db.transaction('users', 'readwrite').objectStore('users');` `store.add({ id: 1, name: 'John' });`	• Browser-native asynchronous NoSQL database with indexes, transactions, and version management • storage limits vary (Chrome: ~60% disk, Safari mobile: ~50MB) with quota management required
PouchDB	`const db = new PouchDB('todos');` `await db.put({ _id: 'todo1', text: 'Buy milk' });` `db.sync('http://server/todos');`	• JavaScript database inspired by CouchDB with automatic sync to remote servers • uses IndexedDB in browsers, SQLite in Node.js, and handles conflict resolution via revision trees
SQLCipher	`sqlite3_key(db, "passphrase", 10);`	• 256-bit AES encryption extension for SQLite providing transparent full-database encryption • protects sensitive data at rest with minimal performance overhead (5-15% slower than plain SQLite).

Table 2: Conflict Resolution Strategies

Strategy	Example	Description
Last-Write-Wins (LWW)	`if (incomingTimestamp > localTimestamp) {` `applyUpdate(incoming); }`	• Simplest strategy where most recent timestamp wins • easy to implement but risks data loss when concurrent edits occur — suitable for non-critical fields like user preferences or UI state

Table 3: Background Synchronization

Mechanism	Example	Description
WorkManager (Android)	`val work = OneTimeWorkRequestBuilder<SyncWorker>()` `.setConstraints(Constraints(networkType = CONNECTED))` `.build();` `WorkManager.enqueue(work);`	• Android's recommended API for deferrable, guaranteed background work • survives app restarts and device reboots with built-in retry, backoff, and constraint-based execution (network, battery, storage).

Table 4: Network State Management

Technique	Example	Description
ConnectivityManager (Android)	`val cm = getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager;` `cm.registerDefaultNetworkCallback(object : NetworkCallback() {` `override fun onAvailable(network: Network) {} });`	• Android API for monitoring network availability and type with lifecycle-aware callbacks • provides onAvailable(), onLost(), onCapabilitiesChanged() for real-time connectivity tracking