<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Abdullah Teslim</title>
    <description>The latest articles on DEV Community by Abdullah Teslim (@abdullah_teslim_7b2a00f5b).</description>
    <link>https://dev.to/abdullah_teslim_7b2a00f5b</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3947937%2F0d7216c4-4df9-4f5f-8bc0-332759bc0ab3.png</url>
      <title>DEV Community: Abdullah Teslim</title>
      <link>https://dev.to/abdullah_teslim_7b2a00f5b</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/abdullah_teslim_7b2a00f5b"/>
    <language>en</language>
    <item>
      <title>How to Build Local-First Software with React: From IndexedDB to Offline Synchronization</title>
      <dc:creator>Abdullah Teslim</dc:creator>
      <pubDate>Thu, 22 Oct 2026 11:48:28 +0000</pubDate>
      <link>https://dev.to/abdullah_teslim_7b2a00f5b/how-to-build-local-first-software-with-react-from-indexeddb-to-offline-synchronization-dg6</link>
      <guid>https://dev.to/abdullah_teslim_7b2a00f5b/how-to-build-local-first-software-with-react-from-indexeddb-to-offline-synchronization-dg6</guid>
      <description>&lt;h1&gt;
  
  
  How to Build Local-First Software with React: From IndexedDB to Offline Synchronization
&lt;/h1&gt;

&lt;p&gt;&lt;em&gt;Your React application should not fall apart just because the network doesn't.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Most web applications are built around a simple assumption: the browser requests data from a server, receives a response, and displays it.&lt;/p&gt;

&lt;p&gt;That architecture works. Until it doesn't.&lt;/p&gt;

&lt;p&gt;A user opens a dashboard and waits for the API. They open the same dashboard in another tab, triggering another round of requests. They lose connectivity while editing a record. They refresh the page and wait for data they already loaded a few minutes ago.&lt;/p&gt;

&lt;p&gt;The problem isn't React. It isn't necessarily your database, either.&lt;/p&gt;

&lt;p&gt;The problem is that many applications treat the browser as a temporary display layer instead of a place where application data can live and remain useful.&lt;/p&gt;

&lt;p&gt;Local-first architecture challenges that assumption.&lt;/p&gt;

&lt;p&gt;Instead of making every interaction depend on a successful network request, a local-first application keeps relevant data on the user's device, reads from local storage, and coordinates changes with the server when connectivity allows.&lt;/p&gt;

&lt;p&gt;In this article, we'll explore how to approach local-first software with React, the browser technologies involved, the synchronization problems developers need to solve, and how to reduce the amount of infrastructure required to make it work.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. What does local-first actually mean?
&lt;/h2&gt;

&lt;p&gt;Local-first software prioritizes the local copy of application data rather than treating the remote server as the only place where useful data exists.&lt;/p&gt;

&lt;p&gt;Consider a project management application.&lt;/p&gt;

&lt;p&gt;A conventional implementation might fetch tasks every time the dashboard mounts:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;\&lt;/code&gt;`jsx&lt;br&gt;
import { useEffect, useState } from "react";&lt;/p&gt;

&lt;p&gt;export default function Tasks() {&lt;br&gt;
  const [tasks, setTasks] = useState([]);&lt;br&gt;
  const [loading, setLoading] = useState(true);&lt;/p&gt;

&lt;p&gt;useEffect(() =&amp;gt; {&lt;br&gt;
    fetch("/api/tasks")&lt;br&gt;
      .then((response) =&amp;gt; response.json())&lt;br&gt;
      .then(setTasks)&lt;br&gt;
      .finally(() =&amp;gt; setLoading(false));&lt;br&gt;
  }, []);&lt;/p&gt;

&lt;p&gt;if (loading) return &lt;/p&gt;
&lt;p&gt;Loading tasks...&lt;/p&gt;;

&lt;p&gt;return (&lt;br&gt;
    &lt;/p&gt;
&lt;ul&gt;

      {tasks.map((task) =&amp;gt; (
        &lt;li&gt;{task.title}&lt;/li&gt;

      ))}
    &lt;/ul&gt;
&lt;br&gt;
  );&lt;br&gt;
}&lt;br&gt;
`&lt;code&gt;\&lt;/code&gt;

&lt;p&gt;This is perfectly reasonable for a basic application. But the implementation depends on a successful network request before it can display the tasks.&lt;/p&gt;

&lt;p&gt;If the user revisits the page, the application may fetch the same data again. If the connection fails, the application has no independent source from which to recover the previously loaded tasks.&lt;/p&gt;

&lt;p&gt;A local-first design changes the data flow:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Read previously stored data from the browser.&lt;/li&gt;
&lt;li&gt;Render that data as early as practical.&lt;/li&gt;
&lt;li&gt;Check whether the server has newer information.&lt;/li&gt;
&lt;li&gt;Update the local copy when fresh data arrives.&lt;/li&gt;
&lt;li&gt;Store user changes locally before attempting remote synchronization.&lt;/li&gt;
&lt;li&gt;Deliver pending changes to the server when possible.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The server still matters. It may remain the authoritative source for shared records, permissions, and business rules.&lt;/p&gt;

&lt;p&gt;Local-first does not mean serverless, and it does not mean abandoning your existing backend.&lt;/p&gt;

&lt;p&gt;It means designing the client so that ordinary reading and editing do not unnecessarily depend on the network being available at that exact moment.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Choose the right browser storage
&lt;/h2&gt;

&lt;p&gt;React state is temporary. It exists while the relevant application runtime is active, but it does not automatically survive a page reload.&lt;/p&gt;

