The quiet return of the local-first app

For ten years the default architecture of consumer software was simple: put everything on someone else's server and treat the device in your hand as a window. It worked, until the Wi-Fi dropped on a train and the notes app that held your whole afternoon turned into a spinner.

A growing number of developers now argue that the window metaphor was a mistake. Their approach, called local-first, treats the copy of the data on your device as the real one and the server as a helpful courier.

What local-first actually means

In a local-first app, every action is applied to a database on your phone or laptop immediately. Syncing happens afterwards, quietly, whenever a connection exists. Nothing waits for a round trip, so nothing feels slow.

The idea was formalised in a widely shared 2019 essay that listed seven ideals, from fast response to long-term data ownership. Few apps hit all seven, but the list gave builders a shared vocabulary.

The hard part: agreeing without a referee

If two people edit the same paragraph offline, someone has to decide what the final text says. Traditional apps solve this by asking a central server to referee. Local-first systems use data structures called CRDTs that can merge any order of edits and always arrive at the same result.

CRDTs have a reputation for being exotic. In practice, mature libraries now hide most of the mathematics, and the remaining design question is a human one: what should happen when two edits genuinely conflict?

• Prefer merging automatically when intent is obvious, such as two different fields changing.
• Surface conflicts visibly when the same sentence was rewritten twice.
• Keep history, so any merge can be undone.

Why users notice

Speed is the first thing people mention. Search is instant because the index is next to the data. Typing never stalls. Airplane mode is no longer a special case.

Privacy follows naturally. When the primary copy lives on your device, the company running the sync service can hold only encrypted blobs, which narrows what a breach or a subpoena can reveal.

It is strange to realise how much of the modern web is an elaborate way of making a database feel nearby.

Where it struggles

Large shared datasets, heavy analytics and anything that needs a single authoritative answer, such as a bank balance, still belong on a server. Local-first is a better default for documents, notes, drawings and task lists, not a universal replacement.

Tooling is also young. Debugging a bug that only appears after three devices merge in a particular order is a new kind of difficult. Teams that succeed tend to invest early in replayable logs and good test generators.

What to watch next

The most interesting experiments are in collaborative editors and design tools, where users already expect instant response. If they succeed, the next generation of software may feel less like visiting a website and more like owning a tool again.