Modern users demand applications that are fast, collaborative, and work seamlessly, even with unreliable network connections.
Building these realtime and offline-first experiences with traditional databases is a significant engineering challenge, often requiring complex infrastructure with event buses, WebSockets, and custom-built state synchronization logic that is expensive to build and brittle to maintain.
StatelyDB provides a powerful, out-of-the-box solution with the SyncList API. This primitive for efficient delta synchronization radically simplifies the development of realtime, collaborative, and offline-first applications.
Stop building complex infrastructure and start delivering the responsive experiences your users expect.
The core problem with keeping clients up-to-date is inefficiency. Most applications resort to polling, repeatedly asking the server for the latest data. 99% of the time, nothing has changed, yet the server re-queries the entire dataset from the database and sends it over the wire, wasting money, bandwidth, and energy.
The core problem with keeping clients up-to-date is inefficiency. Most applications resort to polling, repeatedly asking the server for the latest data. 99% of the time, nothing has changed, yet the server re-queries the entire dataset from the database and sends it over the wire, wasting money, bandwidth, and energy.
The core problem with keeping clients up-to-date is inefficiency. Most applications resort to polling, repeatedly asking the server for the latest data. 99% of the time, nothing has changed, yet the server re-queries the entire dataset from the database and sends it over the wire, wasting money, bandwidth, and energy.
The core problem with keeping clients up-to-date is inefficiency. Most applications resort to polling, repeatedly asking the server for the latest data. 99% of the time, nothing has changed, yet the server re-queries the entire dataset from the database and sends it over the wire, wasting money, bandwidth, and energy.
StatelyDB’s SyncList API flips this model on its head. Instead of asking "give me everything," your application asks, "what's changed since the last time I checked?"
An application makes an initial List request to get a set of data.
An application makes an initial List request to get a set of data.
Along with the data, it receives a sync token, which is like a bookmark for that point in time.
Along with the data, it receives a sync token, which is like a bookmark for that point in time.
On all subsequent requests, the application sends the token to the SyncList API.
On all subsequent requests, the application sends the token to the SyncList API.
StatelyDB returns only the delta - a list of items that have been added, changed, or deleted since that token was issued. If nothing has changed, the response is nearly empty.
StatelyDB returns only the delta - a list of items that have been added, changed, or deleted since that token was issued. If nothing has changed, the response is nearly empty.
This delta sync model is a game-changer for building modern applications.
StatelyDB’s SyncList API flips this model on its head. Instead of asking "give me everything," your application asks, "what's changed since the last time I checked?"
StatelyDB’s SyncList API flips this model on its head. Instead of asking "give me everything," your application asks, "what's changed since the last time I checked?"
An application makes an initial List request to get a set of data.
Along with the data, it receives a sync token, which is like a bookmark for that point in time.
On all subsequent requests, the application sends the token to the SyncList API.
StatelyDB returns only the delta - a list of items that have been added, changed, or deleted since that token was issued. If nothing has changed, the response is nearly empty.
StatelyDB’s SyncList API flips this model on its head. Instead of asking "give me everything," your application asks, "what's changed since the last time I checked?"
This delta sync model is a game-changer for building modern applications.
Users expect your application to work on a plane, in a subway, or anywhere with spotty connectivity. Building this resilience requires caching data locally and intelligently syncing changes when the network returns. This is notoriously difficult to get right.
Your application can fetch an initial dataset and store it locally in the browser (e.g., IndexedDB) or on a mobile device.
Your application can fetch an initial dataset and store it locally in the browser (e.g., IndexedDB) or on a mobile device.
When the application comes back online, it simply calls SyncList with its last saved token. It receives a small, efficient payload of all the changes that occurred while it was offline.
When the application comes back online, it simply calls SyncList with its last saved token. It receives a small, efficient payload of all the changes that occurred while it was offline.
The application can then merge these changes into its local cache, bringing its state perfectly in sync with the server.
The application can then merge these changes into its local cache, bringing its state perfectly in sync with the server.
As we detailed in our post "Reducing DynamoDB read costs by 60% using Sync," this pattern allowed the popular application Destiny Item Manager to not only improve its offline capabilities but also dramatically cut its database costs.
As we detailed in our post "Reducing DynamoDB read costs by 60% using Sync," this pattern allowed the popular application Destiny Item Manager to not only improve its offline capabilities but also dramatically cut its database costs.
Users expect your application to work on a plane, in a subway, or anywhere with spotty connectivity. Building this resilience requires caching data locally and intelligently syncing changes when the network returns. This is notoriously difficult to get right.
Users expect your application to work on a plane, in a subway, or anywhere with spotty connectivity. Building this resilience requires caching data locally and intelligently syncing changes when the network returns. This is notoriously difficult to get right.
Your application can fetch an initial dataset and store it locally in the browser (e.g., IndexedDB) or on a mobile device.
When the application comes back online, it simply calls SyncList with its last saved token. It receives a small, efficient payload of all the changes that occurred while it was offline.
The application can then merge these changes into its local cache, bringing its state perfectly in sync with the server.
As we detailed in our post "Reducing DynamoDB read costs by 60% using Sync," this pattern allowed the popular application Destiny Item Manager to not only improve its offline capabilities but also dramatically cut its database costs.
Users expect your application to work on a plane, in a subway, or anywhere with spotty connectivity. Building this resilience requires caching data locally and intelligently syncing changes when the network returns. This is notoriously difficult to get right.
Building features like collaborative document editing, shared whiteboards, or live dashboards requires keeping multiple clients in sync in real-time. This often leads teams down the complex path of managing persistent WebSocket connections.
Clients can poll the SyncList API at a high frequency (e.g., every few seconds). Because the API only returns deltas, these frequent checks are incredibly lightweight and cheap.
Clients can poll the SyncList API at a high frequency (e.g., every few seconds). Because the API only returns deltas, these frequent checks are incredibly lightweight and cheap.
When one user makes a change, other clients will pick it up on their next sync poll and can update their UI instantly. This provides a near-realtime experience without the operational overhead of a complex event-driven architecture.
When one user makes a change, other clients will pick it up on their next sync poll and can update their UI instantly. This provides a near-realtime experience without the operational overhead of a complex event-driven architecture.
Building features like collaborative document editing, shared whiteboards, or live dashboards requires keeping multiple clients in sync in real-time. This often leads teams down the complex path of managing persistent WebSocket connections.
Building features like collaborative document editing, shared whiteboards, or live dashboards requires keeping multiple clients in sync in real-time. This often leads teams down the complex path of managing persistent WebSocket connections.
Clients can poll the SyncList API at a high frequency (e.g., every few seconds). Because the API only returns deltas, these frequent checks are incredibly lightweight and cheap.
When one user makes a change, other clients will pick it up on their next sync poll and can update their UI instantly. This provides a near-realtime experience without the operational overhead of a complex event-driven architecture.
Building features like collaborative document editing, shared whiteboards, or live dashboards requires keeping multiple clients in sync in real-time. This often leads teams down the complex path of managing persistent WebSocket connections.
With StatelyDB's SyncList API, you have the foundational tool to build the fast, collaborative, and resilient applications they demand, without the typical complexity.