I Didn't Climb the Tech Ladder - I Fell Into It
Opportunities expire. What two missed chances taught me about timing, readiness, and learning systems the hard way.
I once walked into an interview loop knowing I wasn't ready.
I did it anyway.
The AWS Loop
I was recruited to apply to AWS in 2022.
I approved since I was a tech-interview junkie back in the day.
Passed the early technical screens. They were good interviews - the kind you enjoy because they test how you think, not just what you memorize.
Then came the loop.
Somewhere in the middle of it, sitting across from yet another interviewer, I realized something uncomfortable:
I didn't actually want this job. Not yet.
My family and I were pursuing permanent residency in Australia. I was deeply committed to my current role. Leaving stability for prestige wasn't an option - not then.
But I hadn't admitted that to myself before flying in.
I walked into the loop misaligned. Not underqualified. Just not ready.
When the rejection email arrived, my first feeling wasn't disappointment.
It was relief.
The regret came later.
Not regret about AWS specifically - but regret about burning a rare, well-run interview process because I hadn't been honest with myself about timing.
Google Foobar
Foobar hurt differently.
Quieter.
I was invited in 2020. The google search opened up like a door and the terminal UI appeared in my browser - playful, clever, unmistakably Google.
I started the challenges.
I didn't finish them.
I'll come back later, I told myself. After the visa process. After things settle. After life pauses for a moment.
I assumed the opportunity would wait.
It didn't.
Foobar was discontinued. And with it, the chance to experience how Google evaluates engineers from the inside.
I didn't fail Foobar.
I postponed it until it disappeared.
That regret stayed longer than any rejection ever did.
The Pattern
These weren't failures of skill.
They were failures of timing.
I wasn't honest with myself about readiness. I treated opportunities like they'd pause for me.
They don't.
The Messy Path
My path into tech wasn't planned. It was a series of sideways moves, each teaching something the last one missed.
2001–2006: Internet Cafés
My first exposure to computers wasn't at home. It was at internet cafés in Lampung, Indonesia, playing games and watching others build things I didn't understand. The curiosity started there — not with code, but with what computers could do.
2012–2014: Early Frontend
My first real dev work. HTML, CSS, jQuery. Building things that worked, barely understanding why. I learned by copying, breaking, and fixing. No CS degree. No bootcamp. Just trial and error.
2016–2017: Game Design
A detour that didn't look like one at the time. I studied game mechanics, player psychology, interaction design. It seemed unrelated to "real" engineering. It wasn't. Understanding how users behave became foundational later.
2017–2019: WebGL & Awe.media
Building immersive web experiences. 3D, shaders, performance optimization before I knew what a render pipeline was. I learned why browsers choke, why abstractions leak, why "it works on my machine" is never the full story.
2018–2020: WalletHub Security
This is where security stopped being abstract. BugCrowd reports. Real vulnerabilities. Real attackers. I saw the same exploit patterns return again and again. Fixes that didn't stick. Designs that invited abuse.
2020–Present: Breville/Vervio
Full-stack, infrastructure, incident response. The role that finally connected everything — frontend behaviors, backend assumptions, security realities, system design. Not because the job required it, but because the problems demanded it.
Where It Finally Clicked
The click didn't come from big-name interviews.
It came from repetition. From pressure. From years watching systems behave badly.
Bugs ignored team boundaries.
Frontend failures caused by backend assumptions. Infrastructure problems blamed on "frontend slowness." Problems never stayed in their assigned layer.
Security failures kept returning.
Vulnerability reports never stopped. BugCrowd submissions. HackerOne findings. The same exploit patterns, over and over.
Fixes applied locally didn't stick. If you didn't design for abuse, abuse came back - stronger.
Over time, the pattern became clear:
Systems don't respect org charts. Attackers don't respect assumptions. And opportunities don't respect "later."
That's when I stopped thinking in layers.
And started thinking in systems.
Falling Forward
Looking back, my path looks messy.
I moved sideways more than upward. I learned by breaking production. I understood behavior before I learned terminology.
But that mess taught me things I still rely on:
- Why abstractions leak
- Why regressions return
- Why boring systems survive
- Why readiness matters more than opportunity
I didn't climb the tech ladder.
I fell into systems - and stayed.
If Your Path Is Messy Too
Before chasing any opportunity, ask yourself one question:
If they said yes tomorrow, would I actually go?
If the answer isn't immediately clear - you're not ready.
And opportunities don't wait.
Timing isn't separate from readiness. It is readiness.
That's the lesson I learned too late.
Twice.