How do you persist data locally in React Native?

Question

IT Interview Practice · Accepted Answer

React Native apps often need to **store data locally** — user preferences, cached data, auth tokens, offline content. Options include **AsyncStorage** (key-value), **MMKV** (fast), **SQLite**, and **secure storage** for sensitive data. Choosing the right one matters.

## Local storage options

```text
ASYNCSTORAGE → simple async KEY-VALUE storage (the common basic option):
  → store strings (serialize objects to JSON); for settings, small data, simple caching
  → async API; persists across app launches
MMKV → a very FAST key-value storage (by WeChat) — faster than AsyncStorage, synchronous;
  popular modern choice for performance
SQLITE (e.g. expo-sqlite, react-native-sqlite, WatermelonDB) → relational DATABASE for
  STRUCTURED/large data, queries, relationships, offline-first apps
SECURE STORAGE → expo-secure-store / react-native-keychain for SENSITIVE data (tokens,
  credentials) — ENCRYPTED (keychain/keystore)
```

## AsyncStorage example

```jsx
import AsyncStorage from '@react-native-async-storage/async-storage';

await AsyncStorage.setItem('user', JSON.stringify(user));   // store (serialize)
const json = await AsyncStorage.getItem('user');
const user = json ? JSON.parse(json) : null;                 // retrieve (parse)
```

## Choosing the right option

```text
Simple settings/small data → AsyncStorage (or MMKV for speed)
Structured/large/relational/offline data → SQLite / WatermelonDB
SENSITIVE data (auth tokens, passwords) → SECURE storage (encrypted) — NOT AsyncStorage
  (which is NOT secure/encrypted — a common security mistake)
→ Match storage to the data's size, structure, and sensitivity.
```

## Why it matters

Understanding how to persist data locally in React Native is valuable because **apps commonly need to store data on the device** (preferences, cached data, tokens, offline content), so it's useful practical knowledge for building real apps.

Local persistence is a near-universal need, and React Native offers several options.

Understanding the **options** — **AsyncStorage** (the common simple async key-value storage for settings and small data), **MMKV** (a very fast modern key-value alternative), **SQLite/WatermelonDB** (relational databases for structured, large, or offline-first data with queries), and **secure storage** (expo-secure-store/react-native-keychain for sensitive data) — and **when to use each** is the key knowledge.

Choosing the **right option** matters: AsyncStorage or MMKV for simple data, SQLite for structured/large/offline data, and crucially **secure storage for sensitive data** like auth tokens and credentials (which must be encrypted via the platform keychain/keystore — an important security point, since **AsyncStorage is not secure/encrypted and shouldn't hold secrets**, a common mistake).

Matching the storage to the data's size, structure, and sensitivity reflects sound decisions and avoids problems (wrong tool, or insecurely-stored credentials).

Knowing about offline-first solutions (WatermelonDB) is valuable for apps needing robust offline support.

Since apps commonly need local persistence (settings, caching, tokens, offline data) and React Native offers options for different needs, and since choosing appropriately (especially using secure storage for sensitive data) is important for building real apps correctly and securely, understanding local data persistence in React Native is valuable, practically-relevant knowledge — a common need in real apps, important for both functionality (storing the right data the right way) and security (protecting sensitive data with secure storage, not AsyncStorage), and useful for building apps that remember state and work offline.

Local storage options

AsyncStorage example

Choosing the right option

Why it matters

Related questions