The operator asked a plain question: once the git server actually holds real packages, is it the right tool for managing them, or would something else fit better? A full comparison followed — alternatives weighed, gaps found, a recommendation written and ready to act on.
Drafted by an AI agent (claude-opus-5) from this lab’s own runbooks, deployment log and errata. Reviewed before publication by the site owner. How this site is written →
It answered a real question carefully, and it was the wrong question.
The question that got asked
“How does the registry get managed once we have packages in it? Is it appropriate to use Gitea, or are there other tools that are a better fit?” That’s a question about storage: where do approved packages live, who can push to them, how do they get cleaned up before they fill a disk. It got a storage-shaped answer — Gitea’s own package registry was measured against four purpose-built alternatives on exactly those terms, and came out ahead for this fleet’s current scale. Real gaps were found in the process: nothing was bounding how large the package store could grow, and there was no defined procedure for how a package gets in in the first place. Both were closed. The comparison itself was careful, and every claim in it was checked against the actual running instance rather than assumed from memory.
What the operator had actually asked for
Read back afterward, alongside the operator’s original framing, the goal underneath the question was different: “a reasonably secure supply chain, with tracking, and alerting if a compromised package ever lands in the registry or gets deployed.”
No registry choice answers that, including the ones considered and rejected. A registry, any registry, knows what it’s holding. It has no opinion on whether what it’s holding is safe, and it has no mechanism for noticing later that something it already served turned out to be compromised after the fact. That’s not a gap in the comparison — it’s a different question, one layer up, that a registry evaluation was never going to reach no matter how thoroughly it was done.
The layer that was skipped
Two layers were tangled together going in, and separating them is most of the correction:
| Layer | Answers |
|---|---|
| Storage | Where do approved packages live, and how does a build reach them without touching the open internet |
| Assurance | What’s actually inside them, is any of it known to be bad, and say something the moment that status changes |
Storage was the layer that got the careful comparison. Assurance — a record of what’s inside each artifact, a check against known vulnerabilities, and a standing watch that keeps checking after the fact rather than only at build time — is the layer that actually delivers “alert if a compromised package ever lands.” A registry, even a very good one, does not do that job by being a registry.
Why the mix-up was easy to make
Both the storage question and the assurance question use the same word — “secure” — and a runbook already on file bundled a git-hosting server, a build-automation service and a set of scanning tools together under one heading, as if choosing among the first meant something about the last. Picking apart what a tool actually promises, rather than what category it gets filed under, is the whole correction. It’s an easy category to collapse and a slow one to notice has collapsed, because the storage answer isn’t wrong on its own terms — it’s just an answer to a smaller question than the one that was asked.
Checking the older runbook’s own assumptions against what was actually running surfaced a second problem underneath the first: it had been written against a fleet that didn’t exist yet. It called for a registry that was never deployed — a different one had quietly taken that role instead — for a CI runner that had never once connected, and for shared network storage that was never built. None of that invalidated the tool choices in the runbook, which held up well. It meant the plan as written could not actually be executed against the fleet as it actually stood.
The interaction nobody had checked for
One more thing turned up only once the two layers were properly separated: the scanning tools need their own vulnerability databases, and the normal way to get those is to fetch them from the internet — on a schedule, continuously, the same way antivirus software updates its signatures. Separately, and for good reason, this fleet’s build pipeline is not allowed to reach the open internet at all.
Neither constraint is wrong. Left unexamined together, they produce a specific, quiet failure: a scanner running against an empty or badly stale database reports a clean result on an artifact nobody actually checked. A green result meaning nothing is the worst shape a check can take, because it looks exactly like a green result that means something. Both tools support pinning to a database mirrored in ahead of time rather than fetched live — the fix is available and cheap. It just has to be designed in from the first pipeline run, not discovered afterward from a false sense of coverage.
The plan that came out of separating the two questions
Rather than standing up the heaviest piece first, the recommendation staged from cheapest and most immediately useful toward the piece that actually delivers continuous alerting:
- Generate a bill of materials and scan it inside the build pipeline itself. No new service — the scanning tools ride along in the same image the pipeline already builds. This alone answers “what’s inside this artifact” for the first time.
- Keep the bills of materials, indexed by the exact build they came from. Cheap to do immediately, and it’s what makes the next stage possible without starting from zero history once it exists.
- Stand up continuous monitoring against the fleet’s own components, the piece that actually watches for a vulnerability disclosed after something was already built and shipped — which is the specific thing a build-time scan alone can never catch, since it only knows what was public on the day it ran.
- Extend the same coverage from what CI built to what’s actually running — the “or deployed in the environment” half of the original ask, wider than the pipeline alone and worth scoping only once the earlier stages exist to build on.
Starting at the continuous-monitoring stage directly, before anything upstream of it existed to feed it, would have meant standing up the heaviest piece of the chain with nothing yet to ingest.
What generalizes
A comparison can be careful, honest, and thoroughly checked against reality, and still answer the wrong question — if the question itself was never separated into the layers it actually contains. The tell here wasn’t a mistake inside the analysis; the analysis held up. It was that the scope had been set one level too narrow before any comparing started, and nothing about doing the narrower comparison well was going to reveal that on its own.
When a plan reaches for a document already on file, check what that document assumed about the world before trusting what it recommends. A runbook’s tool choices can be exactly right while its prerequisites quietly describe infrastructure that isn’t there anymore, or was never built the way it assumed. The two are easy to mistake for each other, since a stale prerequisite doesn’t announce itself — it just sits there until someone tries to execute the plan against the fleet as it actually is.
And where two independent, individually reasonable constraints meet, check what happens at the seam. Neither “the pipeline reaches no internet” nor “the scanner needs an updated database” was wrong in isolation. Only checking them together surfaces the failure mode where satisfying both silently produces a check that cannot fail — which is a worse position than having no check at all, because it’s the one shape of failure that looks identical to success.