Local-first software: web applications that work even without an internet connection

All it takes is for the Wi-Fi to go down, and many web apps turn into a blank page with a spinning wheel. Spreadsheets won’t load, calendars won’t show meetings, and notes are inaccessible. Yet the data you’re working with is often created by you on your own device. The “local-first” approach aims to flip this relationship: the primary copy of your data stays with you, and the server comes second.

What Does “Local-First” Software Mean?

The term originates from an essay published in 2019 by the Ink & Switch research team (Kleppmann, Wiggins, van Hardenberg, McGranaghan). In it, the authors proposed a set of principles for software that combines the convenience of cloud applications—collaboration and access from multiple devices—with the sense of data ownership familiar from older desktop programs.

The core idea is simple: the copy of your data on your laptop, tablet, or phone is considered the primary copy. The server, if it exists, serves primarily for synchronization and backup. Among the ideals are fast response times without waiting, offline functionality, collaboration among multiple people, privacy protection, and long-term data availability even if the service ceases to exist.

It’s worth noting that this is a set of ideals, not a finished standard. Most applications that are labeled “local-first” today meet only some of these ideals.

How the Web Stores Data Directly on the Device

Web applications do not have to rely solely on small “cookie”-type storage. Modern browsers offer several mechanisms for local data storage, and one of the newer ones is the so-called Open Private File System (OPFS).

What Is OPFS

OPFS is a storage system that belongs to a specific website (more precisely, its origin) and is not visible in the user’s regular file system. It offers low-level access to files and is optimized for performance, making it suitable for local databases, for example. Support in major browsers appeared in 2022 and 2023, and the feature is now considered widely available.

What OPFS Is Not

It should not be confused with unrestricted access to your disk. The website cannot see your files, and you cannot view its files as regular documents. The storage is subject to browser quotas, and when website data is deleted, this storage is also deleted. Therefore, for important data, it’s not enough to rely solely on the browser—you’ll need to back it up or export it.

Offline Loading of the Application

For an app to open even without an internet connection, its code must be stored locally. This is achieved using service workers—small scripts that can intercept network requests and handle them from local storage. Such an app can be turned into a Progressive Web App (PWA).

Why This Can Be Faster

If reading, filtering, and editing are performed on local data, the app doesn’t wait for a server response with every click. Latency is therefore typically very low and does not depend on connection quality. The authors of the original essay describe this as the “zero-wait” ideal: the user does not have to wait for a server request to complete because the primary copy of the data is right there with them.

However, “zero latency” is a simplification. Even local operations consume computational resources, and large databases can strain less powerful devices.

How to Resolve Synchronization Conflicts

The most challenging question is: what happens if you edit the same document on both your phone and laptop, and each device was offline in the meantime? One promising solution is CRDT (Conflict-free Replicated Data Types).

The Principle of CRDT

CRDTs are designed so that they can be edited independently on multiple devices and then automatically merged into the same result, regardless of the order in which the changes arrive. Each device therefore stores the changes and sends them to the others once it reconnects. Only the differences are transferred, not the entire files.

Where Are the Limits

Automatic merging ensures that all devices end up in the same state, not that the result will make sense to a human. If two people rewrite the same sentence differently, the algorithm will choose a specific solution, which may not be the one you would have chosen. Furthermore, the authors of the essay acknowledge that collaboration at the level of the best cloud applications is one of the most difficult goals of the entire concept.

What This Means for Developers and Users

For smaller developers, local processing can reduce the need for expensive server infrastructure, since computations and most of the data remain on the user’s device. This can also make it easier to offer tools for a one-time fee or for free. However, this isn’t automatic: if an app requires synchronization or sharing among users, some server or transmission service is usually still needed. Costs are thus shifted and altered rather than eliminated.

For users, the main benefit is greater control: data can remain on your device, the app works on a plane or train, and you won’t lose everything if the service is discontinued. The downside is greater responsibility for backups, higher demands on device storage, and more complicated development.

Is this the end of the cloud?

No. Claims of a mass exodus from cloud databases or the end of the era of the “dumb window to the server” are not supported by independent data. A more realistic picture is that “local-first” is a growing approach that proves particularly effective for applications involving personal data, notes, document editing, and offline work. The cloud remains essential for sharing, backups, computationally intensive tasks, and services that require a single source of truth—such as payments.

Conclusion

"Local-first" software isn’t magic, but a shift in priorities: device first, network second. Modern browsers provide an increasingly solid technical foundation for it, and CRDTs solve a significant portion of the synchronization problem. However, many questions remain—from backup and collaboration to development costs. It’s useful for readers to be able to tell whether an app actually runs locally or just appears to work offline until the last page loads.