The flag came through: my banks were showing as disconnected. The broker process had been running since 4 September. The key was correct. Tailscale serve was routing / to port 4004. The tailnet URL responded. The banks were not disconnected.

What the UI had surfaced looked like a connectivity failure. The question I'd been asking carried the wrong premise before any investigation started: why are my banks disconnected? I could have acted on the question. Changing something that was working was the probable outcome.

The fix was not a reconnection. It was stopping to verify whether a disconnection had actually occurred. It had not. That is the shape every money fix in an iOS budget app has taken.

The broker is a separate layer

The iOS budget app stack separates the token broker from the bank connections. The broker runs at port 4004, exposed via Tailscale, and sits as the intermediary. When the broker is genuinely unreachable, connections fail. When the broker is reachable but a UI state is stale or misread, connections also appear to fail. Two failure modes, two fixes, one surface symptom.

"A broker you cannot reach is not a bank you are not connected to" is the distinction the September incident enforced. The correct question is not "how do I reconnect the bank?" It is "is this actually a connection failure?" Answering the first question before the second changes something that was working.

Three wrongs from one gap

Before the September incident, Monzo had been reporting a transaction: "Sent from Kroo +£205."

Kroo was in the app as a manual account. No live connection, no transaction sync. The transfer had one side visible (Monzo's outgoing entry) and one side permanently absent. Kroo never pushed data to the app, so Kroo's incoming entry never arrived.

One missing side, three problems:

  • Kroo's balance stayed £205 too high
  • The app's net position was wrong
  • The transfer display was asymmetric: Monzo's side existed, Kroo's did not

The fix was naming the account at the other end of the transfer, even when that account was manual-only. The app knew about Kroo. It knew the transfer amount. What it lacked was the explicit association between Monzo's entry and Kroo as the named counterpart. Making that association explicit addressed all three problems without needing Kroo to become live-connected.

"Name the account at the other end" is a rule with teeth. A manual counterpart is named as manual. An unknown counterpart is declared unknown. The gap the UI should close is the naming gap. Not the data gap.

Within the hour

PY-030 shipped with the transfer feature included. Within the hour of shipping, I used the transfer function and then cancelled it. Monzo went into negative two hundred pounds.

unlinkTransfer found the other row sharing the transfer reference and acted on it. The action was deletion. The other row was the bank's actual Monzo transaction, not a soft link, not a transfer record, the row that underpinned the balance. Deleting it took the balance from correct to wrong in one operation.

The fix was narrow: find the shared row, clear the transfer reference on that row, leave the row. "Unlink" means dissolve the association. It does not mean delete the entry. The function's name was right; the implementation had been treating unlink and delete as equivalent.

Closing that gap was straightforward once the behaviour was visible. The visibility came from using the cancel path on the day the feature shipped. If the cancel test had been deferred, the same function would have silently destroyed bank rows on every cancelled transfer thereafter. The balance discrepancy would have surfaced weeks later without a clear cause.

Currency follows the money

Reports had been four words in the plan since Sprint 7: "Reports, AI learning categorisation, widgets, advanced insights." No specification existed. When the spec was finally written in August 2026, the currency question came up almost immediately.

A sterling account can hold euro transactions. When the report runs across that account, which currency does it assign to the euro charge?

The quick answer was the account's base currency. Apply sterling to everything on a sterling account. Consistent in the display.

The correct answer was the transaction's currency. A euro charge on a sterling account is a euro charge. The report should show it as one. Using the account's currency would silently redenominate every foreign transaction without disclosure. The balance shown would not match the bank statement.

"Currency follows the money, not the account list" was the rule the spec session produced. The transaction carries the currency. The UI reflects it.

Reports Phase 1 reached git five weeks after the devlog entry that claimed it had shipped. The August 2026 entry and Phase Z's ticked steps had both been committed in 380bc76, a commit about the dev-broker rails, not Reports. The Reports code had attached to the wrong commit. When it finally landed in its own entry in September, the currency rule was already in the schema. The delay was in the record, not in the data.

The pattern

Four incidents, the same underlying structure.

A broker misread as a bank disconnection: check the layer before acting on the symptom.

A transfer with one side named and one side absent: name the counterpart, even if it's manual-only.

An unlink that deleted: match the behaviour to the name.

A currency rule that could follow the account or the transaction: follow the transaction.

Each incident had a shortcut available. Reconnect first and ask later. Skip the asymmetric transfer. Delete the broken row. Default to the account's currency because it is simpler. Every shortcut would have produced a system that displayed correctly. None would have been correct.

Financial data is the category where a display that looks right is not sufficient on its own. A balance off by £205 is wrong regardless of how the UI frames it. A silently redenominated transaction is wrong regardless of whether anyone notices in the first month.

The alternative is not complexity. It is precision about what the system knows and honesty in what the UI shows. A transfer to a manual account names the counterpart as manual. A missing side is shown as a gap. A connection alert fires when the broker is unreachable, not when the UI misreads state.

That's the standard the money layer in an iOS budget app holds itself to. Refuse to guess at the layer. Name the account. Let the UI say what it does not yet know.

All writing →