Local-First Apps Explained: Why Developers Are Moving Data Off the Cloud
Local-First Apps Explained: Why Developers Are Moving Data Off the Cloud
Introduction
Discover what local-first apps are, why developers are moving data off the cloud, and how SQLite, CRDTs, and sync engines make offline-first software possible.
For years, building an app followed a fairly predictable formula. You created a frontend, connected it to a backend, stored everything in a cloud database, and made the user's device request data whenever it needed something.
It worked. Really well, actually.
But it also created a dependency that developers and users have gradually learned to accept. No internet? The app struggles. Slow server? Everything feels sluggish. Service discontinued? Your carefully organised data might become difficult to access.
And honestly, that's a strange situation when you think about it. We have incredibly powerful smartphones and laptops, yet many applications still behave as if these devices are little more than screens connected to somebody else's computer.
That's where local-first software comes in.
Instead of treating the cloud as the permanent home of your data, local-first applications keep the primary working copy on your device. The cloud still has a role, but it becomes responsible for synchronisation, backups, and collaboration rather than controlling every interaction.
This isn't simply another development trend. It's a different way of thinking about performance, privacy, data ownership, and the future of software.
For freelance developers and digital agencies, it also creates an interesting opportunity: clients increasingly need applications that remain responsive, reliable, and useful even when the internet isn't cooperating.
Let's break down how local-first apps work, why developers are adopting them, which technologies make them possible, and whether this architecture makes sense for your next project.
What Is Local-First Software?
Imagine opening a note-taking app to write down an idea.
In a traditional cloud-based application, your device might send a request to a remote server, wait for the response, and then display the updated information. Even if the app makes that process look seamless, your interaction still depends on the network.
A local-first application approaches the same task differently.
It saves your note directly to your device first. You can continue writing, editing, searching, and organising your information without waiting for a server. When an internet connection becomes available, the application synchronises the changes with your other devices.
Think of it like having a personal filing cabinet in your office instead of keeping every document in a storage facility across the country. You can open your files whenever you need them, while a courier service makes sure updated copies reach your other locations.
That's the basic idea.
The cloud hasn't disappeared. Its job has changed.
Where Did the Local-First Concept Come From?
The term became widely known through a 2019 essay published by the research lab Ink & Switch.
The essay, titled Local-first software: You own your data, despite the cloud, was written by Martin Kleppmann, Adam Wiggins, Peter van Hardenberg, and Mark McGranaghan.
Their argument was straightforward: users should enjoy the collaboration and convenience of cloud applications without giving up control over their own data.
The authors outlined seven ideals for local-first software:
- Fast: Reading and writing data should happen locally, without waiting for network requests.
- Multi-device: Information should synchronise across phones, tablets, and computers.
- Offline-capable: Users should be able to continue working without an internet connection.
- Collaborative: Multiple people should be able to work on shared information.
- Long-lived: Data should remain accessible even if the original software company disappears.
- Private: Encryption should protect information, including from the service provider where appropriate.
- User-controlled: People should be able to export, move, and manage their own data.
These principles are still useful when evaluating local-first architecture today. You can read the original research here:
Ink & Switch: Local-first software.
inkandswitch.com+1
Local-First Is Not the Same as Offline-Only
This distinction matters.
An offline-only application might store everything on one device and never communicate with a server. That's useful for certain tools, but it creates another problem: accessing your information from multiple devices or collaborating with other people becomes difficult.
Local-first software tries to provide both experiences.
You can work independently when disconnected, then synchronise your changes when connectivity returns.
Think of it like working on a document during a long flight. You don't need permission from an internet connection to keep typing. Once you land, your changes can travel to your other devices.
Offline capability is part of the experience, not a separate emergency mode.
Why Are Developers Moving Data Off the Cloud?
The cloud isn't going away. However, developers are becoming more interested in deciding which operations actually need a remote server and which ones can happen directly on the user's device.
There are several reasons behind this shift.
1. Faster Apps Without Constant Server Requests
Users notice delays.
They might not understand API latency, database queries, or network round trips, but they definitely notice when clicking a button produces a loading spinner instead of an immediate response.
In a traditional architecture, an application may need to contact its backend before displaying updated information. This becomes particularly noticeable when users have slow connections or are located far away from the server.
Local-first architecture reduces that dependency.
When the application reads and writes to a local database, most everyday interactions can happen immediately. Synchronisation continues separately in the background.
Imagine a restaurant kitchen. The chef shouldn't need to telephone a supplier every time someone orders a glass of water. The restaurant keeps commonly needed supplies nearby and contacts suppliers when stocks need replenishing.
Local-first applications follow a similar principle: keep frequently needed information close to the user.
For freelancers building dashboards, project-management platforms, creative tools, and document editors, this can make a noticeable difference to the user experience.
2. Offline Access Becomes a Normal Feature
Internet access isn't equally reliable everywhere.
A client might be travelling, working from a basement office, attending an event, or using a mobile connection that drops every few minutes. In some regions, unreliable connectivity is simply part of everyday life.
A cloud-dependent application can turn these situations into frustrating error messages.
A local-first application can keep working.
For example, consider a field-service application used by technicians visiting customer locations. They should be able to view job details, add notes, update task statuses, and record information without needing a continuous connection.
When the connection returns, the application synchronises the pending changes.
And this isn't just a theoretical benefit. Developers discussing offline-first projects on Reddit have highlighted the difference between designing for offline use from the beginning and trying to add it later. One developer described how an expense-tracking app initially depended on backend requests, then required a separate offline mode when users experienced connectivity problems. The retrofit made the experience less seamless than building around local data from the start.
Reddit+1
You can read the discussion here:
Reddit: Build local-first whenever you can.
3. Better Control Over Privacy and Data
Privacy is another major reason developers are exploring local-first architecture.
Traditional cloud applications often collect large amounts of user information in central databases. That information needs protection against unauthorised access, accidental exposure, and other security risks.
Local-first applications can reduce the amount of personal information that must be stored centrally. Some can also use end-to-end encryption so that synchronisation servers cannot read the underlying content.
But let's be clear: storing data locally doesn't automatically make an application secure or GDPR-compliant.
Developers still need to consider device security, encryption at rest, authentication, access permissions, backups, and data deletion. If sensitive information is synchronised to a cloud service, the security of that process matters just as much.
Think of it like keeping important documents in a locked cabinet rather than leaving them on a shared office desk. The cabinet reduces exposure, but you still need to control who has the key.
For freelancers working with healthcare providers, legal firms, financial businesses, and other clients handling confidential information, this architecture can be particularly interesting.
It may help reduce unnecessary data exposure, provided the complete security design supports that goal.
4. Less Dependence on a Single Service Provider
Here's something people don't always consider when choosing cloud software.
What happens if the company behind your favourite application shuts down?
Or changes its pricing, removes an important feature, or restricts access to an older version?
You might be able to export your information, but that doesn't necessarily mean you can continue using it in the same way.
Local-first software addresses part of this problem by keeping usable data on the user's device.
Consider a freelance designer who has spent three years organising project notes, client feedback, research, and creative references in one application. If that service suddenly disappears, losing access could mean losing a significant part of their working history.
Portable files and local storage offer another layer of protection.
This is closely connected to the original local-first movement's emphasis on long-term data preservation and user control.
inkandswitch.com+1
5. A Different Approach to Server Costs and Backend Complexity
Local-first architecture can also change how an application uses server infrastructure.
When everyday reads and writes happen locally, the application may need fewer repeated network requests. That can reduce some backend workload, especially for applications where users frequently interact with the same information.
But don't assume this automatically means cheaper hosting.
A reliable sync system requires infrastructure too. You still need to handle authentication, remote backups, synchronisation, conflict resolution, and sometimes real-time communication.
In other words, you're moving some complexity rather than making it disappear.
For a small software agency, this is an important distinction when estimating a project. A local-first application might reduce certain API costs while increasing the time required to design and test its data-sync architecture.
The Technology Behind Local-First Applications
A few years ago, building a reliable local-first application could involve considerable custom engineering.
The difficult part wasn't saving information on a device. Developers had been doing that for decades.
The real challenge was keeping multiple copies of the same data consistent when different devices could make changes independently, sometimes without an internet connection.
Fortunately, modern tools have made this architecture more accessible.
1. CRDTs: Automatically Reconciling Changes
CRDT stands for Conflict-free Replicated Data Type.
It's a family of data structures designed to let multiple devices or users make changes independently and eventually converge on a consistent result.
Imagine two designers editing the same shared document. One changes the heading while another adds a paragraph. Both devices are offline.
When they reconnect, the application needs to combine the changes without accidentally deleting someone's work.
CRDTs provide mathematical rules that help make this possible.
Think of them like two people writing in separate copies of the same notebook. Instead of throwing one notebook away, the system uses information about the edits to combine the changes.
Some useful CRDT technologies include:
- Automerge: A library for building applications that store documents locally and synchronise changes between devices.
- Yjs: A CRDT framework for collaborative applications, with support for offline editing and integrations with text editors.
- Loro: Another option for developers building collaborative data structures and editing experiences.
Automerge's documentation provides a practical example of storing documents in browser IndexedDB and synchronising browser tabs through BroadcastChannel.
Yjs, meanwhile, supports shared data types, offline persistence, and different networking approaches.
Explore their documentation:
automerge.org+2
One important point, though: CRDTs don't magically solve every conflict. They help merge compatible changes, but your application still needs business rules for situations where two edits cannot both be accepted.
2. Sync Engines: Keeping Devices in Agreement
CRDTs are one approach to handling concurrent changes. But they aren't the only way to build local-first software.
Sync engines help manage how information moves between local databases and remote servers.
Some tools worth exploring include:
PowerSync
PowerSync keeps a local SQLite database synchronised with a backend database. Its architecture supports local reads and writes, with changes synchronised between the client and server.
It's particularly relevant if you're building an application around an existing database and want a local data layer without designing every part of the synchronisation system yourself.
ElectricSQL
ElectricSQL provides a synchronisation approach built around PostgreSQL and client-side databases. Its documentation is useful for developers exploring partial data replication and reactive applications.
Zero
Zero is another interesting project. Its architecture synchronises the data needed by the interface into a local client datastore, allowing reads and writes to happen locally while updates continue in the background.
powersync.com+2
These tools don't all work identically. Some focus on relational database synchronisation, while others are designed around collaborative documents or different replication models.
The right choice depends on your application, existing backend, and consistency requirements.
3. Local Databases and Browser Storage
Local-first isn't limited to native desktop or mobile applications.
Modern web applications can also store substantial amounts of structured information on the user's device.
A few important technologies include:
SQLite: A lightweight relational database that can run locally in desktop, mobile, and browser-based environments.
IndexedDB: A browser API designed to store larger structured datasets, including objects and indexed records.
Origin Private File System (OPFS): A browser storage feature that provides efficient file access within an application's private storage area.
The last one is particularly interesting for developers building browser-based tools that work with larger datasets.
According to MDN, OPFS is widely available across modern browsers, although its storage is subject to browser quotas and can be deleted when users clear website data.
MDN+1
Read more:
And here's something beginners should remember: browser storage is not the same as a permanent, user-controlled file on the computer. Data stored in IndexedDB or OPFS can be removed under certain conditions.
For important user data, you still need an appropriate backup and export strategy.
Local-First vs. Traditional Cloud Applications: What's the Difference?
The architectural difference becomes easier to understand when you compare how each model handles everyday operations.
Feature | Traditional cloud-first | Local-first |
Primary working data | Remote server | User's device |
Reading information | Often requires a network request | Usually reads locally |
Writing information | Often depends on server confirmation | Saved locally first |
Offline access | Limited unless separately implemented | Core design consideration |
Synchronisation | Server-centred | Background replication |
Collaboration | Usually server-coordinated | Can use CRDTs or other sync strategies |
Data ownership | Depends heavily on provider | Greater local control |
Development complexity | Familiar, established patterns | More complex synchronisation and recovery |
This isn't a competition where one architecture wins every time.
Cloud-first systems remain useful for many applications. Local-first architecture simply offers another way to design products where responsiveness, offline access, and user control matter.
Where Are Local-First Apps Already Being Used?
You don't have to imagine what this architecture might look like. Several familiar products and software projects demonstrate parts of the local-first approach.
How I take notes as a developer is quickly evolving | by Bennett | Medium
Obsidian
Obsidian stores notes as Markdown files in a local vault. Users can access their files directly, while optional synchronisation services make it possible to work across devices.
Linear
Linear is known for a responsive application experience. Its local data and synchronisation approach is an example of how client-side state can help make an application feel immediate.
Use audio to chat with your team – Figma Learn - Help Centre
Figma
Figma demonstrates the value of real-time collaboration in design software. Its collaborative editing model is relevant to local-first research, although it shouldn't be described as a fully local-first application.
Notes User Guide for Mac - Apple Support
Apple Notes
Apple Notes supports on-device note access and synchronisation through iCloud. It illustrates how local access and cloud syncing can work together.
These products don't all follow the same architecture or meet every one of the seven local-first ideals. They're useful examples of individual ideas, not proof that every one is a fully local-first system.
The Challenges Developers Should Understand Before Building Local-First Apps
Now for the less exciting part.
Local-first architecture sounds great when you're talking about instant interactions and offline access. But once you start implementing it, you discover that synchronising data across multiple devices introduces some serious engineering challenges.
And you really don't want to discover these problems after launching a client's application.
1. Conflict Resolution Is More Than a Technical Problem
Imagine two employees editing the same project while offline.
One renames it "Website Redesign," while another changes the name to "New Company Website."
When both reconnect, which version should the application keep?
A CRDT might help merge certain types of data, but it can't decide what the business actually wants.
That's a product decision.
Developers need to define clear conflict-handling rules. Depending on the application, this could mean automatic merging, showing users both versions, using timestamps, or requiring manual confirmation.
For example, combining two paragraphs is different from combining two conflicting payment amounts.
2. Database Migrations Become More Complicated
Traditional cloud applications often have a central database that developers can update in a controlled deployment.
Local-first applications are different.
Thousands of users might have different application versions and local databases. Some devices may remain offline for days or weeks before reconnecting.
That means developers must consider how older clients handle newer data structures, how migrations run safely, and what happens when a user reconnects after a long period.
It's like maintaining thousands of individual shops rather than renovating one central warehouse. Every location needs to remain functional while the changes are introduced.
3. Access Control and Data Revocation Need Careful Planning
Suppose a client gives an employee access to a shared project and later removes that permission.
With a traditional server-based application, blocking future API requests can prevent the user from retrieving additional information.
But what if that information has already been synchronised to the employee's device?
Removing server access doesn't automatically erase a local copy.
This creates a difficult security problem, particularly for applications handling confidential business information.
Developers need to design permissions, encryption, key management, and revocation behaviour together rather than treating access control as a simple backend feature.
4. Local Storage Needs Backup and Recovery
Keeping data on a device gives users more control, but it also creates responsibility.
What happens if their laptop is damaged, their browser storage is cleared, or their phone is lost?
Local-first does not mean backup-free.
A reliable application needs a recovery strategy, which might include encrypted cloud backups, user-controlled exports, device-to-device synchronisation, or a combination of these approaches.
5. Not Every Application Should Be Local-First
Some applications need a central authority to decide what happens.
Consider a payment platform. Two users cannot independently withdraw the same money from an account and expect the system to merge those transactions later.
The same applies to airline seat reservations, inventory management, banking transactions, and other systems where simultaneous actions can affect real-world resources.
These applications still need authoritative server-side validation and transaction processing.
Local-first techniques can improve their interfaces, caching, and offline workflows, but they shouldn't replace the server's responsibility for critical business rules.
6. The Ecosystem Is Still Evolving
The local-first ecosystem has improved, but it isn't as straightforward as building a conventional REST API connected to PostgreSQL.
Different tools have different assumptions about data models, synchronisation, conflict resolution, and backend integration.
Developer discussions reflect this reality. In a September 2025 Hacker News discussion about local-first applications, developers raised concerns about debugging, database migrations, sync complexity, and the difficulty of balancing offline access with multi-device use.
Hacker News+1
You can explore the discussion here:
Hacker News: Why haven't local-first apps become popular?
The takeaway isn't that local-first is too difficult. It's that developers need to treat synchronisation as a core part of the architecture rather than an extra feature added at the end.
Should Freelance Developers Build Local-First Applications?
This is where the topic becomes particularly interesting for freelancers and small development agencies.
Clients don't usually approach you asking for a CRDT implementation or a distributed database architecture. They come with business problems.
A client might want a field-service dashboard that works without internet access. Another might need a collaborative writing platform. Someone else could be planning an inventory application for employees working in locations with unreliable connectivity.
These are opportunities to offer more thoughtful solutions.
Projects That Could Benefit From Local-First Architecture
Note-taking and document applications: Users can create, edit, and search documents without waiting for server responses.
Project-management tools: Teams can update tasks, record progress, and continue working during network interruptions.
Field-service applications: Technicians can access job information, add notes, and update records while visiting remote locations.
Creative and design applications: Users can work with documents, sketches, and other assets locally, with collaboration and synchronisation added where needed.
Personal productivity software: Applications for journaling, planning, habit tracking, and task management can benefit from fast local access and user-controlled data.
How to Add Local-First Skills to Your Development Portfolio
If you're a React, Next.js, Node.js, or mobile developer, you don't need to build a complete collaborative platform to demonstrate your understanding.
Start with something manageable.
Build a small task-management application that saves information in SQLite or IndexedDB. Make sure users can create, edit, and delete tasks without an internet connection.
Then introduce a synchronisation layer.
For example, you could use PowerSync with SQLite and a compatible backend database, or explore Automerge if your project involves collaborative documents.
Add a clear offline indicator, a sync status, and a way to recover or export user data.
Now you have something meaningful to demonstrate to potential clients.
And honestly, a working project that solves a real problem can be more convincing than a portfolio full of generic landing pages.
How to Explain Local-First Architecture to International Clients
Avoid overwhelming clients with technical terminology.
Instead of saying, "I'll implement a CRDT-based replicated data model," explain the benefit:
"Your employees will be able to update project information even when the internet connection drops. Their changes will synchronise automatically when they reconnect."
That's a business outcome.
For a design agency or software freelancer, this distinction matters. Clients pay for reliable workflows, less disruption, and better user experiences—not just the technology underneath them.
How to Start Building a Local-First App: A Practical Approach
You don't have to rebuild an entire application around local-first principles on day one.
In fact, an incremental approach is often more sensible.
Step 1: Identify Which Data Needs Local Access
Start by examining the application.
Does the user need to access project details offline? Should they be able to edit documents without a connection? Which information needs to be available immediately?
Not everything needs to be stored locally.
A dashboard displaying public analytics, for example, might need a different strategy from a document editor containing hours of user work.
Step 2: Choose a Suitable Local Database
For web applications, IndexedDB or OPFS may be appropriate depending on the type and volume of data.
For applications that need a relational database experience, SQLite is worth exploring.
For a React or Next.js developer, this is a good opportunity to understand how the UI can respond to local database changes instead of waiting for every server request.
Step 3: Make Local Writes Work First
When users create or update information, save those changes locally before attempting remote synchronisation.
The interface should immediately reflect the change.
This is often described as an optimistic local update, although the underlying data architecture needs to ensure that the change can be reconciled safely later.
Step 4: Add Synchronisation
Once local operations are working, introduce a sync engine or build a carefully designed synchronisation layer.
You need to consider what happens when devices reconnect, how updates are ordered, how duplicate requests are handled, and what happens when two devices change the same record.
Don't leave these decisions until the end.
Step 5: Test the Uncomfortable Situations
A local-first application shouldn't only be tested when everything works perfectly.
Turn off the internet. Edit the same record on two devices. Restart the application during synchronisation. Try reconnecting an old client. Test what happens when local storage becomes unavailable.
These scenarios reveal problems that ordinary development testing can easily miss.
And that's the difference between an application that technically supports offline mode and one that users can actually trust.
The Future of Local-First Software: What Developers Should Watch
Local-first development is connected to several broader changes in software engineering.
One is the growing interest in applications that keep more computation and data processing on the user's device. This includes browser-based databases, local AI models, and tools that can operate without sending every interaction to a remote service.
Another is the development of better synchronisation systems.
Ink & Switch, for example, continues to publish research related to collaborative software. Its newer projects include Keyhive, focused on local-first access control, and Patchwork, which explores creative working environments.
inkandswitch.com+1
The developer community is also debating what local-first should mean in practice. Some discussions focus on CRDTs and real-time collaboration, while others argue that reliable offline access, backups, and transparent conflict handling deserve equal attention.
A useful example is this 2025 Hacker News discussion, where developers explored the practical and commercial barriers to wider local-first adoption.
Hacker News
There is no guarantee that every SaaS product will move towards this architecture. Some services genuinely need centralised data and computation.
But the broader direction is worth watching: developers have more options for deciding what should happen locally, what should happen remotely, and what should be synchronised between them.
For freelancers, understanding these options could become a valuable addition to an existing full-stack skill set.
The Bottom Line: Local-First Doesn't Mean Leaving the Cloud
Local-first software isn't about declaring war on cloud computing.
It's about giving the cloud a different job.
Instead of acting like a landlord who controls access to everything you create, the cloud becomes more like a courier service: it helps move your data between devices, supports collaboration, and keeps remote backups while your local device remains capable of doing useful work independently.
That's a meaningful change.
Of course, local-first architecture introduces challenges around synchronisation, security, database migrations, and recovery. It won't be the right choice for every product, particularly systems that require strict central coordination.
But for document editors, productivity tools, collaborative applications, and software used in unreliable network environments, it offers a compelling approach.
And if you're a freelance developer, it's worth experimenting with now. Build a small offline-capable application, learn how SQLite and IndexedDB work, explore CRDTs, and understand at least one modern sync engine.
The next client who asks for an application that works anywhere, responds instantly, and doesn't lose data when the internet disappears might appreciate that you already know how to build it.
Frequently Asked Questions About Local-First Apps
1. What is a local-first application?
A local-first application stores its primary working data on the user's device rather than depending entirely on a remote server. It can continue working offline and synchronise changes with other devices when a connection becomes available.
2. What is the difference between local-first and offline-first software?
The terms overlap, but local-first puts particular emphasis on user data ownership and local storage as the primary source of data. Offline-first generally focuses on ensuring that an application remains usable without an internet connection. A product can follow offline-first principles without fully adopting the broader local-first ideals.
3. Are local-first apps better than cloud-based apps?
Neither architecture is universally better. Local-first applications can offer faster interactions, offline access, and greater control over user data. Cloud-first applications can simplify centralised coordination, transaction processing, and large-scale computation.
4. Which technologies are used to build local-first applications?
Common technologies include SQLite, IndexedDB, OPFS, CRDT libraries such as Yjs and Automerge, and synchronisation tools such as PowerSync and Zero. The appropriate combination depends on the application's data model and collaboration requirements.
5. Do local-first applications need a backend?
Not necessarily, but many use a backend for authentication, synchronisation, remote backups, collaboration, and other services. Local-first changes the role of the backend rather than requiring developers to remove it entirely.
6. Are local-first applications secure?
They can improve privacy by reducing centralised data storage and supporting end-to-end encryption. However, local storage alone doesn't guarantee security. Developers still need encryption, authentication, access control, secure backups, and appropriate data-recovery mechanisms.
7. Can I build a local-first application with React and Next.js?
Yes. You can use browser storage technologies such as IndexedDB or OPFS, combine them with local databases and suitable synchronisation tools, and build a React interface that reads and writes locally. The important part is designing the data and sync architecture carefully.
Editorial note: The examples above distinguish between products that demonstrate local storage or collaboration and applications that fully satisfy all seven local-first ideals. That distinction is important for technical accuracy.

