Why iOS, why now.

You'd think a post called "Why iOS" would start with iOS. It doesn't. It starts with why I chose apps at all.

Why apps, not the web

Looking back, what pulled me in was a feeling I couldn't shake: the best apps do the hard thing without letting you notice. And it was never just one thing.

Part of it is the network. WhatsApp holding a real conversation on a few kbps. ChatGPT — and later Claude — staying usable through flaky connections, retrying and reconnecting so quietly you never think about it. But the other part is the craft you feel and don't clock: Zomato and Swiggy taking a genuinely complex flow and making it feel obvious; Duolingo's micro-animations turning a lesson into something you actually want to come back to; Blinkit and Swiggy again, every tap acknowledged, the whole thing shaped around the person using it; District now, that same user-first instinct.

None of it announces itself. That's the whole point — the network resilience, the security, the tiny animations, the user-first decisions all disappear into "it just works." It was never only the plumbing that hooked me; it was that all of it is invisible when it's done right. The web, meanwhile, kept frustrating me: spinners that never resolve, dropped requests, layouts reshuffling under my thumb. We all choose our battles. I chose apps.

Not iOS, though — not at first. I didn't own an iPhone, and I wasn't going to build for a platform I could only ever see through a simulator. So the honest choice back then was broader: get genuinely good at the mobile stack.

The first thing I built alone

I started learning Flutter in college — mostly by ignoring college. Within about six months I could build an app on my own, without a tutorial running in another window. The first one was for a college hackathon: six hours, two screens, one HuggingFace API, a camera I wired up before I understood permissions. A plant disease detector — snap a photo, compress it ~80%, send it off, get back a disease and a confidence score.

Looking at it now, it's maybe thirty minutes of work. That night it took me six. Hostel room, 10pm to 4am, no sleep. I still remember the first clean compile — the first time something I'd built entirely myself actually ran. When it worked, I finally lay down. Didn't really sleep. It was the most peaceful not-sleeping of my life.

That awful little app taught me the thing I still work by: if I'm in it, it should be the best I can make it — not "will change the world," but "I didn't leave anything out." I put everything I had into it. No regrets.

Then I stepped into water I couldn't stand up in

I lost that hackathon, by the way — and felt none of the shame you're supposed to. I'd built a real thing, alone; that was the prize. Then came the bigger final-year project, and three friends and I built the thing that was actually annoying us: somewhere to keep travel tickets. Every trip meant re-authenticating just to see a ticket, or digging through WhatsApp for the PDF I'd forwarded to my mom. A real problem.

I didn't know backend, so I made the frontend as good as I could — and this time I chose React Native cold, on the logic of "I already know Flutter, how hard could it be?" It was stupid, and I look back on it fondly for exactly that: throw yourself in the water, learn to swim, now. The app never really worked — the backend was beyond us — but the part I still like did: ticket → structured JSON through the Gemini API, clean. It had potential we couldn't reach yet. (It's in my projects — Travel Companion.)

The narrowing

From there it stops being self-taught detours and becomes a job. The React Native I'd flailed through became the stack of my first one — real-time WebRTC video calling at SparkLink. Then Flutter, and a product I shipped end to end. Then native iOS — Swift, SwiftUI, UIKit — where the work stopped being "build this screen" and became "why does the whole app talk to the network like this?" Networking rewrites, security, the threading bugs that never show up in a demo but decide whether an app is trustworthy. (Later posts go deep on those. This one's just the map.)

Why iOS, why now

So — why iOS? That invisible craft pulls two ways: toward the polish (the animations, the feel) and toward the plumbing (the network, the security, the reliability). I went toward the plumbing — but it's the same instinct either way: make the hard part disappear. That's the layer under the feature, and it's where the pull that made me choose apps over the web kept sending me — down. Cross-platform got me building; native iOS is where I finally get to work at that depth, for real, in production, on the parts of an app you never see.

This is post 1. The rest gets specific — the networking rewrite, the security work, the Android port, the bugs worth remembering. Start here; the details come next.