A SaaS with no server
doing the work.

The product needed to answer a computationally expensive question — score every tracked activity, at every moment in time, for any location on Earth, personalised to an individual profile — and it needed to do that continuously and interactively as the user scrubbed across hours, days and months.

Done conventionally, that is a server-side compute bill that scales linearly with engagement. Every scrub of a timeline is a burst of requests. The more people use the product, and the more they enjoy using it, the faster it loses money. That is a structurally broken unit economic for a consumer product with a free tier.

There was a second, harder constraint. The input to every calculation is intensely personal data. Sending it to a server to be computed on — and, worse, into a third-party language model for interpretation — creates a privacy liability that no amount of policy text resolves. The honest answer is not to hold the data at all.

We inverted the standard SaaS topology. Instead of a thin client calling a fat server, Nimisha ships a fat kernel to a thin server's client.

The computational core is written in C — the Swiss Ephemeris for astronomical positions, statically linked, plus roughly 12,000 lines of rule engines and 72 separate activity-scoring engines. That whole body of code is compiled with Emscripten into a single WebAssembly module of about 374 KB gzipped, downloaded once, cached by a service worker, and executed entirely inside the user's browser tab.

The Cloudflare Worker that remains does only what a client genuinely cannot: it authenticates users via Google ID tokens, holds subscription state in D1 at the edge, and proxies calls to a language model. Crucially, the model is never asked to calculate anything — the kernel computes the numbers locally, and only the derived, non-identifying findings are sent up for the model to phrase in natural language.

That division — the kernel computes, the model interprets — is enforced as an architectural rule, not a convention. It is what makes the privacy claim true and the cost claim durable at the same time.

1. Getting a scientific C library into a browser tab The Swiss Ephemeris is a decades-old C codebase that expects a filesystem, real doubles, and a desktop's memory model. Making it run correctly under Emscripten meant solving data-file packaging, heap sizing, and numeric consistency between the native build and the WASM build — because a result that differs between the two is a result nobody can trust.
2. Keeping a 374 KB payload honest 72 scoring engines plus a full ephemeris is a lot of code. Every kilobyte shipped is a kilobyte of first-load latency. The kernel is aggressively size-optimised and service-worker cached so the cost is paid once per device, not once per session.
3. Verifying correctness against external oracles Accuracy is the whole product. Kernel output is checked against an independent reference implementation for raw numeric parity, against published almanacs for derived boundary times, and against a corpus of hand-verified reference cases. Where a value genuinely cannot be computed — polar latitudes where sunrise is undefined — the system says so explicitly rather than silently substituting an approximation.
4. Running a language model on a free tier, reliably A consumer free tier can't absorb per-token costs. Model access is pooled behind a circuit breaker with caching on the stable portion of the context, so a rate limit on one path moves traffic elsewhere without the user ever seeing a failure.
5. Designing for a client that may be offline or asleep The roadmap includes proactively notifying a user when a favourable window opens — which means nothing in the kernel or scoring API may assume someone is actively looking at a screen. That constraint was designed in from the start rather than retrofitted.

Nimisha runs live at nimisha.app on Cloudflare's free tier. Scrubbing the timeline triggers no network requests at all — the computation happens locally, at native-adjacent speed, with no round trip.

The economics invert with it: engagement no longer drives marginal cost. A user who spends an hour exploring costs the same as one who bounces. That is what makes a genuinely free tier possible without a burn rate behind it.

And the privacy promise is architectural rather than contractual. Private profile data is held in the browser and computed on in the browser. There is no server-side store to breach, subpoena, or leak — the property holds because of where the code runs, not because of what a policy page says.