Client-Side by Default: When Not Sending Data Is the Architecture
For a certain class of application - formatters, converters, calculators, analyzers - there is a design choice available that most products cannot make: the data never goes anywhere. The work happens in the browser, nothing is transmitted, and there is no copy on any server because there was never a request.
Treated as a marketing line, this is worth little. Treated as an architectural constraint, it changes what the system is obliged to do, what it is capable of, and what has to be true of every feature added afterwards.
What the constraint removes
| Ordinary obligation | Under this constraint |
|---|---|
| Retention and deletion policy | Nothing is retained, so there is nothing to define |
| Breach exposure for user content | No stored content to expose |
| Data residency and transfer rules | No transfer takes place |
| Access control on user data | The data never leaves the user's own device |
| Consent for processing content | No processing occurs outside the browser |
| Scaling cost with usage | Computation happens on the user's machine |
The last row is an underrated practical benefit. An application whose work happens client side has a cost profile that barely responds to traffic, which is what makes a large collection of small utilities viable to run at all.
The most valuable property, though, is that the claim is checkable. A user who is unsure can open developer tools and watch for a request that never comes. Very few privacy claims can be independently verified by the person relying on them.
What it rules out
The constraint is not free, and it forecloses features that are ordinary elsewhere: no history that follows a user across devices, no sharing a result by link, no collaboration, no scheduled or long-running work, no access to anything requiring a credential you hold, and no processing of inputs too large for a browser tab.
Accepting those exclusions deliberately is what keeps the architecture coherent. Accepting them accidentally, and then adding one of them later without revisiting the claim, is how the promise quietly becomes false.
The claim applies to everything, including your telemetry
This is where most implementations fail, and rarely in the main feature. The transformation stays client side exactly as promised, and then analytics record what was used, or an error reporter attaches the input that caused the failure, or an embedded third-party script observes the page.
- Error reporting that includes the failing input has transmitted user content, whatever the feature did.
- Analytics that record values rather than events do the same, less obviously.
- Any third-party script on the page can read what the user typed, so the claim now depends on that vendor.
- Autocomplete, prefetch and translation features can all move content off the device without an explicit request.
The discipline is that the claim constrains the whole page, not the feature. If you want error monitoring for a page like this, it must record what happened without recording what was being processed - which is achievable, but only if it is a requirement from the start rather than a retrofit.
When one feature genuinely needs a server
Some capabilities cannot be client side. Fetching a URL the user supplies is the common one: the browser will not allow it cross-origin, so the request has to be made by a server, and the architecture's central promise does not apply to that feature.
The honest resolution is not to quietly relax the claim, but to make the boundary explicit and visible. Say which action leaves the browser, state what is sent and what is kept, and keep it a separate, obvious thing rather than something that happens invisibly as part of a page that claims otherwise. A precise claim about a mixed system is more trustworthy than a broad one that is almost true.
The exception needs its own protections
A server-side feature in an otherwise client-side application is easy to underprotect, because the rest of the system needed none of this. An endpoint that fetches a user-supplied address is a well-known hazard specifically: without restriction, it will happily request internal addresses reachable from the server but not from the internet.
- Allow only the schemes you intend, and reject everything else before resolving anything.
- Resolve the hostname and refuse private, loopback, link-local and internal ranges.
- Follow redirects manually and re-check the destination each time, since a permitted host can redirect to a forbidden one.
- Enforce a timeout and a maximum response size, so a slow or enormous response cannot occupy the server.
- Rate limit per client, because this is now the one endpoint worth abusing.
- Return only what the feature needs, rather than proxying the raw response back to the browser.
The redirect step is the one most often missed. Validating the submitted address and then following redirects without re-validating leaves the protection in place and entirely bypassable.
Be precise about what it does not protect
Client-side processing protects against a specific thing: the operator receiving and retaining user content. It does not protect against a compromised page, a malicious browser extension reading the DOM, or the operator changing the code tomorrow. Overstating it invites a reasonable objection that undermines the parts that are true.
A content security policy that restricts what can run on the page is what turns the claim from a statement of intent into something with enforcement behind it - and it is also what stops a well-meaning addition from silently breaking the promise months later.
Conclusion
Choosing not to send data is a real architecture with real consequences in both directions. It removes retention, residency, access control and breach exposure from the design, and it removes cross-device state, sharing and server-side capability from the product. Hold the claim across the entire page rather than just the headline feature, make any server-side exception explicit and visibly bounded, protect that exception properly because it is now the only thing worth attacking, and describe the guarantee precisely enough that it survives scrutiny.