Local-First Software: The Sync Engine Became the Product

Seven years after Ink & Switch published the local-first essay, the movement stopped being a manifesto and became a procurement decision. The tell isn't the philosophy — it's that 2026 has been declared "the year of the sync engine" by the people selling them, and for once the data backs the marketing up. Companies now advertise their sync layer the way they used to advertise their cloud. That's a product pitch, not a hobbyist slogan.

From Manifesto to Product Category

The original 2019 Ink & Switch essay laid out seven ideals — fast, multi-device, offline, collaboration, longevity, privacy, and user ownership — and for years they read as a wishlist for a niche of markdown-note apps[1]. What changed is that the hard technical problem got productized. CRDTs went from academic papers to shippable libraries like Automerge, whose "batteries-included" toolkit releases turned merge logic from a distributed-systems PhD project into an afternoon of integration work[2]. Once conflict resolution came off the critical path, the economics of building local-first flipped entirely.

The community infrastructure grew up alongside the code. Local-First Conf in Berlin packed a "big tent" of academic researchers, startup founders, and enterprise developers — with panel debates on whether sync engines should be pragmatic UX tools or carry the full ideological weight of user ownership[3]. The PowerSync team's writeup of that conference captures the moment perfectly: the density of genuinely invested people was unusual, the debates were real, and the community finally made progress on the once-endless argument over what "local-first" actually means. There's even a dedicated Sync Conf now, running in San Francisco. Movements get conferences; products get roadmap slides. Local-first now gets both, which is exactly what an industry-in-the-making looks like from the inside.

Databricks Just Paid Real Money for a Sync Engine

Here's the fact that should end any remaining skepticism about whether this is a real market: in August 2026, Databricks acquired Electric — the company behind PGlite, the embeddable Postgres that runs in browser tabs and on edge devices, plus a real-time sync engine — explicitly to bring local Postgres to AI agent sandboxes[4]. Read that again. One of the most valuable data companies on the planet didn't buy a dashboard or a model — it bought a sync engine and an embedded database, because AI agents need fast local state and the cloud alone can't provide it. When sync infrastructure commands acquisition-level valuations, the sync engine has officially become the product.

The timing tracks with a broader tooling wave. ElectricSQL shipped version 1.1 with a new storage engine delivering 100x faster writes[5], the InfoQ conference circuit now features full talks on building production apps on sync engines as a mainstream architectural pattern[6], and even the AI angle runs through the same pipes — Databricks didn't buy Electric for humans with laptops; it bought it because AI agents need sandboxed local state, and an embedded Postgres with sync is exactly that. The RxDB ecosystem alone documents sync adapters for every backend you can name, and browser storage APIs like OPFS have matured to the point where the client-side database is no longer the bottleneck[7].

What Users Actually Get in 2026

Concrete wins, already shipping in mainstream apps:

• Instant everything. UIs read from local storage, so there's no spinner on your own data. The Smashing Magazine deep-dive on local-first architecture in 2026 opens with exactly the failure mode this kills: a project-management tool that couldn't show the author his own task board without a two-second server round-trip[8].
• Offline is a mode, not an error state. Airplane mode stopped being a failure screen in the best implementations.
• Privacy as architecture. When encryption is layered on CRDT sync, the server relays ciphertext it mathematically cannot read — "we value your privacy" became a property of the protocol instead of a policy document.
• Longevity. Data in an open format on your own disk outlives the vendor. Every shut-down cloud service that took users' notes with it is an argument for this movement that writes itself.

There's also a quieter infrastructure story underneath all of this: the browser itself became a local-first platform. Origin Private File System, WebAssembly-compiled databases, and service workers turned the tab into a genuinely capable application runtime with real persistence — which is why the same engine that powers a note app now powers an AI agent's working memory. The browser vendors didn't set out to build local-first infrastructure; they set out to make web apps competitive with native ones, and local-first architecture fell out of that as a side effect. Some of the most important platform shifts arrive unannounced, as optimizations for something else entirely.

The Honest Caveats

Now the part the conference talks skip. Sync engines are hard at the edges: CRDT metadata bloats documents, conflict resolution and client-side schema migrations remain genuinely tricky distributed-data problems, and revoking a collaborator's access is still awkward in merge-everything systems[7]. There's also an ideological split the community itself argues about — pragmatists like Zero's Aaron Boodman have taken flak for excluding offline writes from their sync engine entirely rather than ship a half-baked version, which tells you how unsettled the semantics still are[3].

And the lock-in question hasn't vanished; it's moved. Swapping your app's sync engine two years in is roughly as painful as swapping your database, so dependency has been relocated from the server to the SDK — better, because there's real competition in that layer now, but let's not pretend dependency is gone. One honest guide for SaaS builders puts it bluntly: don't build a sync engine from scratch unless the sync engine is your product. Which is precisely the point — for almost everyone, it shouldn't be, because for a few companies it already is.

What I Think

I think 2026 is the year local-first stopped being a value statement and became table stakes for a category of software. Within five years, "your app needs a network round-trip to display my own data" will read the way "your app requires Flash" reads today — an architectural embarrassment. The Databricks–Electric deal is the signal I'd point to first: when the data-platform establishment starts acquiring sync engines, the infrastructure era of local-first has begun, and infrastructure eras are where real money and real defaults get set.

The deeper bet: sync engines commoditize the cloud's role down to what it should have been all along — a cheap, reliable relay. Every company whose entire moat was "we hold your database" should read the Databricks news with some discomfort. The interesting companies of the next cycle will sell speed, craft, or intelligence — things that survive the user walking away with their own files. That's not nostalgia for .txt files. It's just better engineering, and this time the tooling, the conferences, and the acquisitions all finally agree.