Local-first and bring-your-own-key

Two ideas that were, not long ago, positions you had to argue for are quietly becoming defaults in small software. Neither won on principle. Both won because the economics moved.

Worth writing down what actually changed, because the arguments people make for these patterns are usually not the reasons they are spreading.

Local-first stopped being a manifesto

The phrase comes from an Ink & Switch essay from 2019, which framed it as an attempt to get cloud convenience without giving up ownership of your data. For years after that it read as a research position with a small number of committed practitioners.

The distinction it draws is worth restating precisely, because “local-first” is now marketing copy and gets used for things that are not it. In a cloud-first app, the authoritative copy of your data is on a company’s servers and your device holds a view of it; lose the connection and the app degrades. In a local-first app, the authoritative copy is on your device, the app is fully functional offline, and sync — if it exists at all — is a convenience layered on top.

It is not the same as offline-only. Local-first apps can sync and share. The question is only which copy is the real one.

What changed is not that more people read the essay. It is that the alternative got more expensive and less stable at the same time. Hosted note and task subscriptions have drifted upward across the category, and long enough has now passed for a lot of people to have personally lived through a tool they relied on being sold, redesigned into something else, or shut down. Once that has happened to you twice, “the file is on my disk in a format I can open with something else” stops sounding ideological and starts sounding like ordinary risk management.

There is a builder’s version of the same calculation, and it is the one that actually drives adoption. A local-first app has no servers to run, no user accounts to store, no password reset flow, no breach surface, and no recurring infrastructure cost that a subscription has to cover. For a solo developer that is not a philosophy. It is the difference between a product you can maintain alone and one you cannot.

Bring-your-own-key is the same trade, for AI

The second pattern: instead of the app selling you AI features, the app asks for your own API key and talks to the provider directly from your machine.

Users get a real guarantee rather than a promise. The text goes from your computer to a provider you chose, under a contract you agreed to, and the app author cannot read it — not because they are trustworthy but because the traffic never passes through them. If you want to know what was sent, your provider’s dashboard will tell you.

Developers get something more immediately practical: no margin risk. Selling AI features at a fixed monthly price means guessing average usage and eating the difference when a heavy user shows up. Bring-your-own-key removes the guess entirely. There is no inference bill, so there is nothing to meter, and — this is the part people find surprising — the feature can then be given away free. That is the reasoning behind Jot’s AI features sitting in the free tier. There is nothing to charge for.

The cost is real and mostly falls on the least technical users: someone has to create an account with a model provider, generate a key, and paste it in. That is a genuine barrier and it is why bring-your-own-key remains a pattern for developer-adjacent tools rather than a mass-market one.

Meanwhile, the platform apps have gone quiet

The third thing, and the one that makes a small tool like this viable at all.

Big platform applications reach a state where they are not being removed and not being improved, and they can stay there for years. Microsoft To Do is a frequently cited example: Windows Central wrote in 2026 about it surviving each round of app culls while users wonder how long that lasts. No major feature overhaul has been announced; the visible direction of travel for task management inside Microsoft has been toward Planner, Loop and Copilot integration rather than the standalone app.

For anyone building around it, this is a mixed report and both halves matter. The stable half: To Do is installed everywhere, signed in everywhere, on everyone’s phone, wired into Outlook, and its API is public and unglamorous enough to be unlikely to change under you next quarter. The risk half: an app in maintenance is an app that could be folded into something else, and a bridge into it inherits that risk.

The way to hold both is to make sure the integration is not the product. Jot’s captures live in a local database that is complete on its own; the To Do bridge is a destination, not the storage layer. If that destination changed, another one would take its place and nothing anyone had already typed would be at stake.

Which is really the same idea as the first two sections, arriving from a third direction. Own the copy that matters, rent everything else, and be honest with yourself about which is which.

The uncomfortable part

Local-first and bring-your-own-key both make the same trade, and the trade is not free.

Your data being on your machine means your data is as safe as your machine. There is no server-side backup, no “recover my account”, no support team with database access to undo a mistake. A stolen laptop is a stolen archive. The answer is the same as it has always been for local files — back them up somewhere — and it is an answer that requires you to actually do something.

The industry spent fifteen years training people out of that habit, largely by making it unnecessary. Local-first spends some of that convenience back. It is worth being upfront that this is a trade rather than a free upgrade, because the people most attracted to the pitch are the ones least likely to be running backups.

Where the outside claims here come from: the local-first framing is Ink & Switch’s; the characterisation of Microsoft To Do’s position is Windows Central’s reporting, not an inside view. Everything about Jot’s own design is checkable in the repository.

Jot is a quick-capture app for Windows: one hotkey, one line, back to what you were doing. What it is, or what is still unproven.