&lt;p&gt;For persistent local data, web applications have several options.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;localStorage&lt;/strong&gt; is useful for small values such as preferences and simple flags. Its synchronous API and string-based storage make it a poor foundation for large, structured application datasets.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;IndexedDB&lt;/strong&gt; provides asynchronous storage for structured data and is generally a better foundation for browser-side application data.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Service workers&lt;/strong&gt; can intercept supported network requests and help applications serve cached resources or provide offline navigation experiences. They do not automatically synchronize your application database.&lt;/p&gt;

&lt;p&gt;These technologies solve different problems. A service worker does not replace IndexedDB, and IndexedDB does not automatically synchronize with your backend.&lt;/p&gt;

&lt;p&gt;For this tutorial, IndexedDB is our starting point.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Create a persistent local data layer
&lt;/h2&gt;

&lt;p&gt;You can use the browser's native IndexedDB API directly, but its event-based interface can be cumbersome. A wrapper such as the &lt;code&gt;idb&lt;/code&gt; package makes it easier to work with.&lt;/p&gt;

&lt;p&gt;Install it:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;\&lt;/code&gt;&lt;code&gt;bash&lt;br&gt;
npm install idb&lt;br&gt;
\&lt;/code&gt;&lt;code&gt;\&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;Create a database module:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;\&lt;/code&gt;`js&lt;br&gt;
// db.js&lt;br&gt;
import { openDB } from "idb";&lt;/p&gt;

&lt;p&gt;export const dbPromise = openDB("project-manager", 1, {&lt;br&gt;
  upgrade(db) {&lt;br&gt;
    db.createObjectStore("tasks", {&lt;br&gt;
      keyPath: "id",&lt;br&gt;
    });&lt;br&gt;
  },&lt;br&gt;
});&lt;/p&gt;

&lt;p&gt;export async function getTasks() {&lt;br&gt;
  const db = await dbPromise;&lt;br&gt;
  return db.getAll("tasks");&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;export async function saveTask(task) {&lt;br&gt;
  const db = await dbPromise;&lt;br&gt;
  await db.put("tasks", task);&lt;br&gt;
}&lt;br&gt;
`&lt;code&gt;\&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;We have created a database called &lt;code&gt;project-manager&lt;/code&gt; with an object store for tasks.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;put()&lt;/code&gt; operation inserts a record or replaces the existing record with the same key. The &lt;code&gt;getAll()&lt;/code&gt; operation retrieves the records in that store.&lt;/p&gt;

&lt;p&gt;This is a basic persistence layer. It does not yet handle server synchronization, record conflicts, storage failures, or multi-user isolation.&lt;/p&gt;

&lt;p&gt;Those are separate engineering problems.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Connect IndexedDB to React
&lt;/h2&gt;

&lt;p&gt;Now let's build a component that reads its initial data from local storage.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;\&lt;/code&gt;`jsx&lt;br&gt;
import { useEffect, useState } from "react";&lt;br&gt;
import { getTasks, saveTask } from "./db";&lt;/p&gt;

&lt;p&gt;export default function Tasks() {&lt;br&gt;
  const [tasks, setTasks] = useState([]);&lt;br&gt;
  const [ready, setReady] = useState(false);&lt;/p&gt;

&lt;p&gt;useEffect(() =&amp;gt; {&lt;br&gt;
    let cancelled = false;&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;getTasks()
  .then((storedTasks) =&amp;gt; {
    if (!cancelled) {
      setTasks(storedTasks);
      setReady(true);
    }
  })
  .catch((error) =&amp;gt; {
    console.error("Could not read local tasks", error);
  });

return () =&amp;gt; {
  cancelled = true;
};
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;}, []);&lt;/p&gt;

&lt;p&gt;async function addTask(title) {&lt;br&gt;
    const task = {&lt;br&gt;
      id: crypto.randomUUID(),&lt;br&gt;
      title,&lt;br&gt;
      updatedAt: Date.now(),&lt;br&gt;
    };&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;await saveTask(task);
setTasks((current) =&amp;gt; [...current, task]);
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;}&lt;/p&gt;

&lt;p&gt;if (!ready) return &lt;/p&gt;
&lt;p&gt;Opening local data...&lt;/p&gt;;

&lt;p&gt;return (&lt;br&gt;
    &lt;/p&gt;
&lt;br&gt;
       addTask("New task")}&amp;gt;&lt;br&gt;
        Add task&lt;br&gt;
      

&lt;pre class="highlight plaintext"&gt;&lt;code&gt;  &amp;lt;ul&amp;gt;
    {tasks.map((task) =&amp;gt; (
      &amp;lt;li key={task.id}&amp;gt;{task.title}&amp;lt;/li&amp;gt;
    ))}
  &amp;lt;/ul&amp;gt;
&amp;lt;/section&amp;gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;);&lt;br&gt;
}&lt;br&gt;
`&lt;code&gt;\&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;This is a useful first step: data can survive a reload because it is stored outside React's in-memory state.&lt;/p&gt;

&lt;p&gt;However, there are two important limitations.&lt;/p&gt;

&lt;p&gt;First, this example waits for IndexedDB before rendering the task list. A production implementation could render the surrounding application immediately while managing local hydration separately.&lt;/p&gt;

&lt;p&gt;Second, the example only reads and writes local data. It has no mechanism for retrieving server updates or delivering local changes to the backend.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Persistence is not synchronization.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;That distinction is where local-first engineering becomes more interesting.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Make the local copy and server work together
&lt;/h2&gt;

&lt;p&gt;A real application usually has two copies of relevant data:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The local copy, optimized for immediate access and continued work.&lt;/li&gt;
&lt;li&gt;The remote copy, used to coordinate data between users and devices.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Once these copies exist, you need explicit rules for keeping them consistent.&lt;/p&gt;

&lt;p&gt;A simple synchronization flow looks like this:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;\&lt;/code&gt;&lt;code&gt;text&lt;br&gt;
Application starts&lt;br&gt;
       |&lt;br&gt;
       v&lt;br&gt;
Read local data&lt;br&gt;
       |&lt;br&gt;
       v&lt;br&gt;
Render available data&lt;br&gt;
       |&lt;br&gt;
       v&lt;br&gt;
Request server updates&lt;br&gt;
       |&lt;br&gt;
       v&lt;br&gt;
Validate and store changes&lt;br&gt;
       |&lt;br&gt;
       v&lt;br&gt;
Update the application state&lt;br&gt;
\&lt;/code&gt;&lt;code&gt;\&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;A straightforward implementation can fetch server data and replace the local copy.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;\&lt;/code&gt;`js&lt;br&gt;
import { dbPromise } from "./db";&lt;/p&gt;

