The toast that could not fire

A trainer taps Mark All and the whole room's round is recorded. From October 2025, if every one of those saves failed, the app said nothing, because a failed save and a deliberate skip had become the same value.

2 min readMicroGym · Live stage

A session runs on a tablet in the middle of the room. Members move through rounds, and the trainer records each one in a grid, a row per member and a column per movement. Most of the time the numbers are what the grid already suggests, so there is a button for that: Mark All records the round for everyone at once. It is the most-pressed control on the screen that matters most, and it runs on gym wifi.

Two meanings of nothing

Every write goes through one function. It catches any error, logs it to the browser console and returns null. That is a defensible contract as long as every caller reads null as failure. The single-cell dialog does: a null keeps the dialog open and says the save failed. On 23 October 2025 Mark All learned not to overwrite a cell that was already recorded, and the way it skipped a member was to return null. Then, before checking results, it filtered out the nulls as skips. A failed save was now indistinguishable from a member already recorded, and it was filtered out with them.

The check that followed asked whether every remaining result had succeeded, which after that filter could not be false. If every save failed, nothing remained, and the code returned success for an empty list on purpose, because a round where everyone was already recorded is not an error. Two lines further on sat a toast reading Failed to mark all users as completed. Nothing about a failed save could reach it.

What the room would have seen

Nothing, which is the point. The trainer taps, no error appears, and the cells that did not save keep showing a suggestion instead of a record. In a loud room with the next round starting, that looks like done. The error went to the browser console, where the app keeps the last ten to attach to a bug report, and nowhere else. So I cannot say whether it ever happened. The database records the sets that saved. A set that failed leaves no row, and that is the whole difficulty.

The fix

A skip now returns its own marker, and null means only failure. Any failed save makes Mark All report failure, so the toast fires, and the entries that did save still land on screen. The change is fifteen lines smaller than what it replaces. Run over the five cases that matter (all saved, all already recorded, all failed, one failed, a skip beside a failure), the old logic reported success for all five and the new logic reports failure for the three that contain one. It merged on 10 November 2026.

Why it belongs on this page

This is a type error the type system was never asked about. Null meant failure in one function and skip in another, and each was reasonable on its own; the defect exists only where they meet. The live stage's other choice, firing milestone checks without waiting on them, is the same trade made on purpose and written down beside the code: the write must not stall for a side effect. This one was not a choice. It is what happens when one value carries two meanings and the code that reads it has to guess which.

More notes
  • The webhook that credits twiceA payment processor delivers every result at least once. The interesting engineering is in what happens when your side fails halfway through.
  • A ledger you can edit from a route handler is not a ledgerWhy every movement of value on the payments platform goes through a Postgres function, and what it costs to keep it that way.
  • Four rows that were not theirsHardening multi-tenant row-level security in four reversible phases, verified by impersonating a member and counting what they could see.
  • The bug inside the fixA payout race, the fix for it, the bug inside that fix, and why it is the best argument I have for one person owning the whole path.
  • The sale that arrives with no referrerA creator shares a link on Instagram, the buyer taps it, installs the app and purchases. Nothing in that chain carries the creator's name across. Here is what does.
  • The minimum that belongs to someone elseHeld commissions are released to creators once a brand's payout minimum is met. Group the money by creator, the obvious way, and one brand's minimum ends up holding another brand's money.
  • The commission that must not mint twiceA buyer pays and the platform owes a creator a commission. Between those two facts sit a colluding pair, a call that arrives twice, and a cart with three items on one payment.
  • The rule that has to be written twiceFirestore security rules do not cascade to subcollections. Forget that in one place and a single query returns every private message on the platform.
  • Thirty days in the ledgerSplitting a payment at charge time is simpler and wrong: a refund after the creator is paid is a clawback nobody enjoys. Holding the money creates a different set of problems, and each piece of machinery around the hold answers one of them.
  • Arbitrary but consistentA gym's assessment answers become rules that swap an exercise for a member before a session. Two rules can disagree about the same movement. The code says who wins, and the comment admits how.
  • The number that ducked every thresholdA deposit arrives from a browser carrying two numbers. The platform scored one of them and charged the other, and every limit it had was measuring the wrong figure.
  • The second one tells you the shapeHigh-risk merchants get dropped by processors, so the platform cannot be welded to one. The interface that makes a processor swappable could not be designed before the second one existed.
  • A key you did not makeA device fingerprint is a hash the browser computes and the server has to take on faith. The useful question is not whether to trust it, but what a server does once it accepts that it cannot.
  • The template never learns your nameA trainer builds a workout once and runs it for a room of people who are not the same. The data model that survived is three tables with a one-way street between them, and the model it replaced was the obvious one.
  • The copy that heals itselfA marketplace that sells a brand's products keeps a copy of the brand's store. The same codebase keeps that copy two different ways, and the slower one is the one that is right by morning.
  • The ledger was rightA team sale splits one commission between two people. The split was recorded correctly everywhere a person could look, and the code that sent the money would have paid the wrong one.
  • Zero was not a ceilingA creator can write their own commission rate, so the server caps it at what the brand agreed to. For most of the catalogue the cap never ran, because those products carried no commission of their own.
  • Smaller than it wasOn 27 September the gym's movement library lost 4,724 lines and gained one field. What came out was a theory of how movements relate. What replaced it was a trainer writing the relation down.
  • The ceiling is a thousand rowsA comment beside the member totals names their ceiling: tens of thousands of sets, and then it gets slow. The query under it has no range, and the API it calls stops at a thousand rows without saying so.
  • Spent, but not on anythingEvery deposit required a texted code, and each code could be spent once. Nothing recorded which deposit spent it, so the dispute packet that cited those codes was counting texts, not approvals. Now each spent code carries the checkout it approved.
  • No exceptions notedThe platform could generate a certificate of its own controls for underwriters, and every result in it was the same fixed string. Re-reading it for this page found that. It now counts what the guard actually decided.