LocalStash

Guides · Privacy architecture

Why your reference library should never leave your browser

A bookmark tool is a diary of what you are thinking about. Most of them upload that diary, index it, and keep it indefinitely. Local-first storage flips the direction: the file stays on your device, and you decide when a copy leaves. Here is what that protects, what it does not, and how to check the claim yourself.

Updated 16 Nov 2026 10 min read LocalStash guides

Try a small thought experiment. List the ten pages you bookmarked this month. Now consider what that list reveals: the client you are worried about, the competitor you are studying, the medical condition you looked up, the job you are quietly applying for. A bookmark library is not a neutral artifact. It is a record of attention, and attention is the most useful data a company can hold.

That is why the storage location matters more than the feature list. Two tools can have identical interfaces and completely different privacy properties, depending on one question: when you press save, where does the record go?

What happens when you bookmark in the cloud

In a typical hosted bookmark tool, saving a page sends a request to an API. The server writes a row: your account id, the URL, the title, the description, a timestamp, whatever tags you added. The page may also be fetched server-side to extract metadata or a preview image, which means the tool's servers contact the page on your behalf. From there, the record usually reaches a managed database, a backup system, a search index, an analytics pipeline, and whatever third-party services the company uses for email, support, and billing.

None of that is necessarily malicious. It is how a sync service works, and sync is genuinely valuable. But the consequences are structural:

  • The library exists on infrastructure you do not control, under a policy you did not write.
  • It survives account deletion for as long as backups and logs are retained.
  • It is reachable by legal process, by an insider with database access, and by any future owner of the company.
  • It can be used to improve a model, or to price a subscription, if the terms allow it.
  • It stops working if the company does — or starts charging for what used to be free.

For a public reading list, none of that matters much. For a working designer's reference file — filled with unreleased client work, screenshots of competitor flows, notes about what to fix — it matters a great deal.

What “local-first” means, and what it does not

Local-first is an architectural stance: the copy of the data that matters is on your device, and the software works against that copy. Sync, when it exists, is a background convenience rather than the source of truth. The term was popularised by a 2019 essay that listed seven ideals — fast, multi-device, offline-capable, collaborative, long-lived, private by default, and under user control — and noted that no single system achieves all of them at once.

For a personal reference library, three of those ideals do most of the work: offline-capable (the app loads and saves with no network), private by default (nothing is transmitted unless you ask), and long-lived (the archive can be read without the original software). Multi-device sync and real-time collaboration are the ones you give up, and that trade is the right one for a private swipe file.

Local-first is not the same as “encrypted cloud” End-to-end encryption protects data in transit and at rest on a server. Local-first removes the server from the path entirely. The second is a stronger guarantee for a single-user library, because there is nothing to decrypt on someone else's disk.

Where the data actually sits

Browsers ship a real database. IndexedDB is an asynchronous, transactional object store available on every modern desktop and mobile browser. It can hold structured records and binary blobs, which means a saved screenshot can live beside its URL and note without any conversion to base64.

Three properties of IndexedDB matter for a library:

  • It is scoped to an origin. Data written by localstash.pages.dev is invisible to every other site, including other pages on the same hosting platform.
  • It persists across sessions until the user or the browser removes it. There is no expiry; the “clear site data” button is the delete key.
  • It is not automatically encrypted. The operating system's disk encryption is the encryption. Anyone who can use your unlocked browser profile can read the database — the same way they could read your files.

That last point matters for honesty. Local-first protects the library from companies, breaches, and subpoenas aimed at a service. It does not protect it from someone using your unlocked laptop, a malicious extension with broad page permissions, or malware. If your threat model is a shared device, the answer is a separate browser profile with disk encryption, not a different web app.

The threat model that actually matters

RiskCloud libraryLocal-first library
Server breach exposes your savesPossible, and outside your controlNo server to breach
Legal request for your account dataProvider must respond per its policyNothing to hand over
Company shuts down or pivotsExport if offered, migration if notFile already in your browser
Price increase or feature paywallYou either pay or leaveThe app keeps running
Library used to train or profileDepends on terms you did not negotiateNo copy leaves the device
Someone uses your unlocked deviceAlso exposed, plus the web accountExposed; use a locked profile
Browser data cleared accidentallyRecoverable from the cloudLost unless you exported a backup
You switch computers or phonesSign in and continueExport, then import on the other device

Read the last two rows carefully. Local-first trades convenience for control, and the trade is only honest if you take the backup habit seriously. A local archive without exports is one cleared cache away from being nothing.

Verify it in sixty seconds

Do not take a privacy claim on faith; any page can print the words “no upload”. Check the network instead. In Chrome, Edge, Firefox or Safari:

  1. Open the app and open developer tools (F12 or Cmd+Option+I).
  2. Switch to the Network tab and clear the list.
  3. Save a reference, add a tag, attach a screenshot, search, and export a backup.
  4. Watch the request list. On a genuinely local app you should see no new requests at all — the page is already loaded and every operation happens in memory or in IndexedDB.
  5. Open Application → IndexedDB and look for the database. You should see your records there, with the screenshot stored as a blob.

