September 16, 2026
Discipline, Not Luck
Live Wire: A Solo GitLab Upgrade Log — Sixteen posts, eleven stations, two CVEs, one long-standing bug — all closed. Looking back, one habit shows up in almost every single entry.

Sixteen posts later, the pattern is easier to see in hindsight than it ever was in the moment
This is Part 17 of "Live Wire: A Solo GitLab Upgrade Log" Previous: Station 11, Part 2: 202, Not 400 — The Image That Wouldn’t Die, Finally Does | Series overview: Live Wire: A Solo GitLab Upgrade Log — Series Overview | Next: none — this is the last part
TL;DR
This series started with a CVSS 9.4 vulnerability and no test environment to rehearse any of it in. It ends eleven stations and sixteen posts later, with both CVEs patched and a long-standing registry bug finally resolved instead of just worked around. None of the individual stations felt connected to each other while they were happening. Looking back at all of them together, one habit shows up almost everywhere: don’t trust the surface signal — verify the real state, independently, every time.
What This Project Actually Was
A GitLab instance that had carried real production traffic for three years, upgraded across eleven stations, with no staging environment anywhere in the process. That was the premise this series opened with, and it held all the way through: every risky step happened against the real system, because there was never another option.
The Habit, in One Sentence
Whatever a system, a log line, or a piece of documentation claims about its own state, verify it independently before acting on it — because the gap between what something looks like and what it actually is was where nearly every finding in this series lived.

The same shape of gap, six different disguises
The Same Gap, Wearing Different Disguises
The Runner Audit — a field named contacted_at looked exactly like "still in use." Real job history said a third of the fleet had been idle for months.
The Image That Wouldn’t Die — a registry answered a capability probe with an honest-looking 200. The actual delete call it claimed to support failed every single time.
Station 4 and Station 7–8 — a backup file existing on disk looked like a finished job, twice, in two different tools. Both times, the process behind it was still running.
Station 6 — an error message blamed a missing database column. The column hadn’t vanished; it had been renamed, and the real cause was a completely unrelated migration’s side effect.
Station 5–6 — this series’ own notes claimed a specific fix mechanism, carried forward from earlier research and never independently checked. Verifying it before writing found the outcome was real, but that particular explanation wasn’t provable.
Station 11, Part 2 — closing the loop meant testing the exact same indicator three separate times, at increasing levels of realism, before it was trustworthy enough to act on.
Six different tools, six different layers of the stack, the same underlying gap every time: something claimed a state, and the real state turned out to be different enough to matter.
What Made the Risky Stations Survivable
None of this series’ outcomes came from things going right by default. Station 4 spent an entire day on verification and rehearsal before swapping a database engine live, turning a 30-minute official estimate into 6 minutes of real downtime. Station 11 ran a dry-run that surfaced four separate blockers before the real cutover, turning an estimated 30 to 60 minutes into 17. In both cases, the risk got spent somewhere safe to spend it, on purpose, rather than discovered live.
Where Honesty Mattered More Than a Clean Story
Not every finding in this series resolved neatly, and the series is more honest for including the ones that didn’t. The migration that fixed itself came with an appendix admitting the specific mechanism couldn’t be confirmed. The backup that looked broken ended with no fix at all, just a correct diagnosis and a wait. A parallelism setting that clearly helped turned out to have a real limit, found the hard way against tables that simply didn’t care how high the knob was turned. None of these needed to be dressed up as bigger wins or cleaner failures than they actually were.
The Project, by the Numbers
+---------------------------+---------------------------------------------+
| Metric | Result |
+---------------------------+---------------------------------------------+
| Mandatory stations | 11, all completed |
+---------------------------+---------------------------------------------+
| Posts in this series | 16 |
+---------------------------+---------------------------------------------+
| CVEs patched | 2 (CVSS 9.4 and a CSRF issue) |
+---------------------------+---------------------------------------------+
| Test environments available | 0, the entire way through |
+---------------------------+---------------------------------------------+
| Station 4 estimate vs. real | 30 minutes → 6 minutes |
+---------------------------+---------------------------------------------+
| Station 11 estimate vs. real | 30-60 minutes → 17 minutes |
+---------------------------+---------------------------------------------+
What Actually Worked
The single habit that shows up across nearly every post in this series — verifying the real state instead of trusting the surface signal — cost time in the moment and saved far more of it later. It’s not a sophisticated technique. It’s closer to a discipline: check the thing itself, not the thing that’s supposed to represent it, every time the two could plausibly disagree.
Where This Still Falls Short
This series covered one GitLab instance across one upgrade window. The specific bugs, the specific error messages, the specific migration names — none of that generalizes directly to any other system. What might generalize is the habit itself: the willingness to stop trusting a clean-looking signal long enough to check what’s actually underneath it. Whether that holds up on the next project is a question this series can’t answer from here.
If you’ve made it through this whole series — what’s the equivalent gap you’ve run into, between what something looked like and what it actually was?
This is Part 17 of "Live Wire: A Solo GitLab Upgrade Log" Previous: Station 11, Part 2: 202, Not 400 — The Image That Wouldn’t Die, Finally Does | Series overview: Live Wire: A Solo GitLab Upgrade Log — Series Overview | Next: none — this is the last part
GitHub: jasonChen0604
Portfolio: jason-chen-1cb56.web.app
LinkedIn: jason-cj-chen