I built myself a cage and called it job security
Ten or twelve years ago I built a thing that only I could run, and for a while that felt like the best work I'd ever done.
It was a promo email system, and it was held together with bubble gum and duct tape. I was still green, still learning. Most of what we built in house ran on Ruby, and I was bad at Ruby. So instead of doing it the right way I reached for the one tool I actually knew, and I built the most hacked-together Excel macro you have ever seen. It pulled our sales numbers out of SQL over an ODBC connection. It drew a bar graph and laid an image over the top so it looked a little nicer than it had any right to. Then it reached into Outlook and fired the emails out to our customers and our sales team. It ran on exactly one computer in the world, mine, and exactly one person understood how, me. It would have taken somebody a solid month to untangle what I'd done. I was on a deadline and it needed to work now, and it did. It worked.
And I was proud of it. Here's the part that took me ten years to say out loud: I was proud that only I could run it.
I told myself it was job security. If I'm the only one who knows how the promo goes out, they can't very well get rid of me. That was the lie sitting on top. Underneath it was something I'm less comfortable admitting. I was green and I wasn't sure I belonged in the room, and being the one guy who understood the thing that mattered made me feel like I'd earned my seat. The macro wasn't just holding up the promo. It was holding up my sense that I was supposed to be there at all. That's imposter syndrome, and that duct-tape macro was the thing I leaned on to keep it quiet.
To the people around me who didn't write code, it looked like magic. I was the wizard who turned the numbers into a nice email. To anybody who actually understood what was happening under there, it was half-assed, and they'd have been right. I wasn't doing anything groundbreaking. I'd hot-glued some junk together on a deadline. Both of those were true at the same time, the wizard and the hack, and the whole story lives in the gap between them.
Then the promo ended, and I set it aside, and went back to the rest of the job, learning and breaking and fixing things. About a year later the phone rang. We're running the same promo again. And this time I didn't feel proud. I felt my stomach drop. Because it was still only me, I still didn't have time to do it right, and so I did the only thing I could. I made the hack work one more time.
That was the moment the words flipped on me. Job security. I hadn't made myself valuable. I'd made myself un-leave-able, and those are not the same thing. Every promo after that, I had to stop whatever I was actually building, climb back into code I could barely remember writing, and nurse it through another batch. It was too tangled to hand to anyone non-technical. We didn't have a junior who could take it, and honestly I wouldn't have done that to a junior. The thing I'd built to prove I belonged had quietly become a chain around my neck.
I ran across a piece of that old spreadsheet years later. It was fun to look at, the way an old photo is fun, look how I solved that. But it also reminded me of something I keep relearning. A lot of what we call clever is just nobody else can follow this, and given enough time, nobody includes you. I've met my own code as a stranger more than once.
After that second year I finally did the boring thing I should have done first. I built proper reports so somebody else could pull the promo data themselves, and we handed the actual sending off to a piece of software built for it. Off the shelf. The unglamorous answer, the one that didn't have my name welded to it.
For a long time I read that as giving up. I'd surrendered the clever problem to a vendor. It took me a while to see it the other way around. That wasn't me losing the cool thing. That was me getting out of the cage.
The lesson isn't build everything yourself, and it isn't buy everything either. I've built plenty since that was worth building from scratch. The line that actually matters is whether you built it around yourself. If you're the only one who can run it, you didn't finish it. You stopped when it started working, which is a different thing.
These days the runbook and the list of ways it can break are part of done for me, not a someday-cleanup that never comes. The test I hold things to is simple. Could I hand this to somebody tomorrow and disappear for a month. I built a whole fleet-management platform recently with exactly that as the goal, made so people who don't write code can run it without me in the loop. It does the safe thing because of how it's built, not because I'm standing over it watching. Owning something like that feels nothing like owning the macro did. One of them I get to walk away from. The other one owned me.
Making it work felt like the win. It always does. That's why this is such an easy trap to fall into and such a hard one to climb back out of. But making it right, and making it so somebody else can run it, is the real win, and it happens to be the selfish one too. I like the next idea more than I like guarding the last one. I like the prototype, the thing sitting just past the edge of what I can do. You don't get to go chase any of that if you're chained to the one system holding the only key.
So now I try to make myself replaceable on purpose. Not because I've gone soft. Because it's the only version of this job where I get to keep moving. Make it work, sure. Then go back and make it right before it hits the fan. The thing I once mistook for job security was the exact thing keeping me stuck. Turns out the security I actually wanted was never being the only one who could do it. It was being good enough that I didn't have to be.