Once one of them ran end to end, I couldn't leave the rest alone.
The first thing I ever automated was a single lookup: pulling one customer's usage numbers. Every month I'd log into a system, find the account, open the usage screen, and copy the figures into a spreadsheet. Automating it erased that half hour at the start of the month. One command, and the number dropped out next to my cursor. For the first few days I ran it when I didn't even need to, just to watch it work. The small thud of a number appearing where my hands used to go was oddly reassuring.
Within days the idea started spreading. There isn't just one customer. Right now I only feed in one, but what if I ran it across all of them? And while I'm at it, wouldn't the trend over the last few months be far more useful than a single snapshot? And then I saw more: usage lived in this system, contract data in that one, support history somewhere else again. I'd been opening three places by hand every time. What if I pulled from all three at once?
Once I started seeing it that way, I couldn't stop. Everything I did by hand looked like a candidate waiting to be automated. In a meeting, hearing someone ask for a number, part of my head would already be running "I could pull that automatically." I counted my next targets while eating, while walking. The world split cleanly in two: things still done by hand, and things not yet automated.
Ten Lookups That Looked the Same
Going from one to ten didn't take long. I was close to addicted. I'd build one in the evening, and the moment it worked I'd start the next one on the spot. The count of working automations felt like a measure of my own skill. Yesterday it was three, today it's five. A folder filling up with files was the great pleasure of that stretch. A non-developer who, months earlier, couldn't get a single line to run without staring at red error text, had stacked up this much. That list was my report card, and the line count was the grade.
There was a trap in that pleasure, which I only see now. I was counting how many worked, not how they were working. I watched the list get longer, but never looked at what state each item was actually in. Growing and accumulating felt like the same word to me. But growing was a visible pleasure, and accumulating was an invisible weight. I had no idea a day would come when that weight landed on my shoulders.
Because the ten lookups all looked alike, I assumed I could build one well, copy it, and tweak a line or two for the next. So that's what I did: duplicate a working lookup, change one address, change one name, ship the next. It felt clever. Why build from scratch when you can branch from something that already runs?
But each one, up close, was not the same job at all. One system logged in differently; some needed only an ID and password, others an extra step after that. Some data wouldn't come all at once, so you'd fetch a little, ask again, fetch a little more, over and over. Some lookups changed which customer they targeted every run; others changed which slice of data I wanted that day.
This part matters. People imagine automation as "a machine tirelessly repeating the exact same task," like a factory arm looping one motion all day. My lookups were nothing like that. The customer in trouble right now, the contract under discussion right now, the field I need to check this minute, the target and the scope shifted every single time. It was less "run the same query daily" and more "reach for the right query whenever a need arises." Same tool, different use each time.
I Had Built Them, Never Operated Them
So the ten that looked alike actually carried ten different situations underneath. And the "one-line" tweaks piled up until the ten drifted into ten slightly misaligned things, each handling the same login a little differently, each receiving the same kind of data its own way. Branches from one root, each with its own quiet habits. Fixing one meant opening two or three side by side, eyes darting between them: this one's like this, that one's like that. I'd copied to save effort and somehow made more of it. Every time, I told myself "I'll clean this up next time." Next time never came, because next time there was always the fun of building something new.
That was the deeper mistake. Building ten meant I knew how to build ten, not how to operate ten, and at the time I couldn't tell those apart. The moment a lookup worked, it moved to the "done" column in my head. Finished. Nothing more to see. I never once thought about how they ran day to day, how they affected each other, what happened while I wasn't watching. The very idea that I should think about that didn't exist for me.
Here is the distinction I only grasped much later: building is what happens while I'm watching; operating is what happens while I'm not. I had only done the watching kind. But automation is, by definition, built to run while you're not watching. That obvious fact was invisible to me then.
For the record, I didn't write a line of this code myself. I said "pull this field for this customer, this way," and the AI turned it into something that ran. Sometimes I couldn't describe what I wanted well enough and had to re-pick my words, "no, not that number, the running total next to it." The reason I could even tell that the ten carried ten different situations wasn't that I'd read every line of their code. It was that I knew clearly what each lookup was for. What was needed, I knew; how to fetch it, the AI knew. That division of labor repeated identically across all ten.
The real lesson arrived later, when all ten started running at once and things that each ran fine alone began knocking each other over. Only then did I understand that I hadn't built ten tools; I'd built ten dependents that lived tangled together. The counting had felt like proof I was becoming someone who "could do this." The actual threshold wasn't making ten things work. It was learning that making and keeping are two entirely different jobs, and that I'd only ever done the first.
This essay is adapted from one of my Korean e-books on automating my own enterprise work as a non-developer. Details are anonymized: no company, system, or tool names, only the shape of what happened.
Related reading: When 'Just Run It on a Schedule' Turned Into a Self-Reviving Disaster · Eight Hours Became Two: What Automation Revealed About the Essence of My Job
Comments
Post a Comment