Skip to main content

The Door Before the Task: How a Non-Developer Lost Days to a Silent Login Failure

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

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...