Skip to main content

The Day One Automation Became Ten: On Confusing 'Building' With 'Operating'

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

Popular posts from this blog

AWS vs Azure vs GCP in 2026: Which Cloud Platform Should You Choose?

The cloud platform decision is one of the most consequential technology choices an organization makes, and in 2026 it's also one of the most misunderstood. Most of the debate I see in enterprise architecture forums reduces to "we're an AWS shop" or "we go Azure because of Microsoft" — neither of which is a strategy. A platform choice made primarily on inertia or existing vendor relationships is a choice that will cost you for years. I've spent significant time in all three major cloud environments — AWS for scale workloads and data engineering, Azure for enterprise SAP and Microsoft-integrated architectures, and GCP for AI-intensive and analytics-heavy use cases. My goal in this guide is to give you a genuine, nuanced comparison that goes beyond feature lists and into the practical realities of choosing and running a cloud platform in 2026. I'll cover market position, each platform's honest strengths and weaknesses, how to match workloads t...

EU AI Act Compliance in 2026: What Every Enterprise Needs to Do Now

EU AI Act Compliance in 2026: What Every Enterprise Needs to Do Now The EU AI Act entered into force on August 1, 2024. The first provisions took effect six months later, and the full implementation timeline runs through 2027. If you're building, deploying, or using AI systems in or for the European Union, this law applies to you — and the window for being caught unprepared is closing fast. I've spent the past year working with enterprise clients on AI governance programs, and one pattern shows up again and again: organizations badly underestimate how much operational work compliance actually takes. It's not a checkbox exercise. It's a rethink of how you develop, document, deploy, and monitor AI systems. This guide is what I wish someone had handed me when I started — the substance of the law, the practical requirements, the deadlines that matter, and the mistakes I keep watching enterprises make. Photo by Petrit Nikolli on Pexels Photo by Karolina Gra...

I Was Keeping Passwords in My Code: A Non-Developer's First Taste of Technical Debt

While I was hastily building ten automations, I was writing passwords straight into the code. My excuse was that it was fastest. To log into a system you need an ID and a password, and if you don't put them somewhere in the code, the automation can't log in. A human just types them when the login screen appears; an automation has no hands to type. So I took the simplest road: I wrote them on the top line of the code. ID is this, password is that. It worked. And because it worked, I waved it off. What matters is that it runs — who cares where I wrote it down? It's code only I use, sitting only on my laptop. Nobody's going to open my laptop and read this file. That's how I talked myself out of it. Actually, "talked myself out of it" is too generous. I never even registered it as a problem. The question "is this okay?" never once surfaced in my head. The convenience that quietly becomes a liability The trouble with a shortcut like this is th...