DEV Community: Nishant Bhatte

Delete the backend: shipping v0.5 of a CRDT relay where the server can't read your data

Nishant Bhatte — Sun, 05 Jul 2026 17:57:17 +0000

Yjs, Automerge, and Loro are excellent CRDT libraries — but they leave the server problem to you. You still write API endpoints. You still design a persistence layer. You still bolt on auth.

Aether-Core deletes that entire stack.

The pitch in one code snippet

Before:

function ShoppingList() {
  const [items, setItems] = useState([]);
  // ... plus API endpoint, database schema, auth middleware, ...
}

After:

function ShoppingList() {
  const [items, setItems] = useAether('items', []);
  // that's the whole change. multiplayer, offline, persisted.
}

The Python relay treats every value as opaque bytes. It doesn't implement business logic. It doesn't have endpoints. It cannot read your data.

What's new in v0.5

End-to-end value encryption. Optional client-side AES-256-GCM wraps every value before it leaves the browser. The relay sees ciphertext only. Even someone who runs the relay for you can't read your data:

const room = await AetherCrypto.roomFromPassphrase("passphrase", "salt");
const aether = new Aether("ws://relay", { transform: room.transform });

Verified end-to-end with a wire observer: two clients round-trip plaintext through the room key, while a third socket sniffing the same relay sees only {"__ae_enc": 1, "iv": "...", "ct": "..."}.

IndexedDB per-key persistence (now default). The previous localStorage default hit two hard problems: the 5-10 MB quota ceiling, and JSON-serialize-the-whole-blob on every write. Both fixed. localStorage remains as a backward-compatible fallback for private mode.

Merkle-trie anti-entropy. When two peers reconnect after a partition, epidemic gossip alone can't recover the ops that flowed while they were split. Aether-Core now ships a Merkle-trie digest exchange. Bandwidth is O(k log N) in the number of divergent keys, not O(N) total. A 1000-key mesh with 3 divergent keys reconciles in ~16 probe messages, not 1000.

LAN peer discovery via mDNS. Two relays on the same wifi find each other with zero config. Opt-in (MeshNode(discovery=True)) because some networks treat mDNS traffic as suspicious.

One-command scaffold:

npx @nishantbhatte/aether-core init

Emits relay.py, index.html, Dockerfile, Procfile. Two commands from npx init to a working relay.

Honest positioning

I'm not competing with Yjs on CRDT math. Yjs is more mature, has a bigger ecosystem, and its sync engine is excellent. The wedge is server-side: I ship auth, rate limiting, payload caps, and optional E2E encryption on by default. Yjs leaves that to you.

	Yjs / Automerge / Loro	Aether-Core
CRDT sync	✅	✅
Backend code required	You write it	None
Auth built-in	❌ bring your own	✅ HMAC by default
Rate limiting built-in	❌	✅ token bucket
Payload caps built-in	❌	✅ configurable
E2E crypto in recommended path	Ecosystem addon	Ships in web/aether-crypto.js
Anti-entropy after partition	State-vector sync (O(delta))	Merkle-trie (O(k log N))
LAN auto-discovery	❌	✅ mDNS opt-in

Try it

pip install aether-zta                  # Python relay
npm install @nishantbhatte/aether-core  # Browser client

Or scaffold a working project:

npx @nishantbhatte/aether-core init

Repo: https://github.com/IronFighter23/aether-core
73 tests green on Linux/macOS/Windows × Python 3.11/3.12
MIT licensed

Feedback welcome. Especially interested in "here's where I'd break it" from anyone who's built collaborative apps before.

I Deleted My Backend. My Frontend Variables Are Now the Database

Nishant Bhatte — Fri, 26 Jun 2026 16:51:15 +0000

Stamps form a strictly total order. Given any two stamps, exactly one is greater. No ties. Ever. When two tabs write the same key concurrently:

The higher-stamp write wins
Every replica picks the same winner deterministically
No conflict-resolution UI needed

Deletes are stored as tombstones, not removals. A stale write that arrives late saying "key X = 5" cannot resurrect a deleted key — the tombstone with a higher stamp always wins.

This isn't theoretical. The math is provably commutative, associative, and idempotent. I hammered it with 1,000 randomised concurrent operations across 3 simulated nodes and asserted all replicas converge byte-for-byte. The test passes 100% of the time.

Offline-first comes for free

Here's the part that genuinely felt like magic the first time it worked.

The JavaScript client maintains a localStorage cache. On every page load, it reads from cache synchronously, before the WebSocket even tries to connect. If the cache is hot, the UI renders instantly.

Stop the relay. Refresh the tab. The app still works. The browser shows your state from cache. When the relay comes back online, the WebSocket reconnects and the gateway snapshot patches any divergence.

Measured: ready() resolves in 1 ms when the cache is hot. That's the difference between "instant render" and "wait for a network round-trip that might never complete."

Real numbers (not vibes)

I shipped a benchmark harness with the repo. Run it yourself with uv run aether-benchmark. Numbers from a Linux VM, Python 3.12, fsync ON:

