← All releases

The old database is switched off

v2.3.1

Three changes over three evenings, Monday 24 to Wednesday 26 August. None of them waited for Friday.

Summary

The store has been running on two databases since June. Since Wednesday morning it runs on one, and the old one has been deleted.

A customer sees nothing. Same pages, same prices, same answers — that is the whole point, and it is what the three changes were built to guarantee. What changed is underneath.

Two databases meant every question the store asks — does this part fit this machine, what did this customer order, what is in their cart — had two places it could be answered from. Two answers that can disagree is a fault waiting for a busy day. The old one also cost the same every month whether we used it a lot or a little, so moving half the work off it saved nothing at all; only stopping it entirely was worth anything.

This is item 06 of the week, switch off Mongo. It is done, and it is the only item on the week's list that is finished outright.

None of the three went out on Friday, and one of them went out at the wrong time of day. Two were done after the store closed. The middle one went out at eleven on Tuesday morning with the store open. Nothing came of it, but the hour was wrong and it is the fourth time that has happened, so it is written down as a pattern rather than as an incident.

There is no going back from this one. Until Tuesday night we could have put the old database back in a few minutes. The cluster is now deleted. A complete copy of everything that was in it is kept and nothing will expire it, but the running store cannot be pointed at that copy. From here, anything that needs correcting gets corrected forwards.

Which parts fit which machine — Monday evening

What it is
When a customer asks whether a part fits their machine, that answer now comes from our main database instead of the old one. 147,323 records across six makes. This was the last question a customer could ask that still reached the old database, so after it nothing a visitor did touched the old system at all.
How we test it
Ask both databases the same questions and compare the answers, not the row counts. A load can be complete and still answer differently if something subtle drifted, so counting rows on its own proves nothing.
The evidence
Both databases held exactly 147,323 records. Across 150 sampled part numbers, the five different ways the store asks this question produced no differing answer between the two. The list of machines came back the same on both sides — 412 models each. It had also been running on the test copy of the store for three weeks beforehand, and the thing that proved the new path was genuinely in use rather than merely switched on was Kuhn: it answered zero there before Alex loaded the Kuhn data, where the old path would have answered 37,400.
Roll back or fail forward
At the time, roll back — one setting and a restart, a couple of minutes. That was deliberate: the old path was left in place for exactly this reason and removed only after this change had run for a day without complaint.

Orders, and the parts catalogue — Tuesday, eleven in the morning

What it is
Orders are now written to and read from our main database. The parts catalogue stopped using the old database entirely — not switched away from it, but disconnected from it, with the old code removed.
How we test it
Count the orders on both sides and then account for every difference by name. A count that matches tells you nothing about which side served it, and a count that does not match is only useful if you can say which order is missing and why.
The evidence
The old database held 47 orders, the new one 46, and the difference was one specific order placed on 23 August — named, not inferred, and it had not moved in two days. Alex copied that one across and reset the order numbering before the switch. That reset is his confirmation rather than our measurement: our own access to that database is read-only and is refused on exactly that operation, so it is recorded as his word and not as something we checked. Since the switch, orders are being written to the new database and none to the old.
Roll back or fail forward
At the time, roll back — put the previous version of each service back, both kept. That stopped being true the following day, when the old database was deleted.

Checkout let go of a database it was no longer using — Tuesday night

What it is
Checkout had stopped reading the old database days earlier, but it was still holding the door open to it and checking, every few seconds, that the door still opened. Switching the old database off would have made that check fail, and a failing check is how checkout decides it is not fit to take orders. This change removed the door.
How we test it
Ask checkout whether it is ready, and read the list of things it says it is checking. The list is the answer — not whether it says yes.
The evidence
Minutes before the change, checkout said it was healthy and listed the old database among the things it was checking, with a two-millisecond response. That is the whole finding: it was not using it and was still depending on it. Afterwards the same question comes back with the old database gone from the list and only our main database on it. That was read again this morning off the version currently taking real orders, so it is not a claim about what was deployed but about what is running.
Roll back or fail forward
Fail forward only, and deliberately so. The thing a rollback would have restored is the connection to a database that no longer exists.

This third one is the one worth reading twice. The plan for switching the old database off was checked, and it was checked against the wrong thing. It confirmed that nothing was reading the old database any more, which was true. It did not ask whether anything was still connected to it, which checkout was. Had the switch-off gone ahead on that basis, checkout would have started refusing orders and would have kept refusing them until the nightly restart the following morning — up to a day of the store being unable to take an order, from a step that had been written down as safe.

It was found before the switch and not after, which is the only reason this is a paragraph and not a page of its own. The lesson is small and worth keeping: a thing you no longer use can still be a thing you still depend on.

What is kept — because the original is gone

A complete copy of the old database was taken four minutes after checkout let go of it, and before anything was switched off. It holds 66 collections across five databases — 453 MB, of which 452 MB is the live production data, 41 collections of it. It sits in long-term storage with no rule that deletes anything on a schedule, so it stays until somebody deliberately removes it.

It is the only copy. That is stated plainly rather than left to be assumed: there is no second backup elsewhere, and the system it came from cannot be asked again.

What v2.3.1 is — the exact thing to go back to

Read off the running systems on the morning of 26 August, after all three changes. Only the services moved; the storefront and search are still what v2.3.0 pinned.

Storefront137e97ed2Unchanged since 21 August.
Searchsearch-api-00042-fimUnchanged since 21 August.
Servicesd35bec865 → d9915efeChanged. Orders, payment, catalogue and the rest. The previous version of each is kept, so going back is possible for the code — but see the row below before doing it.
Old databasedeleted 26 AugustNot a rollback target. Going back to the previous services would restore code that expects a database that no longer exists. If something needs undoing, it gets undone forwards.
The copy that was keptfinal-pre-terminate-20260826_030900 453 MB, 66 collections, long-term storage, no expiry rule. The only copy.
DatabaseunchangedNo change to the structure of our main database in any of the three. Data was copied into tables that already existed.