When my first data-fetching automation started working — however clumsily — I thought I was done. I'd type a command, data would come back, I'd drop it into a spreadsheet, and a half-day of work collapsed into a few seconds. For a few days I was genuinely thrilled.
Then one morning I ran the same command and got back an empty table. No error. Not a single line of red text — just a clean, blank result. At first I assumed that account simply had no data. I tried another account. Same. Everything was empty.
The strange part: the system never said it had failed. The response came back fine; the status code read success. Every signal said "all good," yet what I held was empty. Success on the surface, failure underneath.
The most expensive failures are the silent ones
After staring at it for a long time, I understood: what came back wasn't data — it was a login screen. My code believed it had received data, but what it had actually received was "who are you? log in again." Somewhere along the way, my queries had been quietly bounced out of authentication.
Here's why it took me days. When you log into a site, that logged-in state is kept alive by a small tag of sorts. My code borrowed the browser's tag — mimicking a login the browser had already done. But those tags come in kinds: some are valid "only inside this site," others stay valid "even when you pass through another site." My code flattened that distinction and treated every tag as the "inside this site only" kind. So during a cross-site login hop, the single most important tag silently fell off.
Nothing told me it was wrong. A missing tag doesn't stop the code. It just runs cleanly to the end in a logged-out state, hands you a login page dressed up as data, and reports "success." I burned days chasing that silent omission.
This was the first tuition I paid for a habit I'd lean on for years afterward: never trust something just because it looks like success. A failure that loudly throws an error is almost kind — it tells you where it broke. A failure that smiles and hands you an empty result will run wrong forever, as long as you don't suspect it.
Why logins keep falling apart
Once I fixed the empty-table problem, a bigger war was waiting. Logged-in state isn't permanent. After a while it expires. When a human uses a browser, that's no problem — you just log in again. In an automation running with no human present, it was lethal. If the login expired at 3 a.m., every query came back empty-handed until morning.
So I built a ladder that revived the login state automatically, a few rungs tall:
- Bottom rung — cheapest, fastest: if the login tag in hand is still alive, just use it. Most of the time it ended here.
- Middle rung: if that expired, climb up and mint a fresh one from a longer-lived tag. There was a trap here: this second tag had an absolute lifetime — no matter what I did, it failed exactly a day after issue. I didn't know that at first, and spent ages baffled by why a healthy automation died on a daily cycle.
- Top rung: when both were useless, as long as the longest-lived session tag survived, launch a browser and walk the entire login flow again from scratch. That tag lasted tens of days, so a human rarely had to step in.
MFA hell
Just as the ladder was nearly built, the last wall appeared: two-factor authentication. During the automatic re-login, the screen would sometimes demand "type the two digits you see into your phone app." If a human is sitting there, you just grab your phone. But I was often not there — out somewhere, having tossed a command at the automation from my phone and moved on. When the MFA screen appeared, the automation froze waiting for me, and I'd lose tens of minutes without knowing.
The way I solved it still makes me smile. When the automation hit the MFA digit screen, I had it screenshot that screen and fire it straight to my phone messenger. Wherever I was, I'd read the two digits and type them into the authenticator. What used to be tens of minutes of a stuck pipeline became a few seconds via one message. I left exactly that one action — typing the digits — as a human's job, and made everything before and after flow automatically.
The real difficulty isn't the task — it's the door
Writing this out, I was struck again: the hard part of automation isn't "the thing you want to do." It's "the door you have to pass before you can do it." The logic to fetch the data was simple. What held me for days was the login door that blocked the way before I ever reached that logic.
And here the same line I'd drawn earlier held. Understanding that login state lives in tags, that tags have kinds and lifetimes — that picture I had to grasp myself. Without it, I couldn't even ask "why is an empty table coming back?" But how to read and revive those tags, what code built the ladder — that I handed to AI. Understanding the door and writing the code to open it are different jobs, and as a non-developer, mine was the former. I asked as much as I understood, and delegated as much as I asked.
There was one more lesson. There is no such thing as full automation. However well I built the ladder, points remained where a human finally had to press — like the two MFA digits. For a while that bothered me. Then I changed my mind: instead of forcing those two digits away, keep only them in my hands and stitch everything around them as smoothly as possible. Telling apart the spot where a human must stay from the spot where a human isn't needed — that eye, in hindsight, earned its keep far more often than any code fix.
From my own experience automating knowledge work inside a large enterprise, adapted from one of my Korean e-books. Company, systems, and people are deliberately left unnamed.
Related reading: The Consumer's Seat · Why Most Enterprise AI Projects Stall at Proof of Concept
Comments
Post a Comment