I ship first and reflect later. That's the whole method, and most weeks it works. But the reflection is where I catch the things the shipping hid, and this week the reflection caught a good one.
I keep a file called LOAD_BEARING.md. It's exactly what it sounds like: the list of things my product cannot survive losing. The model provider. The database. The two APIs I'd have to rewrite a week of work to replace. The idea is that if I know what's load-bearing, I can watch it — keep a fallback wired in, mirror what I can, read the changelog when it moves. It's a good file. I wrote it in January and I was proud of it.
I hadn't opened it since March.
That's the confession. Not that I lacked a list of my critical dependencies — I had one, a tidy one, version-controlled. It's that a list you don't reread is just a snapshot of what scared you the day you wrote it. Everything I added to the product after March never made the file, because by then the file felt done. And the things that scare you in month one are almost never the things that take you down in month nine.
So I ran the audit properly this time. I didn't start from the file. I started from the imports, the environment variables, the outbound calls in the logs — the actual surface where my code reaches for something it doesn't own. Then I asked one question about each: if this vanished tonight, what would I do tomorrow morning? Not "is it likely to vanish" — that question lets you talk yourself out of everything. Just: do I have a next move, or do I have a panic.
Three things came back as panic.
One was a model I pull at build time from a public registry, quantized by someone whose handle I don't recognize, cached on my own disk but never mirrored anywhere I control. It works. It's worked for months. And my entire plan for "what if it's gone" was to hope it isn't. That's not a plan; that's the absence of one wearing a plan's clothes.
The other two were quieter — a helper library I'd stopped pinning to an exact version because updates had been painless for so long that pinning felt like superstition, and a webhook I trust to fire that I have never once tested failing. Both are fine. Both have been fine every single day, which is precisely why I stopped looking at them. The dangerous dependency isn't the one you're worried about. It's the one you were worried about, then weren't, because it kept its promises long enough for you to look away.
Here's the thing I actually want to write down, the reflection under the reflection. Mirroring a dependency is cheap. Pinning a version is one line. Testing the failure path is an afternoon. None of these are hard. I didn't skip them because they were hard. I skipped them because the dependency had earned my trust, and trust is exactly the thing that makes you stop doing the cheap safe work. The reliability is the risk. A thing that fails often keeps you honest; a thing that never fails lulls you into building on it as if it were part of you, until the day it reminds you it was always someone else's.
I fixed the three. I mirrored the model to storage I own, pinned the library, and wrote a test that forces the webhook to fail so I know what my code does when it does. Total time: most of a Tuesday. Then I did the part I actually should have automated in January — I put a recurring reminder on LOAD_BEARING.md itself, because a load-bearing file you never reopen is just another dependency you forgot to mirror.
The larger version of this is the week the whole industry ran the same audit on us — the commons, the runtimes, the money rails all quietly getting owners. But you don't need a headline to run it. You need to reopen the file. Reread the list of what you can't lose, and be honest that the list is older than you think.
I ship first and reflect later. This was the later. The shipping had been hiding a month of small trusts I'd stopped auditing, and the only reason I found them is that I made myself look at the boring file again. That's the whole tip, if it's a tip: the dependency that gets you is never the one on the list. It's the one that used to be, that you crossed off in your head because it was good to you for a while.
Reopen the file. Mine was lying, and it was lying in my own handwriting.
