From mobile to full-stack: the years I spent unlearning

For about ten years I was an Android engineer. The kind whose hands knew where a particular framework method lived before the question was finished. The kind whose résumé read smooth in front of a hiring manager — same toolchain, same vertical, same set of problems getting subtly harder each year.

In 2018 I started giving that up. Not all at once, and not because I had a plan. I started reading backend code that I had been politely ignoring. I built a small web app. I rewrote it twice. I learned what a Postgres index actually does. I made all the embarrassing mistakes you make when you go from being good at one layer to being a beginner across five.

The unlearning was the hard part. Not “I don’t know TypeScript yet” — TypeScript is just reading. The unlearning was the muscle memory of being the expert in the room. The reflex to say “I know how this works.” The instinct, when something broke, to assume my decade of pattern-matching applied. Most of the time it didn’t.

What I kept from those ten years was harder to name. A sense for when a frame drop matters. A nose for releases that look fine but aren’t. A bias toward thinking about the user with a slow phone in a quiet city, not the user with a Mac on hotel wifi. These instincts didn’t transfer to backend or to AI products by analogy. They transferred by stubbornly insisting on being there — at design review, at the point of writing the first test, at the moment of deciding what to ship Tuesday.

I’m not nostalgic about Android. I don’t want to go back. But I notice now that the part of me that built consumer mobile apps for a decade is the part of me that, in 2024, refuses to ship an AI product that drops requests under load and calls it “experimental.” That’s not a methodology you can pick up by reading. You have to have been wrong on a Tuesday morning, with someone shouting at you, more than once.

The years I spent unlearning weren’t wasted. They were the actual education.