Metric	Result
Gateway round-trip (loopback, p50)	0.21 ms
Gateway round-trip (loopback, p99)	0.68 ms
Ledger replay throughput	~86,000 ops/sec
Snapshot-boot speedup vs cold replay	1.6 – 1.8×
Mesh convergence (5-node ring, 100 writes)	63 ms
Ledger write throughput (with fsync)	~1,400 ops/sec

The relay isn't your bottleneck. The network is.

What's actually in the box

Three working "killer" demo apps, all open in two tabs and sync in real time:

🗂️ Kanban board — columns, drag-drop cards between columns, priority cycling, delete-cascade
📝 Collaborative Markdown editor — paragraph-keyed CRDT, live HTML preview pane
🖧 Network topology diagrammer — drag-drop devices, typed links (1G/10G/Wi-Fi), labels

Plus the actual engine:

CRDT layer: Hybrid Logical Clock + LWW Map (crdt.py)
Mesh layer: WebSocket gossip with epidemic relay between Python nodes (mesh.py)
Storage: append-only JSON-lines ledger with crash recovery (storage.py)
Gateway: browser-facing WebSocket endpoint, rate-limited and payload-capped (gateway.py)
Security: token bucket, connection caps, payload validators, slow-loris guard (_security.py)
Browser SDK: 700 lines of vanilla JS, no build step, no framework (aether.js)
TypeScript declarations: full .d.ts covering every method (aether.d.ts)

And the boring-but-important stuff:

26 automated tests (17 Python pytest + 9 JS scenarios)
Protocol conformance tests that parse the README and assert the running server matches it (so the docs cannot silently drift from the code)
Threat model documentation with every mitigation
8-file documentation suite: getting started, concepts, two API references, recipes, deployment guide, troubleshooting

The whole thing is MIT-licensed and depends on exactly one Python library (websockets) and zero JavaScript libraries.

What this is not for

I owe you the limits, because none of this is free magic.

❌ High-cardinality data (millions of keys). Every new browser tab gets the full snapshot.
❌ Fine-grained authorization. Every connected client sees every key.
❌ Character-level collaborative editing of the same line. LWW means one writer wins per field. (My Markdown editor sidesteps this by keying each paragraph separately.)
❌ Strong consistency. CRDTs are eventually consistent by definition.
❌ Public-facing apps with thousands of concurrent users per relay. You can shard by document/room, but you do it manually.

Where it shines: internal tools, prototypes, niche collaborative editors, multi-tab desktop-app-like web UIs, anything where 5–50 people share state. The whole class of apps where you'd normally write a 200-line Express server, a 5-table Postgres schema, and 6 REST endpoints — and where 90% of that work exists only to ferry the same data between representations.

Try it

git clone https://github.com/IronFighter23/aether-core
cd aether-core
uv sync
uv run aether-demo

Three URLs in two tabs each:

http://localhost:8080/ — topology diagrammer
http://localhost:8080/demos/kanban.html — Kanban
http://localhost:8080/demos/markdown.html — Markdown

Kill the server. Refresh. Notice the state is still there.

Star, fork, tell me what to break

The repo: github.com/IronFighter23/aether-core

I'd genuinely love to know:

What's the smallest real app you'd build on this? Drop it in the comments.
Where does the model break for you? I want to find the edges.
Should I add a Redis driver for the federation layer? That'd let you run this on AWS/GCP without exposing the mesh port publicly.

If you build something on top of Aether-Core, tag me — I'll happily add it to the README's "built with" list.

If this post helped you think differently about backends for a minute, leave a ❤️ or a 🦄. If it didn't, tell me why in the comments. I'm wrong about plenty of things and would rather find out now than later.

Built by Nishant Bhatte. MIT licensed. 4,000 lines of Python + JavaScript + Markdown.

I built a zero-dependency env variable validator for Node.js — env-guard

Nishant Bhatte — Wed, 10 Jun 2026 17:57:03 +0000

Every Node.js project reads from process.env. But process.env gives you raw strings — no types, no validation, no defaults.

This leads to silent bugs like:

PORT is undefined and your app crashes
ENABLE_CACHE === "false" is truthy in JS
Missing DATABASE_URL discovered at runtime, not startup

I got tired of writing the same boilerplate fix in every project, so I built env-guard.

What it does

Zero dependencies — pure Node.js
Type coercion — strings become numbers, booleans, parsed JSON
Collects ALL errors at once — see every problem in one error
Beautiful error output — with hints and examples in the terminal
Built-in .env loader — no dotenv needed
Auto-generates .env.example from your schema

How it works

Install it:
npm install @ironfighter23/env-guard

Define your schema once:

const { guard, schema } = require('@ironfighter23/env-guard');

const config = guard({
PORT: schema.port().default(3000),
DATABASE_URL: schema.url().sensitive(),
NODE_ENV: schema.enum(['development', 'production']),
SECRET_KEY: schema.string().min(32),
ENABLE_CACHE: schema.boolean().default(false),
});

If anything is wrong you see ALL errors at once with hints — not one at a time.

Links

Would love your feedback!