Where the hours went.

Frontend across iOS, Android and web on a shipping consumer AI product, plus two of the services behind it. Rebuilt onboarding and then A/B tested the new flow against the old one, which is where the conversion gains came from.

Set up the app's design system and removed the two UI libraries it had accumulated, Tamagui and NativeBase, over four phases; a later pass settled the app on a single experience and deleted 268 files and roughly 60,000 lines of what those migrations had left stranded. Built the asset library service every style, material and user upload is served from — curated assets shared, user uploads private, new collections added as data rather than as a schema change — and the remote-config service the app reads its flags and tutorials from, backed by one JSON document the team edits in an internal dashboard.

Both were written with AI assistance and neither was architected by it — collections as data rather than schema, and one canonical shape for the config, are the calls that keep them simple. Accessibility went in alongside each feature rather than after it, product analytics with it, and on-call and production triage came with the seat.

Frontend problems land on my desk from across the team, including from engineers with more years than I have, and talking them through is a normal part of the week rather than a favour. When the interaction design is mine to work out rather than handed over, what I propose is generally what ships.

Sole developer on three apps: vehicle maintenance for a trucking operation, point of sale for a park, and verified attendance. Each was mine end to end — architecture, implementation, releases, and the production support that follows.

All three had to hold up on phones and tablets, and on an operations floor rather than at a desk. I worked with the people using them daily, which is the fastest way to find out what a screen actually costs someone mid-shift.

Sole frontend developer across three product lines — EazyDukan, WebRasoi, and Zluper — owning the mobile and web frontend end-to-end, from architecture through production. All three reached real users: Induskriti, a well-known terracotta chain, ran both its POS and inventory management on EazyDukan, as did several smaller shops.

A restaurant or two used WebRasoi's restaurant-specific flows, and Zluper took orders daily from launch. Took full ownership of the release lifecycle — app store releases, OTA updates, error and performance monitoring, and Core Web Vitals — and contributed to backend and cloud infrastructure when the work called for it, and the final year of it ran alongside a full-time role elsewhere.

First engineering job, and the senior whose work I picked up left a few weeks in, so the client app and its roadmap became mine as a fresher. It was JavaScript with no types and real users already on it, which is a quick way to learn what a codebase costs you when nothing states the shape of your own data.

Built health tracking and assessment apps for medical clients. Built RHIA, a voice-first assistant covering registration, appointments and front-desk tasks, and a JSON-to-React-Native converter so server-described components stopped being hand-written twice.

Guided a junior engineer through an automated email and PDF pipeline — mostly getting HTML to render reliably in email, which is where that kind of project actually stalls. Engineers with five years on me started bringing their frontend problems to me while I was still the newest person in the room, and I could usually work them out on the spot.

Asked more than once to think through UI and UX myself rather than build to a handed-down design, and those went into the product as proposed. I left knowing frontend was the part I was genuinely good at, and knowing why.

Wrote and built a React Native course that starts at first setup and ends at a release build, taught with Expo throughout. Worked to a brief and a schedule set by a mentor, which turned out to suit me — given the guardrails and a date, the work lands inside them.

The curriculum runs from components and navigation up through native modules, performance and store releases, built around worked examples and projects rather than reference prose. Having my own explanations reviewed by someone further along is where a lot of the fundamentals actually set.

This came before my first full-time engineering role, which is a strange order — teaching the thing, then going and doing it for a living. It is also why writing something down clearly enough for another developer to follow reads as part of the work to me, not overhead on top of it.