&lt;p&gt;export async function refreshTasks() {&lt;br&gt;
  const response = await fetch("/api/tasks");&lt;/p&gt;

&lt;p&gt;if (!response.ok) {&lt;br&gt;
    throw new Error("Could not synchronize tasks");&lt;br&gt;
  }&lt;/p&gt;

&lt;p&gt;const tasks = await response.json();&lt;br&gt;
  const db = await dbPromise;&lt;/p&gt;

&lt;p&gt;const tx = db.transaction("tasks", "readwrite");&lt;/p&gt;

&lt;p&gt;await tx.store.clear();&lt;/p&gt;

&lt;p&gt;for (const task of tasks) {&lt;br&gt;
    await tx.store.put(task);&lt;br&gt;
  }&lt;/p&gt;

&lt;p&gt;await tx.done;&lt;/p&gt;

&lt;p&gt;return tasks;&lt;br&gt;
}&lt;br&gt;
`&lt;code&gt;\&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;This example illustrates the basic mechanics, but it assumes the endpoint returns the complete dataset and that replacing the collection is safe.&lt;/p&gt;

&lt;p&gt;That assumption will not hold for every application.&lt;/p&gt;

&lt;p&gt;If the server returns only a partial result, clearing the local collection could delete valid records. If the user has unsynchronized local edits, replacing records could overwrite their work.&lt;/p&gt;

&lt;p&gt;Production synchronization needs to account for the shape of the data, the scope of the response, pending local changes, and the server's version of each record.&lt;/p&gt;

&lt;p&gt;For large datasets, fetching the entire collection repeatedly can also become expensive. Incremental synchronization, pagination, version markers, and server-provided changes are often more appropriate.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Support offline writes
&lt;/h2&gt;

&lt;p&gt;Reading data offline is only part of the problem.&lt;/p&gt;

&lt;p&gt;Suppose a user edits a task while disconnected. If your application updates React state but never persists the edit, the change can disappear on reload.&lt;/p&gt;

&lt;p&gt;A more resilient approach is to persist the change and record the remote operation that still needs to happen.&lt;/p&gt;

&lt;p&gt;A queue entry might look like this:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;\&lt;/code&gt;&lt;code&gt;js&lt;br&gt;
{&lt;br&gt;
  id: "operation-123",&lt;br&gt;
  type: "UPDATE_TASK",&lt;br&gt;
  entityId: "task-456",&lt;br&gt;
  payload: {&lt;br&gt;
    title: "Prepare release"&lt;br&gt;
  },&lt;br&gt;
  createdAt: Date.now(),&lt;br&gt;
  status: "pending"&lt;br&gt;
}&lt;br&gt;
\&lt;/code&gt;&lt;code&gt;\&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;The application can show the new task immediately while marking the change as pending synchronization.&lt;/p&gt;

&lt;p&gt;A simplified queue processor might look like this:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;\&lt;/code&gt;&lt;code&gt;js&lt;br&gt;
async function sendTaskUpdate(task) {&lt;br&gt;
  const response = await fetch(&lt;/code&gt;/api/tasks/${task.id}`, {&lt;br&gt;
    method: "PATCH",&lt;br&gt;
    headers: {&lt;br&gt;
      "Content-Type": "application/json",&lt;br&gt;
    },&lt;br&gt;
    body: JSON.stringify({&lt;br&gt;
      title: task.title,&lt;br&gt;
    }),&lt;br&gt;
  });&lt;/p&gt;

&lt;p&gt;if (!response.ok) {&lt;br&gt;
    throw new Error("Task update was not accepted");&lt;br&gt;
  }&lt;/p&gt;

