Redefining Local-First Software: Decentralizing the Centralized Public Cloud

By Reid Christian and Chiraag Deora

Technology works in cycles. Right now we are seeing an overreaction to the public cloud, the pendulum swung too far and is swinging back. Mass underlying platform changes — including the movement from on premises to cloud to AI — drive new software paradigms across application architectures and developer workflows. AI specifically is ushering a wave of highly data-intensive applications, which could require software architectures to be reevaluated from the ground up in order to enable high performance, best-in-class user experience and data protection.

Local-first software, rather than applications running on a large centralized cloud, is a development approach that is ready for its moment in the spotlight and has impacts on software development as well as end user applications.

How Did We Get Here?

Taking a step back, studying computing from the past is important context to understand what may be necessary going forward.

1950s: Mainframes

Many of computing’s origins began with the mainframe, which was highly available, highly scalable and processed large amounts of small data rapidly. They were used for many purposes including customer order processing, payroll and inventory control through a request-response mechanism to interactive remote user terminals. While effective, mainframes required significant maintenance and high degrees of customization.

1980s: Personal Computers (PCs)

Standalone, personal systems started to proliferate which allowed individuals access to productivity suites including spreadsheets, presentations, word processing and data management. PCs were originally not collaborative in nature, nor “online” and were not capable of receiving external information.

1980s: Client/Server

Prior to this wave, computing was centralized. Client/server now invoked a distributed computing mechanism that allowed for clients, or PCs, to network to servers, which processed and stored shared data across the network. From this wave, computing began to become more collaborative in nature.

1990s-2000s: Internet and Mobile

The internet allowed for consumers and enterprises to consume information in a further distributed manner. Specifically, the internet protocol suite (TCP/IP) was more broadly adopted, which specified how data should be packetized, transmitted, routed and received. This allowed enterprises to tie networks together and work across mass amounts of data. The internet also led to the emergence of mobile and smartphones.

2010s: Cloud

Cloud computing allows for significant efficiencies to the client/server model by leveraging the power of the internet to allow applications to use shared resources via the network (including compute, storage and networking). The proliferation of cloud has allowed for more iterative and flexible application development processes along with business process optimizations.

Each architectural shift from the various eras of computing have been driven by more powerful processors, which have then furthered the capabilities of applications being developed. As Moore’s Law comes to an end and we’ve reached a high degree of processing power, applications being built may now instead drive what the requisite architecture should be.

What’s Changing?

Cloud-first software has been a significant boon to virtually every industry across the globe, however, given how increasingly data-intensive applications are becoming (especially with the boom in AI) cloud may not be the best path forward. Having applications run against a large centralized cloud which drives inherent latency and also maintains ownership of all your data creates some obvious problems.

Local-first software shifts the model, by again leveraging a client’s local device as the source of truth for the data using a local database, rather than an external server, and then sync data to other devices. This way of building software drives some major benefits:

1. Instant Response Times: With the cloud, data resides on a server so speed is limited by how quickly responses can be received from the server. Local software keeps the data on the device, so you don’t have to wait for requests to be completed. This drives an immense improvement to customer experience.
2. Offline Applications: Local-first software doesn’t require accessing data from a network, so people can access, interact and edit applications while offline. When devices come back online, data is synced across devices.
3. Data Ownership and Security: Because the data lives within your local device, you truly own the data versus when data is hosted in the cloud, or “somebody else’s computer.” This also drives an improvement in security because your local device is much less likely to be the victim of mass cyberattack.

These benefits can be recognized whether you’re an end user working with local-first software or a developer building with local-first development paradigms, especially given how powerful CPUs have become.

Who’s Already In?

The benefits of local-first software span across developers as well as end users.

For Developers: Given the raw advancements in PCs, the burden of working with cloud-based developer tools is becoming too cumbersome when those same tasks can be completed locally at faster speeds and without the hair pulling. With the right local-first tooling, collaborative development can still be enabled through syncing and appropriate version control.

For End Users: There are prominent examples of leading software companies leveraging local-first software to drive an exceptional customer experience, including Google Docs, Figma and Notion. All of these tools allow for users to work offline, but specify the limitations by doing so.

What is most exciting about both these categories is that they are inherently collaborative processes, which is arguably the most complicated part of local-first software. Local-first would be a simpler approach if users were only reliant on their own data, but what makes it exciting is the potential of solving real-time collaboration across multiple users in varying locations while still gaining the aforementioned benefits.

Who’s Making This Possible?

Local-first practices have primarily been DIY so far, which is possible when highly sophisticated technical talent is available as it has been in the examples previously mentioned. Given the increasing desire for local-first software, we have seen pioneers building enabling technology across the technology stack.

Developer Workflows:

Edge Compute: Brings compute closer to the sources of data in order for lower latency and more efficient bandwidth use. This would reduce reliance on the cloud and potentially shift compute as far as the end device, though it could also be at an edge node in a region near to the device.

Cloud Emulation: Allows developers to emulate the development and testing of cloud services offline on local devices. This allows for quicker and more iterative development without having to deal with the potential sluggishness of the cloud.

WebAssembly (WASM): WebAssembly is code that can be run in modern web browsers that allows a variety of programming languages to compile to a single binary for execution. Since WebAssembly is lightweight (smaller than a container), doesn’t require the handling of distinct OS, and can start instantly, it can be an effective layer to serve local-first.

Application Architectures:

Syncing/CRDT: Solutions that enable data syncing between devices as changes are made, including syncing from offline devices when they turn back online. Conflict-free Replicated Data Type (CRDT) are data structures that simplify distributed data storage systems and multi-user applications, which can provide a basis for data syncing.

Database: Local-first software is reliant on an embedded database being available locally against devices. These databases allow applications to store the data locally. SQLite is built upon many attributes that could make it a database of choice for local-first software.

Networking:

Platforms that allow for end devices to maintain control and core application logic while providing the network layer for connectivity across devices.

At CRV, we’re excited about the prospect of swinging the pendulum from public cloud towards local-first development and local-first applications. If you are a founder building at the earliest stages across this domain, our team would love to connect with you.