Local-first, and why it shapes Clessira

Most applications in everyday use run on someone else's infrastructure. Input is sent to a server, the result comes back, and the local device largely acts as a rendering surface. The failure modes of that arrangement are well known: without a network connection the application is unavailable, and when the provider discontinues the service or a subscription lapses, access to the data stored in it ends along with it.

Local-first describes the opposite arrangement. The term was introduced by Ink & Switch for software that keeps the authoritative copy of the data on the user's device. The application functions without a network connection, reads and writes go to local storage, and synchronisation — where it exists at all — distributes changes between devices rather than holding the only copy.

What follows from it

Several properties follow directly from that storage model:

• Latency is bounded by local storage rather than by a round trip, so most operations complete without a loading state.
• Offline is the normal operating mode rather than an error condition; connectivity affects synchronisation, not availability.
• The data remains readable and exportable in a documented format, independent of an account.
• Data that is never transmitted cannot be logged, aggregated or exposed in a breach on the provider's side.

Consequences for a time tracker

Clessira, my time tracker for macOS, is built on that model. Time tracking data is a minute-by-minute record of what somebody worked on and when — the category of data least suited to being stored on third-party infrastructure by default.

Clessira therefore keeps its data in a local file. There is no account, and no server-side component is required for the application to work. It starts without a network check, records regardless of connectivity, and reads context from the tools already installed on the machine — Jira, the current Git branch — instead of routing that information through a backend. Export is an ordinary operation on a file that was never inaccessible to begin with.

The trade-off

Local-first shifts backup and multi-device synchronisation from the provider to the user. Moving the data to a server to avoid that is not a solution, and neither is ignoring it. Clessira addresses it by making export unconditional and by supporting file-based sync over a directory the user selects — iCloud Drive, another sync service, or a network share — so replication across devices is available without a service that holds the only copy.

The trade-off is worth making where the data is sensitive and the application does not depend on a server for its actual function. For a time tracker, both conditions hold.