&lt;p&gt;return response.json();&lt;br&gt;
}&lt;br&gt;
`&lt;code&gt;\&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;The important detail is not the HTTP method. It is the separation between saving a change locally and confirming that the server accepted it.&lt;/p&gt;

&lt;p&gt;A robust queue needs to handle:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Durable storage of pending operations.&lt;/li&gt;
&lt;li&gt;Retrying temporary network and server failures.&lt;/li&gt;
&lt;li&gt;Removing or acknowledging successfully processed operations.&lt;/li&gt;
&lt;li&gt;Preventing duplicate effects when a request is retried.&lt;/li&gt;
&lt;li&gt;Ordering dependent operations correctly.&lt;/li&gt;
&lt;li&gt;Identifying permanent errors that require user intervention.&lt;/li&gt;
&lt;li&gt;Recovering after a page reload or browser restart.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It also needs a deliberate policy for repeated edits.&lt;/p&gt;

&lt;p&gt;If a user changes a task's title five times while offline, sending all five intermediate updates may be unnecessary. Depending on the data model and operation semantics, the queue may be able to coalesce them into one final update.&lt;/p&gt;

&lt;p&gt;But this is not safe for every operation. A payment, an audit event, and a task-title update do not have the same delivery requirements.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;An offline queue is a consistency mechanism, not just an array of failed requests.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Handle conflicts instead of assuming they won't happen
&lt;/h2&gt;

&lt;p&gt;Consider two devices editing the same task.&lt;/p&gt;

&lt;p&gt;Device A changes the title while offline. Device B changes the same title online. When Device A reconnects, which value should win?&lt;/p&gt;

&lt;p&gt;A timestamp alone may not be sufficient. Device clocks can differ, and a later timestamp does not necessarily represent the correct business decision.&lt;/p&gt;

&lt;p&gt;Possible strategies include:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Last-write-wins:&lt;/strong&gt; Accept the update that wins according to a defined ordering rule. This can work for some simple fields but may silently discard meaningful changes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Version-based conflict detection:&lt;/strong&gt; Attach a version or revision to a record. If the server has moved to a newer version, reject or flag the stale update instead of blindly overwriting it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Field-level merging:&lt;/strong&gt; Merge changes to different fields when the application can prove that doing so is safe.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Explicit conflict resolution:&lt;/strong&gt; Present both versions to the user or apply domain-specific rules.&lt;/p&gt;

&lt;p&gt;Conflict resolution should be designed around the meaning of the data. There is no single merge strategy that is correct for every application.&lt;/p&gt;

&lt;p&gt;For example, independently edited profile preferences may be easy to merge. Inventory, financial records, and collaborative documents may require much stricter rules.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Coordinate multiple browser tabs
&lt;/h2&gt;

&lt;p&gt;Open the same application in three tabs.&lt;/p&gt;

&lt;p&gt;Without coordination, all three may independently fetch the same data, establish separate real-time connections, and attempt to process the same pending operations.&lt;/p&gt;

&lt;p&gt;This can produce unnecessary server traffic and additional synchronization races.&lt;/p&gt;

&lt;p&gt;A multi-tab-aware architecture can coordinate work by:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Sharing persisted data through IndexedDB.&lt;/li&gt;
&lt;li&gt;Communicating updates between tabs.&lt;/li&gt;
&lt;li&gt;Electing or locking a tab to perform certain network operations.&lt;/li&gt;
&lt;li&gt;Preventing multiple tabs from replaying the same queue entry simultaneously.&lt;/li&gt;
&lt;li&gt;Propagating logout and account changes across the browser.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Browser APIs such as &lt;code&gt;BroadcastChannel&lt;/code&gt; and the Web Locks API can help with parts of this design. They do not automatically provide a complete coordination system, and the application still needs to define its locking, recovery, and synchronization rules.&lt;/p&gt;

&lt;p&gt;A browser with several tabs is effectively several concurrent application runtimes sharing some resources.&lt;/p&gt;

&lt;p&gt;Treating each tab as an isolated client ignores that reality.&lt;/p&gt;

&lt;h2&gt;
  
  
  9. Don't confuse offline access with offline security
&lt;/h2&gt;

&lt;p&gt;Local storage changes your security responsibilities.&lt;/p&gt;

&lt;p&gt;A browser cache may contain private information. A queued write may belong to a particular user or tenant. If one person logs out and another signs in on the same device, the application must not expose the previous person's data.&lt;/p&gt;

&lt;p&gt;At a minimum, design for:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;User- and tenant-scoped storage.&lt;/li&gt;
&lt;li&gt;Explicit cleanup or isolation during logout and account switching.&lt;/li&gt;
&lt;li&gt;Server-side authorization for every protected operation.&lt;/li&gt;
&lt;li&gt;Validation of queued operations when they reach the server.&lt;/li&gt;
&lt;li&gt;Appropriate treatment of sensitive data at rest.&lt;/li&gt;
&lt;li&gt;Storage quota errors and browser eviction.&lt;/li&gt;
&lt;li&gt;Clear user feedback when a write could not be durably saved.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;IndexedDB is not automatically encrypted just because it is browser storage. A local copy is not a substitute for server-side authorization, and hiding data in the interface is not an access-control mechanism.&lt;/p&gt;

&lt;p&gt;Also, a successful local write does not guarantee permanent storage. Browsers can restrict, evict, or clear site data. Applications must distinguish between a change saved durably to local storage, a change waiting for synchronization, and a change that exists only in memory.&lt;/p&gt;

&lt;p&gt;For critical workflows, communicate those states honestly.&lt;/p&gt;

&lt;h2&gt;
  
  
  10. The real cost: maintaining the synchronization engine
&lt;/h2&gt;

&lt;p&gt;At this point, we have covered local persistence, hydration, server refreshes, offline writes, conflict detection, and multi-tab coordination.&lt;/p&gt;

&lt;p&gt;There are still other concerns: stale data policies, retry backoff, incremental synchronization, real-time events, queue deduplication, schema migrations, session teardown, and recovery after partial failures.&lt;/p&gt;

&lt;p&gt;Each mechanism introduces interactions with the others.&lt;/p&gt;

&lt;p&gt;For example:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What happens when a real-time update arrives while a queued offline edit is waiting to replay?&lt;/li&gt;
&lt;li&gt;What happens when a retry succeeds on the server but the browser crashes before recording the acknowledgement?&lt;/li&gt;
&lt;li&gt;What happens when a user logs out while offline?&lt;/li&gt;
&lt;li&gt;What happens when two tabs attempt to replay the same operation?&lt;/li&gt;
&lt;li&gt;What happens when the server changes a record that the browser has not loaded yet?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;You can build and maintain these systems yourself. For some products, a custom implementation is the right choice.&lt;/p&gt;

&lt;p&gt;But the engineering cost is larger than writing an IndexedDB wrapper and a &lt;code&gt;useEffect&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The difficult part is making all these mechanisms work together predictably.&lt;/p&gt;

&lt;h2&gt;
  
  
  11. Using Flux to implement the infrastructure
&lt;/h2&gt;

&lt;p&gt;This is the problem I built &lt;strong&gt;Flux&lt;/strong&gt; to address.&lt;/p&gt;

&lt;p&gt;Flux is a local-first software infrastructure tool for web applications. It sits between the application and its backend, managing browser-side data persistence, synchronization, offline mutations, and coordination across tabs.&lt;/p&gt;

&lt;p&gt;Rather than asking every React application to implement each mechanism independently, Flux provides a shared runtime for these concerns.&lt;/p&gt;

&lt;p&gt;Its documented capabilities include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;IndexedDB-backed local data with configurable time-to-live policies.&lt;/li&gt;
&lt;li&gt;Hydration of registered application stores from local data.&lt;/li&gt;
&lt;li&gt;Offline write queues and replay.&lt;/li&gt;
&lt;li&gt;Mutation coalescing for supported update patterns.&lt;/li&gt;
&lt;li&gt;Real-time synchronization through supported adapters.&lt;/li&gt;
&lt;li&gt;Cross-tab coordination for data fetching and synchronization.&lt;/li&gt;
&lt;li&gt;Conflict detection and resolution workflows.&lt;/li&gt;
&lt;li&gt;User-scoped storage and session cleanup.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Flux is not a replacement for React, your database, your authentication provider, or your backend API. Those systems remain responsible for their existing roles.&lt;/p&gt;

&lt;p&gt;The objective is to give your application a more resilient client-side data layer without requiring you to assemble and maintain every mechanism yourself.&lt;/p&gt;

&lt;p&gt;Explore the architecture and supported integrations in the &lt;a href="https://tsworldtechflux.dev/docs" rel="noopener noreferrer"&gt;Flux documentation&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  12. Getting started with Flux and React
&lt;/h2&gt;

&lt;p&gt;Flux supports React applications, including projects built with Vite, Remix, and Create React App. It also provides a Next.js integration.&lt;/p&gt;

&lt;p&gt;The general integration process is:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Install the core package and the integration or adapter appropriate for your stack.&lt;/li&gt;
&lt;li&gt;Create a single Flux engine instance.&lt;/li&gt;
&lt;li&gt;Connect the engine to your existing backend or supported real-time provider.&lt;/li&gt;
&lt;li&gt;Register the application stores that need local persistence and synchronization.&lt;/li&gt;
&lt;li&gt;Configure data scope, caching policies, and any required offline-write behavior.&lt;/li&gt;
&lt;li&gt;Integrate hydration and synchronization into your application lifecycle.&lt;/li&gt;
&lt;li&gt;Test reconnects, duplicate requests, account switching, and conflicting updates.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The exact setup depends on your state manager, backend, and framework. Follow the relevant integration guide rather than assuming every application uses the same configuration.&lt;/p&gt;

&lt;p&gt;Start here:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href="https://tsworldtechflux.dev/docs" rel="noopener noreferrer"&gt;Flux for React and other supported frameworks&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;For the underlying architecture, read the &lt;a href="https://tsworldtechflux.dev/docs/core-concepts/5-layer-stack" rel="noopener noreferrer"&gt;five-layer resilience stack&lt;/a&gt; and the &lt;a href="https://tsworldtechflux.dev/docs/api/register" rel="noopener noreferrer"&gt;&lt;code&gt;register()&lt;/code&gt; API reference&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;You can also explore Flux at &lt;a href="https://tsworldtechflux.dev/" rel="noopener noreferrer"&gt;tsworldtechflux.dev&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion: Your browser can do more
&lt;/h2&gt;

&lt;p&gt;React made it easier to build interactive interfaces. Modern browser storage and networking APIs make it possible to build applications that remain useful when the network is unreliable.&lt;/p&gt;

&lt;p&gt;But local-first software requires more than caching a response.&lt;/p&gt;

&lt;p&gt;It requires a deliberate approach to persistence, synchronization, offline mutations, conflict resolution, concurrent tabs, and user data isolation.&lt;/p&gt;

&lt;p&gt;Start with a clear data model. Decide which operations can safely happen offline. Define how conflicts are resolved. Treat local storage as fallible, and test what happens when requests fail at the worst possible moment.&lt;/p&gt;

&lt;p&gt;Then decide whether maintaining the entire synchronization layer is the best use of your engineering time.&lt;/p&gt;

&lt;p&gt;The network will always be an external dependency. Your application does not have to make every interaction depend on it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Build for the moment the connection fails, not just for the moment it works.&lt;/strong&gt;&lt;br&gt;
&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxcoq6fg9rml9ftl24rtf.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxcoq6fg9rml9ftl24rtf.png" alt=" " width="799" height="390"&gt;&lt;/a&gt;&lt;/p&gt;

</description>
      <category>localfirstsoftware</category>
      <category>webdev</category>
      <category>programming</category>
      <category>architecture</category>
    </item>
    <item>
      <title>Your Web App Has No Memory: Adding Local-First Behavior to the Backend You Already Have</title>
      <dc:creator>Abdullah Teslim</dc:creator>
      <pubDate>Wed, 07 Oct 2026 20:01:18 +0000</pubDate>
      <link>https://dev.to/abdullah_teslim_7b2a00f5b/your-web-app-has-no-memory-adding-local-first-behavior-to-the-backend-you-already-have-319</link>
      <guid>https://dev.to/abdullah_teslim_7b2a00f5b/your-web-app-has-no-memory-adding-local-first-behavior-to-the-backend-you-already-have-319</guid>
      <description>&lt;p&gt;Open your app's dashboard in three browser tabs. Open the network panel in each. Now refresh them one after another.&lt;/p&gt;

&lt;p&gt;You will probably see the same requests, three times, for data your browser fetched a few seconds ago. Close the laptop, open it on a train with bad signal, and the app either spins or shows an error. Edit something while the connection drops and you are hoping the request retries.&lt;/p&gt;

&lt;p&gt;None of this is a bug. It is the default shape of a client server web app: the server is the only place data lives, and the browser asks for it every time. The browser is treated as a screen, not as a place that can hold anything.&lt;/p&gt;

&lt;p&gt;"Local-first" is the idea that flips that default. The data lives on the device first, and the network is how it gets distributed. Most of the writing about it covers the research and the CRDT tooling. That is great for new collaborative apps, but a lot of us have a Postgres database, a REST API, and a production app we are not going to rewrite.&lt;/p&gt;

&lt;p&gt;So this post is about the other case: getting local-first behavior while your backend stays exactly where it is.&lt;/p&gt;

&lt;p&gt;I am the founder of the team building Flux, a library that does this, so I'll use it as the worked example. The ideas apply even if you build the pieces yourself.&lt;/p&gt;

&lt;p&gt;Local-first, with a backend that is still in charge&lt;/p&gt;

&lt;p&gt;There are two broad ways to get there.&lt;/p&gt;

&lt;p&gt;The first is to move the source of truth to the client and replicate it, usually with CRDTs. Automerge and Yjs are the well known libraries. It is the right model when multiple people edit the same document concurrently and you want merges that never conflict.&lt;/p&gt;

&lt;p&gt;The second keeps your backend as the system of record. The browser keeps a local copy, coordinates it across tabs, queues writes while offline, and reconciles with the server when it can. Conflicts still exist here, and your backend still decides what is true. This is the model Flux follows, and it fits dashboards, internal tools, booking systems, e-commerce and operational software, where the server has to stay authoritative.&lt;/p&gt;

&lt;p&gt;If you are not sure which you need, ask this: could two people legitimately edit the same thing at once and both be right? If yes, look at CRDTs. If your data has one correct answer owned by the server, a backed local layer is simpler.&lt;/p&gt;

&lt;p&gt;Problem 1: every tab asks for the same thing&lt;/p&gt;

&lt;p&gt;Browsers do not share state between tabs by default. Ten tabs means ten bootstraps, ten sockets, ten sets of identical reads.&lt;/p&gt;

&lt;p&gt;The fix is coordination. One tab is elected as the leader and makes the network request. The other tabs hydrate from local storage instead of calling your server. When a tab changes something, it signals the others, so the update shows up everywhere immediately with no refresh.&lt;/p&gt;

&lt;p&gt;The practical result: ten tabs open, one request to your server, and every tab agrees about what the data is.&lt;/p&gt;

&lt;p&gt;Problem 2: return visits start from zero&lt;/p&gt;

&lt;p&gt;Most apps on a repeat visit do the same work as a first visit: render a shell, fire requests, show a spinner, render data.&lt;/p&gt;

&lt;p&gt;If the data is already in IndexedDB, there is no reason to wait. The useful model has three states for any cached item:&lt;/p&gt;

&lt;p&gt;Fresh: the data is recent enough. Render it and do not ask the server.&lt;br&gt;
Stale: the data is past its time to live. Render it right away, and revalidate in the background.&lt;br&gt;
Missing: nothing is cached. This one waits for the network, like any first visit.&lt;/p&gt;

&lt;p&gt;The detail worth noticing is that a time to live describes freshness, not deletion. Expired data can still be shown immediately, and it only gets replaced when something newer arrives. Return visits can render from local data before the network responds. They will not always skip the loading state, because a cold cache still has to fetch, and anyone who promises otherwise is overselling.&lt;/p&gt;

&lt;p&gt;Problem 3: writes that vanish offline&lt;/p&gt;

&lt;p&gt;Reads are the easy half. The harder question is what happens when a user saves something and the connection is gone.&lt;/p&gt;

&lt;p&gt;The pattern that holds up is a durable queue:&lt;/p&gt;

&lt;p&gt;The write goes into local storage first.&lt;br&gt;
The UI updates optimistically.&lt;br&gt;
When the network returns, queued writes replay in order.&lt;br&gt;
Duplicates are removed, and repeated edits to the same record can be coalesced into one request.&lt;/p&gt;

&lt;p&gt;The payoff is in your own code. The handler for "save this note" does not need an offline branch. You write the save once, and the queue deals with the gap between the browser and your backend.&lt;/p&gt;

&lt;p&gt;There are edge cases you should know about. Browser File objects do not survive a tab closing the way plain JSON does, so uploads need their own pattern. A write that is delayed is not a write that is guaranteed to succeed, because the server can still reject it. A good queue makes failures visible instead of hiding them.&lt;/p&gt;

&lt;p&gt;Problem 4: reconnecting should not mean re downloading everything&lt;/p&gt;

&lt;p&gt;A phone comes back online after twenty minutes. The naive recovery is to refetch everything. That works, and it is expensive for your server and slow for the user.&lt;/p&gt;

&lt;p&gt;The better approach is a sync anchor: a marker for "the last point this client knew about", tracked per channel. On reconnect, the client presents its anchor and the server sends only what changed since. Deletions need extra care, because a delta log only tells you about rows that still exist. A reconcile step, where the client and server compare what they believe is present, catches the rows that were removed while the client was away.&lt;/p&gt;

&lt;p&gt;Problem 5: the world changed while you were offline&lt;/p&gt;

&lt;p&gt;Here is the case that separates a real system from a demo. A user edits a record offline. While they are offline, someone else changes the same record on the server. Then the first user reconnects and their queued edit replays.&lt;/p&gt;

&lt;p&gt;If you do nothing, the stale edit overwrites newer data.&lt;/p&gt;

&lt;p&gt;The approach in Flux is a two pass handshake for queued offline mutations. Before the write lands, the client and server check whether the record moved. If it did, the write is held as a conflict instead of being applied, and your application decides what to do: keep the server version, keep the local one, or show the user both. Conflicts are scoped to queued offline writes, not to every request, which keeps the mechanism small and predictable.&lt;/p&gt;

&lt;p&gt;Offline is not the hard part. Knowing what to do when things changed underneath you is.&lt;/p&gt;

&lt;p&gt;Problem 6: shared machines&lt;/p&gt;

&lt;p&gt;Cached data in a browser belongs to whoever logged in last, unless something prevents that. On a family laptop, a kiosk, or a work machine passed between shifts, user B should never see user A's cached data.&lt;/p&gt;

&lt;p&gt;The fix is structural, not a cleanup step you hope runs. Every cache entry, queued write, sync anchor and conflict lives under a per user namespace. Logging out purges that namespace and signals the other tabs to do the same. On the next boot, a sweep removes namespaces that no longer have a session.&lt;/p&gt;

&lt;p&gt;To be precise about what this is: it isolates browser state. It is not authentication and it is not authorization. Your server still decides who is allowed to see what.&lt;/p&gt;

&lt;p&gt;What the setup looks like&lt;/p&gt;

&lt;p&gt;For a Next.js app, the service worker and the offline routing are generated at build time from a config wrapper, so you never write the worker yourself. The full walkthrough is in the Next.js guide.&lt;/p&gt;

&lt;p&gt;ts&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;`

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;// next.config.ts&lt;br&gt;
import type { NextConfig } from "next";&lt;br&gt;
import { withFlux } from "@tsworldtech/flux-next/plugin";&lt;/p&gt;

