Show HN: Vaultrice – A real-time key-value store with a localStorage API

[adrai]

Hi HN,

I'm Adriano, one of the makers of Vaultrice. I'm excited (and a little nervous!) to share what we've been building.

For years, we found ourselves in a frustrating loop: whenever we needed a simple real-time feature—like a "who's online" list, a collaborative app, or just sharing state between a marketing site and our main app — we'd end up spending days setting up the same stack or discarded to do it. Setting it up, it always involved wiring together a database, a WebSocket server, an API, and managing the connection state. It felt like massive overkill for what we were trying to achieve.

We wanted a tool that felt as simple to use as the browser's `localStorage` API but worked across domains and devices, with real-time sync and security built-in.

So, we built Vaultrice.

It’s a key-value data store built on top of Cloudflare's Durable Objects, which gives you a strongly consistent backend for each data object. You interact with it through our TS/JS SDK, which comes in two flavors:

1. `NonLocalStorage`: A low-level client with a `localStorage`-like API (`setItem`, `getItem`, etc.) plus real-time events and presence (`.on()`, `.join()`).

2. `SyncObject`: A higher-level, reactive JavaScript Proxy. You just change a property on an object (`doc.title = 'New Title'`), and it automatically syncs to all other connected clients.

The goal is to let you build the real-time features you want in minutes, not days. We've also put a lot of thought into a layered security model, allowing you to go from simple API key restrictions all the way to server-signed object IDs and client-side E2EE.

We’ve just launched and would be grateful for any feedback from the HN community. What do you think of the API design? Are there use cases we haven't considered? Any thoughts on the security model?

We'll be here (or via email ([e-mail])) to answer any questions. Thanks for checking it out!

[RestartKernel]

I love the API, but it's a tough sell as a SaaS first — who knows if you'll still be around after I've built my infra around your SDK?

[adrai]

The team behind vaultrice.com is the same team behind locize.com and i18next.com...

[taherchhabra]

Just yesterday my son built a zombie shooter game in chatgpt, then shared the link with his friend, both were able to play individually, then my son asked can we play together and shoot each other. I was wondering is there something like localstorage but for network which chatgpt can easily use it. Can this work for my son's use case?

[adrai]

Yes — that’s exactly the kind of thing Vaultrice is designed for.

Think of it like localStorage, but instead of being tied to one browser on one device, the data lives in a globally-available, real-time object. Any change one player makes (like moving their character or firing a shot) can be sent instantly to the other player’s browser — without having to set up your own server or WebSocket layer.

For your son’s zombie shooter: • Each game session could be one Vaultrice “object” (with an id like game-123). • Each player writes their position, health, actions to that object. • The other player’s browser listens for changes and updates the game state instantly. • Presence tracking is built-in, so you can show “who’s in the game” without extra code.

The nice part is that the SDK’s API feels familiar — setItem, getItem, and on() for events — so you can get a working multiplayer prototype with just a few lines. If you want even less boilerplate, the SyncObject API lets you just set properties on a shared object and Vaultrice syncs it behind the scenes.

It won’t handle game physics for you, but it’s a fast, simple way to make a turn-based or moderately real-time multiplayer experience without hosting your own backend.

[santa_boy]

Yet to explore but just reading few snippets ... is this good for offline first apps?

If not, any others you recommend for that use-case?

If yet, is this ready enough for production use?

[adrai]

Hey, thanks for the great questions!

Offline-first: That's a key distinction. The Vaultrice SDK is currently designed for "online-first" and "offline-sometimes" use cases. Its main strength is real-time, consistent synchronization that relies on an active connection.

Proper offline-first support with automatic conflict resolution is on our roadmap, as we have a backlog item for it ;-) However, you can easily achieve a robust offline capability in your own code today by using localStorage as a fallback.

Here’s a simple wrapper pattern (not tested, just for illustration) that reads from Vaultrice when online and falls back to a local cache when offline:

import { NonLocalStorage } from '@vaultrice/sdk';

// --- A simple offline-first wrapper --- function createOfflineStore(credentials, id) { const vaultriceStore = new NonLocalStorage(credentials, id); const localCacheKey = `vaultrice_cache_${id}`;

  // Helper to get local data
  const getLocal = () => JSON.parse(localStorage.getItem(localCacheKey) || '{}');

  return {
    // SET: Write to both Vaultrice (if online) and localStorage
    async setItem(key, value) {
      // Always update the local cache immediately
      const localData = getLocal();
      localData[key] = value;
      localStorage.setItem(localCacheKey, JSON.stringify(localData));

      try {
        // Attempt to write to the cloud
        await vaultriceStore.setItem(key, value);
      } catch (error) {
        console.warn('Offline: Data saved locally.', error.message);
      }
    },

    // GET: Try Vaultrice first, fallback to localStorage
    async getItem(key) {
      try {
        const item = await vaultriceStore.getItem(key);
        if (item) {
            // Optional: Update local cache with fresh data
            const localData = getLocal();
            localData[key] = item.value;
            localStorage.setItem(localCacheKey, JSON.stringify(localData));
            return item.value;
        }
      } catch (error) {
        console.warn('Offline: Reading from local cache.', error.message);
      }
      // Fallback to local cache
      return getLocal()[key];
    }
  };

}

Production Readiness: Yes, for its intended use case, Vaultrice is ready for production. We've put a lot of focus on a layered security model (from API key restrictions to E2EE) and built it on top of Cloudflare's infrastructure, which gives us a reliable and scalable foundation.

Hope that helps clarify things! Appreciate you checking it out.

[djfobbz]

I thought you could easily achieve this (a global real-time object) with convex.dev?

[adrai]

The team at Convex is building an awesome product. You're right that you can absolutely achieve real-time functionality with Convex, but we think about the problem with a different philosophy and focus.

The way we see it, it comes down to the level of abstraction and what problem you're trying to solve:

Convex is a powerful, full-featured backend platform. It gives you a database, serverless functions (mutations and queries), and file storage. It's a fantastic choice if you're looking to build your entire backend on a modern, reactive stack. You write your logic in server-side functions, and Convex provides the infrastructure.

Vaultrice aims to be a simpler, more focused real-time component that often requires no backend code from you at all. Our goal is to feel like a frontend tool—like a "cloud-based localStorage".

The key difference is in the developer experience:

With Vaultrice, for things like cross-domain state sharing or a simple "who's online" list, you just instantiate our SDK on the client with your credentials and start using it. There are no backend functions to write. Our SyncObject API, where you just modify a JavaScript object and it syncs, is designed to completely abstract away the server.

So, a good way to think about it might be:

Choose Convex when: You need a complete backend replacement, with server-side logic, schema validation, and complex queries.

Choose Vaultrice when: You already have a backend (or don't want one for this feature) and you just need to drop in a real-time, cross-domain state layer with a dead-simple, frontend-friendly API.