How a capture on your desktop ends up as a buzz in your pocket

A reminder that only fires on the machine you were sitting at when you typed it is half a reminder. The thought you had at 11:04 in a meeting is usually about something that happens away from that desk.

The obvious solution is to build a phone app and a server to talk to it. That is also how a small local-first tool turns into an account system, a subscription that pays for infrastructure, and a copy of your notes on somebody else’s computer.

There is a shorter path. Microsoft To Do is already on your phone, already in Outlook, already signed in, and already the thing that sends you notifications. It has an API. Jot writes into it.

What actually happens

You capture something with a time in it:

Call the vendor tomorrow 2pm #work

Four things happen, in this order.

1. It is saved locally, immediately. The overlay hides, focus returns, and the row is written to the SQLite database on your disk. This step never waits for the network and never fails because of it. If everything below this line is broken forever, the capture is still yours.

2. A background worker notices it. A separate thread wakes periodically — and immediately when you capture something — and looks for rows that need pushing. It compares what the capture says (a todo, due tomorrow at two, in the “work” list, not yet done) with what it knows about the corresponding task (there isn’t one yet) and works out the single operation that would reconcile those two facts.

3. It resolves the list, then creates the task. Your lists are fetched, the one named work is matched case-insensitively, and if it does not exist it is created. Then the task is created in it, with the title, the due date and time, the reminder, and the importance flag mapped onto the equivalent To Do fields.

4. Microsoft does the rest. The task now exists in your account. It syncs to your phone the way everything else in your account does. Tomorrow at two, To Do sends you a notification, because that is To Do’s job and it is already good at it.

Jot is not involved in step four in any way. It does not know your phone exists.

Push only, and why that is a feature

Jot pushes to To Do. It does not pull from it.

This is a deliberate limit, not an unfinished feature. Two-way sync means merging: the same item edited in two places, two edits, one truth, and a rule for deciding which wins. Every sync bug you have ever hated came out of that rule. Doing it well is a large amount of work, and doing it badly loses data silently.

The one-way version needs none of it, because the capture row on your disk is always the source of truth. The worker can read what the capture says and what the task is, and compute the one operation that closes the gap. There is no outbox table to keep in step and nothing to merge.

The consequence you should know about: rename a task in To Do and Jot will not know. Edits made in To Do stay in To Do. Status changes made in Jot — marking something done, deleting it — do propagate, because a change to the capture re-queues it and the worker completes or deletes the mirrored task to match.

What is sent, and what is not

Only captures you made as todos, and only once sync is switched on. Notes are not sent. Drafts are not sent. Nothing is sent before you connect an account.

For each todo that is sent: its title, the expanded note body if there is one, the due date and time, the reminder time, whether it is flagged important, and whether it is complete. That is the whole payload, and it goes from your machine directly to Microsoft’s API over TLS.

It does not pass through any server belonging to Jot, because there isn’t one. The sign-in is a standard OAuth flow with no client secret, which is the correct shape for a desktop application that cannot keep a secret. It opens your real browser — not an embedded webview, which is the pattern that trains people to type their Microsoft password into an unidentifiable window — and catches the redirect on a loopback port on your own machine.

The permissions requested are the narrowest set that makes it work: Tasks.ReadWrite for To Do, User.Read to display which account is connected, and offline_access so it does not have to ask you again every hour. No mail, no files, no calendar, no directory.

When the network is not there

The same design that makes capture instant is what makes an offline stretch a non-event.

Nothing on the save path waits for the network. If a push fails, the capture keeps its place in the queue and is retried with an exponential backoff that starts at 30 seconds and caps at an hour. An error that is clearly permanent — a 4xx that will not fix itself — is held for a day instead of hammered on the backoff curve, and it stays visible in a sync log you can read in Settings, failures included.

Close the laptop on a train, capture nine things offline, open it at the office: the queue drains and nine tasks appear.

Why this is the paid part

Everything else in Jot is free and stays free: capture, parsing, reminders on the desktop, search, the whole local layer, and the AI features you bring your own key for. Sync is the one thing that costs money, at €3 a month, with a 14-day trial that starts when you connect an account rather than when you install the app.

The reasoning is that this is the only part with ongoing cost that is not optional. It is the part that has to keep working when Microsoft changes an API, when a token format changes, when an error code starts meaning something new. A local text field does not rot. A client for somebody else’s API does, and somebody has to keep paying attention to it.

If you cancel, sync stops and nothing else changes. Your captures are a file on your disk. Your tasks are in your Microsoft account, where they always were. Neither of them was ever ours to take away.

The honest caveat

No part of the above has ever been done against a real Microsoft account.

The whole path — the sign-in, the token exchange, the list resolution, the task payload, the retry logic — is covered by tests that run against a mock server that replies with canned responses. That proves the shape of what Jot sends is what it intends to send. It does not prove Microsoft accepts it, because Microsoft has never been asked.

That is the largest single item on the roadmap, and it needs an Azure application registration and a human at a Windows machine. Until it is done, this post describes a design rather than a demonstration, and it would be worth less if it pretended otherwise.

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.