&lt;p&gt;const nextConfig: NextConfig = {};&lt;/p&gt;

&lt;p&gt;export default withFlux({&lt;br&gt;
  precacheRoutes: ["/", "/offline"],&lt;br&gt;
  offlineShell: "/offline",&lt;br&gt;
  storagePrefix: "myapp",&lt;br&gt;
  dynamicRoutePrefixes: ["/products/", "/blog/"],&lt;br&gt;
})(nextConfig);&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;`
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;dynamicRoutePrefixes is the part people find surprising. It lets a route like /products/[slug] open offline even for a product the user has never visited, because the app shell is served at the real URL and the data comes from local storage.&lt;/p&gt;

&lt;p&gt;Realtime comes through adapters for Supabase, Socket.IO, Server Sent Events and plain WebSocket. Your backend implements a small contract: an event shape, a sync handshake, and a changelog table so reconnects can send only what was missed.&lt;/p&gt;

&lt;p&gt;You can prove it works before you configure anything else. Register one store, load the app, switch the network off in devtools, and refresh. The app should come up from local data. Production concerns like licensing, realtime adapters and conflict handling can wait until that moment has happened.&lt;/p&gt;

&lt;p&gt;When not to use this&lt;/p&gt;

&lt;p&gt;Be honest with yourself about fit. A backed local layer is a poor choice when:&lt;/p&gt;

&lt;p&gt;You need strict consistency. Inventory, ledgers and anything where two people must not claim the same resource. Eventual agreement is not enough, and the server has to stay in the loop for every write.&lt;br&gt;
The page is mostly static content. Marketing sites and blogs gain little from client side persistence.&lt;br&gt;
The data is purely server generated. Analytics feeds and search results are fetched, displayed and discarded. There is nothing worth remembering.&lt;br&gt;
You are building a multiplayer editor. Concurrent document editing is what CRDTs are for.&lt;/p&gt;

&lt;p&gt;It fits well when users return to the same data repeatedly, keep several tabs open, work on unstable connections, or queue changes while offline.&lt;/p&gt;

&lt;p&gt;Where this sits among the other tools&lt;/p&gt;

&lt;p&gt;This is a map, not a ranking.&lt;/p&gt;

&lt;p&gt;TanStack Query and SWR manage server state and caching in memory. They are excellent, and they do not persist across sessions or coordinate tabs by default.&lt;br&gt;
PowerSync and ElectricSQL sync a database subset into a local SQLite database. They are a strong choice if you want a local relational store and queries.&lt;br&gt;
RxDB is a reactive local database with replication to a backend of your choice.&lt;br&gt;
Automerge and Yjs are CRDT libraries for conflict free collaborative data.&lt;br&gt;
Flux coordinates persistence, tabs, queued writes, realtime and reconnect around an existing API, without changing your data model or moving your database.&lt;/p&gt;

&lt;p&gt;They overlap more than the labels suggest, and the right pick depends on what you are optimizing for.&lt;/p&gt;

&lt;p&gt;Try it&lt;/p&gt;

&lt;p&gt;If your app opens the same data on every visit, keeps several tabs open, or has users on shaky connections, run the experiment from the top of this post. Count the repeated requests. Then decide whether the browser should keep remembering things for you.&lt;/p&gt;

&lt;p&gt;The docs and quickstart are at &lt;a href="https://tsworldtechflux.dev" rel="noopener noreferrer"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwphow6v7v50du3phubq6.png" alt=" " width="800" height="384"&gt;&lt;/a&gt;. I would like to hear which of the six problems hurts most in your app, and which one I got wrong.&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>architecture</category>
      <category>software</category>
    </item>
    <item>
      <title>Nextjs and reactjs apps can now fully work offline.</title>
      <dc:creator>Abdullah Teslim</dc:creator>
      <pubDate>Thu, 20 Aug 2026 06:01:28 +0000</pubDate>
      <link>https://dev.to/abdullah_teslim_7b2a00f5b/nextjs-and-reactjs-apps-can-now-fully-work-offline-231k</link>
      <guid>https://dev.to/abdullah_teslim_7b2a00f5b/nextjs-and-reactjs-apps-can-now-fully-work-offline-231k</guid>
      <description>&lt;p&gt;Nextjs and reactjs apps can now fully work offline.&lt;/p&gt;

&lt;p&gt;Three days ago, i launched the npm package that gives all features of offline for offline accessibility, managing how applications talk to their server, the mutation queues, the conflict resolution , sparse updates and more,&lt;/p&gt;

&lt;p&gt;Efficiently helping you reduce server cost for scaling apps &lt;/p&gt;

&lt;p&gt;To visit the docs : &lt;a href="https://tsworldtechflux.dev" rel="noopener noreferrer"&gt;https://tsworldtechflux.dev&lt;/a&gt; &lt;/p&gt;

</description>
      <category>nextjs</category>
      <category>developers</category>
    </item>
    <item>
      <title>Have You Ever Used a Website That Keeps Working After You Turn Off Your Internet?</title>
      <dc:creator>Abdullah Teslim</dc:creator>
      <pubDate>Sat, 23 May 2026 16:19:06 +0000</pubDate>
      <link>https://dev.to/abdullah_teslim_7b2a00f5b/have-you-ever-used-a-website-that-keeps-working-after-you-turn-off-your-internet-2k68</link>
      <guid>https://dev.to/abdullah_teslim_7b2a00f5b/have-you-ever-used-a-website-that-keeps-working-after-you-turn-off-your-internet-2k68</guid>
      <description>&lt;p&gt;Neither had I. So I built one.&lt;/p&gt;

&lt;p&gt;Most websites die the moment your internet does. You lose signal, you get a blank screen or a spinner that never stops. Refresh the page offline and it's gone. That's just "how the web works," right?&lt;/p&gt;

&lt;p&gt;I refused to accept that.&lt;/p&gt;

&lt;p&gt;I'm a Front-End Engineer based in Lagos, Nigeria. If you've ever tried to use a web app on a bus in Lagos with 2G cutting in and out, you understand why I started thinking about this differently. The network isn't reliable. But the app should be.&lt;/p&gt;

&lt;p&gt;So I built an architecture I call Browser Physics.&lt;/p&gt;

&lt;p&gt;What Is Browser Physics?&lt;/p&gt;

&lt;p&gt;Browser Physics is my answer to one question: what if the browser didn't need the internet at all?&lt;/p&gt;

&lt;p&gt;I treat the browser as a self-sustaining operating system and the network as an optional backup, not a requirement.&lt;/p&gt;

&lt;p&gt;Instead of fetching data from the server every time a user navigates, I built a three-tier storage model:&lt;/p&gt;

&lt;p&gt;Hot Data — Zustand in memory. Page transitions take zero milliseconds because they read from RAM, not the network.&lt;/p&gt;

&lt;p&gt;Warm Data — IndexedDB on disk. Survives hard refresh. The app boots from local disk even with no internet.&lt;/p&gt;

&lt;p&gt;Cold Data — Supabase, the actual database. Only consulted on first boot and when the user reconnects after being offline.&lt;/p&gt;

&lt;p&gt;On top of that, a Service Worker intercepts network requests so when you navigate around with no internet, everything is served from local cache instantly. No spinner. No broken state. Same speed as online.&lt;/p&gt;

&lt;p&gt;When you're back online, WebSocket pushes live updates the moment data changes in the database. When you reconnect after being offline, an automatic revalidation fetch runs and syncs only what changed so you always have the latest data.&lt;/p&gt;

&lt;p&gt;See It Live&lt;/p&gt;

&lt;p&gt;I am currently building TSWorldTech, the first real production platform running Browser Physics.&lt;/p&gt;

&lt;p&gt;tsworldtech.com&lt;/p&gt;

&lt;p&gt;The application is currently 85% complete. Data, navigation, real-time sync, and offline resilience are all working. Image offline persistence is the remaining layer in active development.&lt;/p&gt;

&lt;p&gt;Here is the challenge:&lt;/p&gt;

&lt;p&gt;Visit the website while online. Then turn off your data. Navigate around. Refresh the page. It all still works, same speed, same data, zero spinners.&lt;/p&gt;

&lt;p&gt;Then come back and tell me what you see.&lt;/p&gt;

&lt;p&gt;Would You Like to Know How I Built It?&lt;/p&gt;

&lt;p&gt;I am planning a full technical breakdown covering the Service Worker architecture, the three-tier storage model, the HydrationGate pattern, the WebSocket and IDB reconnection sync, and every decision behind each layer.&lt;/p&gt;

&lt;p&gt;If that is something you would want to read, drop a comment below. The more interest, the sooner I write it.&lt;/p&gt;

&lt;p&gt;I am Abdullah Teslim, a Front-End Engineer and the person who got tired of spinners.&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>programming</category>
      <category>productivity</category>
    </item>
  </channel>
</rss>
