Should React Native apps rely on server-side idempotency keys or client-side deduplication to prevent duplicate writes on retry?

Answer

For exactly‑once writes on retry, a React Native app should generate a UUID‑based idempotency key, persist it locally (preferably in secure storage), and send it with each mutation. The server must enforce the key by deduplicating requests and returning the same response within a reasonable TTL. This hybrid approach gives the strongest guarantees across network failures, app restarts, and device changes.

Why This Works

• Client‑side key generation guarantees that every retry uses the same identifier, independent of network state.
• Local persistence (AsyncStorage, Keychain, Keystore) survives transient failures but may be cleared on reinstall; secure storage mitigates exposure.
• Server‑side deduplication ensures that even if the same key arrives from a different device or after a reinstall, only the first write is applied. A TTL (e.g., 24‑48 h) balances retry windows against storage bloat.
• Hybrid queueing (optional) can batch initial requests when offline, but the idempotency key remains the single source of truth for duplication.

Confirmed Facts from Current Knowledge

• UUID keys persisted locally are the most reliable source of truth for retries.
• Servers must treat the key as immutable and return identical responses within the TTL.
• Pure client‑side queues without server enforcement cannot guarantee exactly‑once semantics across devices.
• Short or missing TTLs can cause legitimate retries to be treated as new operations.
• App reinstalls that clear local storage remove the key, potentially leading to duplicate writes.

Implementation Steps for Your Project

1. Generate a UUID (e.g., uuidv4()) when creating a mutation.
2. Store the key in secure local storage and attach it to the HTTP header Idempotency-Key.
3. On the server, maintain a key store (Redis, DB) that maps the key to the operation result and TTL.
4. When a request arrives, check the key:
   • If present and unexpired, return the cached response.
   • If absent or expired, execute the operation, store the result, and set the TTL.
5. After a successful operation, delete the key from local storage to avoid re‑sending the same mutation on future app launches.

What If Your Backend Lacks Idempotency Support?

In that case, you must rely on a client‑side deduplication queue and manually reconcile conflicts. However, this approach cannot guarantee single writes if the same request is retried from a different device or after reinstall.

Missing Diagnostic Detail

Does your backend currently support idempotency keys and a configurable TTL? If not, the recommendation may shift toward a more robust client‑side queue with manual conflict resolution.

Diagram

Client	Network	Server	Storage
Generate & Persist Key	Send Mutation	Deduplicate & Respond	Key Store (TTL)