Our phones can literally run Fortnite and its billions of triangles, but my to-do app needs to make a network call just to load my tasks? We need to find a better balance with the cloud.

• Rashid Aziz, CEO of Basic

​

Summary

Basic provides the option to utilize some of the best database technologies available today - local-first sync. We make it easy for you to achieve benefits like instant UI, offline support, and real-time capabilities while still syncing to the cloud automatically.

All you need to get set up is our client SDK.

​

What is local-first sync?

Simply put, local-first sync is a paradigm that’s becoming quickly popular where reads/writes happen to the local database on the client device first, after which data is automatically synced to the cloud in the background.

Unlike a local-only architecture, local-first sync provides the benefits of a cloud database (multi-device support, real-time collaboration, global scale). Similarly, unlike a pure cloud app, local-first has benefits like instant UI, offline support, and fast local performance often found in local-only apps.

With the rise of really powerful web apps that demand more responsive UIs while needing to be highly collaborative (such as Figma, Linear, Notion, etc.), local-first sync has become a popular approach for both adopters and tool makers.

​

Benefits of local-first sync

​

Instant and snappy UI

One of the immediately noticeable benefits of local-first sync is how snappily the UI responds to user actions.

For example, in the Regular UI, there’s a small delay between when a user clicks the “Add” button and when the UI updates to reflect the new item. This is because the action requires a network request to the server to update the database, for the client to receive the new state, and the UI to re-render.

In the Instant UI example, the UI updates immediately after the user clicks the “Add” button because the action only requires updating the local database. Changes are synced to the cloud in the background without any visible latency to the user.

​

Fewer network calls

In a local-first sync environment, every primary read/write operation occurs directly to the local database, drastically reducing the number of network calls to the server. This change in data operations has two primary benefits:

​

Simpler architecture

A local-first sync engine replaces the need for a bloated backend, simplifying your stack and reducing engineering overhead.

Traditional stacks require spinning up and maintaining a backend to make API calls to the database. In contrast, local-first sync architectures allow the frontend to interact directly with a local database while the sync engine manages cloud database communication.

The simpler architecture translates to faster development cycles for your developers with less backend code to maintain.

​

Automatic state management

Traditionally, developers need to update state with the data fetched from their API requests.

Basic’s client SDKs contain hooks that listen for changes and automatically update state on the frontend. This translates to significantly less code for developers to write, test, and maintain as is evident from the example above.

Now, you can access data as simply as db.table('tablename').get() without worrying about updating state.

​

Offline support

Connection gets spotty for users in various situations - if they’re going through a tunnel, hiking through a less populated park, or even just in a crowded coffee shop.

Rather than eliminating your users’ ability to use your app in these situations, local-first sync ensures they can continue working with your app.

This not only reduces their frustration and increases your retention but also saves your developers the time of implementing loading states for every UI element they build.

​

Real-time capabilities

The future of the internet has proven itself to be collaborative. But building real-time capabilities is very hard and takes away your developers’ time from building other features.

Basic’s local-first sync engine comes with built-in real-time capabilities so your users can use your app with their friends and coworkers with no additional engineering on your part.

​

Trade-offs with local-first sync

It would be insincere to discuss a new technology without mentioning its trade-offs. Here are a few we’ve identified:

​

How to use local-first with Basic

All of Basic’s local-first sync capabilities come built-in with our client SDKs.

You can get started by installing the SDK.