Offline-first privacy path: offline-first pain tracker

Offline-first is usually treated like a nice technical feature.

For sensitive apps, it is something sharper:

If you want privacy-first, offline health tech to exist without surveillance funding it: sponsor the build → https://github.com/sponsors/CrisisCore-Systems

a failure policy.

It decides whether the user loses the record when the network disappears.

That matters when the app is used for pain, symptoms, legal notes, crisis context, financial hardship, housing records, or anything the user may not be able to reconstruct later.

PainTracker was built around a simple rule:

the entry should survive before the network gets a vote.

The network should not be part of the user's memory

Pain records often happen inside small windows.

The user may be in a flare. They may be in a waiting room. They may be on public transit, in a rural area, in a basement, in a hospital, or somewhere with unreliable signal. They may have only enough focus to write the thing down once.

A failed save is not neutral in that moment.

If the app drops the entry because a request failed, the user absorbs the cost. They have to remember it later, retype it later, or give up on the record entirely.

That is why offline-first is not just about convenience. It is about refusing to make the network part of the user's memory.

Offline-first changes the architecture

The safer flow is boring:

User enters pain data
Local save happens first
UI confirms local persistence
Network becomes optional
Export remains user controlled

That order is the point.

If the app writes remotely first and treats local state as a temporary cache, the user is always one connection problem away from loss. If the app writes locally first, the user's record does not depend on server availability.

For a social feed or a casual dashboard, that may be a product tradeoff.

For sensitive self-reporting, it is a safety boundary.

The failure question

A useful offline review starts with one question:

if the network drops right now, what does the user lose?

That question should shape the entire feature:

• form saving
• draft recovery
• error messages
• local persistence
• export behavior
• sync assumptions
• reload behavior
• session expiry handling

The answer should not be "the user's only copy of the record."

If the record can disappear because an optional subsystem is unavailable, the core workflow is not resilient. It is network-dependent with offline styling.

PainTracker's offline logic

PainTracker is browser-based and designed so core tracking can continue without account creation or server availability after the app has loaded.

Entries stay local by default.

The user can record pain context without waiting for a remote system to accept it. Export remains user-controlled. The app does not automatically send reports to clinics, insurers, employers, or compensation systems.

That does not mean offline support solves every risk.

It means the essential task is not allowed to collapse just because connectivity is weak.

In PainTracker, offline-first matters because pain notes are time-sensitive. A flare entry written in the moment is often more useful than a reconstructed memory two weeks later.

What offline-first does not solve

Offline-first is not magic.

Device loss is still a risk. Browser storage has limits. Private browsing can behave differently. A user can clear site data. A damaged device can still strand local records. Browser updates and service worker behavior need testing.

Local-first apps still need threat modeling.

They also need clear user education around backup and export. If a product says "your data stays local", it should also say what that means operationally. Local data can be private by default and still require user-controlled backup discipline.

That honesty matters.

Protective claims are only legitimate when the system explains both the boundary and the limit.

Error messages are part of offline design

Offline-first is not only storage code.

It is also feedback.

The user needs to know whether the record was saved locally. They need to know whether export failed, whether sharing failed, or whether only a nonessential remote feature is unavailable.

An error that says "Something went wrong" is not enough for a stressed user.

Better error states answer:

• what failed
• what stayed safe
• whether the local record exists
• what the user can do next
• whether they need to retry now

Do not imply catastrophic loss unless loss is verified.

Practical checklist

Before calling a sensitive app offline-first, test the core workflow like this:

[ ] Can the user start without network after the app is available?
[ ] Can the user save without network?
[ ] Can the user tell whether data was saved?
[ ] Can they recover after closing the tab?
[ ] Does the app explain offline state clearly?
[ ] Does export work without hidden server dependency?
[ ] Does failure preserve dignity instead of creating panic?

Then run the same checks with a slow device, a stale tab, and interrupted use.

If those states are not tested, offline-first is still an aspiration.

The useful takeaway

Offline-first design answers a protective question:

what survives when the user loses connection, time, or focus?

For sensitive apps, that answer belongs in the architecture, not the marketing copy.

PainTracker.ca is live as a free offline-capable pain tracking tool.

I am interested in feedback from developers who care about PWA behavior, local-first storage, accessibility, and failure-mode design.

Support this work

• Sponsor the project (primary): https://github.com/sponsors/CrisisCore-Systems
• Star the repo (secondary): https://github.com/CrisisCore-Systems/pain-tracker