Two caveats keep this check honest. The first page load necessarily makes requests — the HTML, CSS and JavaScript have to arrive somehow. And an advertising or analytics script, if present, will also appear. That is exactly why the distinction should be stated plainly: the app's own data operations make zero requests, and any third-party script is listed in the privacy policy rather than hidden.

Backups are not optional

Treat the browser as a working copy, not an archive. The 3-2-1 habit adapts well to a personal library: keep the live copy in the browser, one export on the same machine, and one export somewhere else. For a swipe file, that means a JSON backup monthly and before any browser cleanup, plus a Markdown export twice a year for the entries that would still matter in a decade.

Two details decide whether a backup is real. First, it must include the screenshots; a JSON file of URLs is a bookmark list, not a library. Second, the restore path must be tested — import the file into a clean browser profile once and confirm the items, tags and images come back. A backup you have never restored is a hope.

The one rule If a tool cannot export everything it holds, in a format you can read without it, it is not your library. It is a subscription to your own data.

Where local-first is worse

An honest comparison has to include the costs.

  • No automatic sync. Saving on your laptop does not put the item on your phone. You move data with export and import, which is fine monthly and annoying daily.
  • Clearing site data deletes the library. Browsers treat website storage as disposable in “clear browsing data”, and some privacy tools wipe it on exit.
  • Storage quotas exist. Browsers cap per-origin storage; screenshots are the bulk of it. A library with thousands of images will need pruning or a desktop app.
  • No collaboration. You cannot share a live collection with a colleague; you send a file.
  • Search is limited to one device's compute. Full-text search over tens of thousands of records is fine in JavaScript; semantic search is not, and that is a real capability gap.

If you need a team library with comments and cross-device sync, a local-first web app is the wrong tool. Choosing it anyway and then being surprised by the tradeoffs is not a privacy win; it is a workflow problem.

How LocalStash implements it

The whole application is a static site: HTML, CSS and four JavaScript files. There is no application server, no account system, and no analytics. Pressing save writes to IndexedDB through a small wrapper; the reference and its screenshot go into separate object stores so that listing items never has to load image blobs into memory.

  • Data stores: items (one record per reference), images (the blob, keyed by id), collections, and meta.
  • Network calls in the app code: zero. There is no fetch, no XMLHttpRequest, no sendBeacon, and no remote font or icon file.
  • Offline: a service worker caches the shell, so the app opens and saves with the network switched off.
  • Exits: JSON with or without embedded screenshots, Markdown of every note, and a zip pack with Notion-ready markdown, a CSV index and a bookmarks file.
  • Third parties: Google AdSense on the hosted site. Ads are the reason the free tier exists; the ad script is the only external request, and the privacy policy says so.

What the app does not do is equally deliberate: no account, no email capture, no telemetry, no crash reporting, no remote configuration, no “anonymous usage statistics” that quietly include your data.

Questions to ask any tool

Whatever you use, these six questions separate a library you own from a library you rent.

  1. Where does a saved item go when I press save?
  2. Can I export everything, including images, in a format another tool can read?
  3. What survives if I delete my account tomorrow?
  4. Which third-party scripts run on the page, and what do they receive?
  5. Does the app work with the network disconnected?
  6. Who owns the database, and under which jurisdiction does it sit?

A good tool answers all six in plain language. A tool that answers only the marketing version — “your privacy is important to us” — is telling you something too.

Questions

Is browser storage really durable enough for a library I care about?

It is durable across restarts and updates, but it is not archival: clearing site data removes it, and browsers may evict data under storage pressure when a site is not installed. Installing the app as a PWA and exporting monthly covers both cases. For anything you would be upset to lose, keep an export outside the browser.

Can the site operator read my library?

Not through the app: there is no endpoint that receives records, and no code that sends them. What an operator can see is normal web-server logging — IP address, user agent, requested file — for the pages you load. That is a hosting fact, not a library upload, and it does not include your references or screenshots.

Does incognito mode protect a local library?

The opposite: private windows typically discard site storage when they close. Use a normal window and, if you share the device, a dedicated browser profile with its own lock screen.

What about ads — don't they defeat the point?

Ads are a third-party request and should be disclosed as one. They load a script that can see the page it runs on, but they do not receive your IndexedDB records; a local app has no upload path to give them. If you would rather not have any third-party request, use a content blocker on the site — the workspace keeps working, because nothing in the app depends on the ad script.

Check it yourself

Open the workspace, save one reference, then watch the Network tab. The only thing that should move is the counter in the sidebar.

Written and maintained by the LocalStash team. No trackers, no email capture. Workspace · Privacy