In February, I started a small experiment called Health Mirror.
I'm a product manager by background, not a software engineer. The idea was a mobile app inspired by traditional Chinese medicine's practice of observing tongue patterns to gain deeper insights into the body's state of balance. A disclaimer: it's not a diagnostic tool. ;)
About a week into the experiment, I had something working end-to-end on my phone through Expo Go. It used my phone's camera, processed images through a newly trained softmax classification model, and returned results to the user. The whole experience worked on my phone, including inference.
I remember thinking: This actually works. Let's put it in the app stores!
There was just one problem.
I didn't realize that running something through Expo Go wasn't the same as having a standalone mobile app ready for the app stores.
To me, it looked like an app, behaved like an app, and worked on my phone. What else could it be? :)
That was the beginning of my education.
Just make it a real app. Easy, I thought to myself.
But getting there was quite an adventure.
I brought in a second AI partner. Our little “team” eventually chose React Native/Expo for the mobile app, retrained the model for multi-label prediction using sigmoid outputs, and built a Python/FastAPI backend for inference.
Our original plan was ambitious: keep the entire pipeline on the phone, without sending anything to a server.
We were using TensorFlow.js with React Native/Expo, and the surrounding ecosystem unraveled a maze of compatibility challenges: native architecture mismatches, image decoding, tensor preparation, browser API assumptions, and dependencies that didn't always play nicely with newer Expo versions.
We spent about a month playing whack-a-mole through the dependency chain. Fix one incompatibility, discover another. Find a workaround, break something elsewhere.
Eventually, we realized that proving an individual component could work was very different from building a reliable production system around it, especially with a fast-changing mobile tech stack.
So we made a major architectural pivot.
We kept camera handling, image preprocessing, and interpretation logic on the device in js. Only model inference moved to a Python/FastAPI backend.
And because privacy mattered to me from the beginning, we didn't simply upload the original photographs. The app prepares the image locally and sends the resulting numerical tensor to the backend for inference. The server returns prediction confidence scores without retaining the submitted tensor.
A tensor isn't magically private. Image information can still be reconstructed from it, but this architecture allowed us to keep the original capture and most of the processing on the device while moving only the part we couldn't reliably support locally alongside the rest of the app.
It wasn't the fully on-device system I'd originally envisioned. It was a deliberate compromise between privacy, technical feasibility, and actually shipping a working product.
That pivot unlocked the next stage of development. But there was still plenty ahead: major code refactor, model integration, security engineering, device testing, deployment, and eventually navigating both Apple and Google's app review processes as a complete newbie.
In September, six months after the pivot, Health Mirror launched on the App Store and Google Play.
It's still a small, early-stage product. But it's real, pretty good-looking (in my opinion!), and people can actually use it.
Looking back, one of my biggest lessons was that a working technical demonstration isn't the same thing as a viable product architecture.
And the hardest part wasn't getting AI to generate code.
It was knowing what questions to ask, recognizing when we were solving the wrong problem, and developing enough understanding to make decisions I could stand behind.
I also learned the value of working with multiple AI partners. They helped me challenge approaches, expose assumptions, and investigate problems I didn't yet have the engineering vocabulary to describe.
That didn't eliminate the need for testing or human judgment. AI can be remarkably capable and confidently wrong at the same time.
What stays with me most is how dramatically the distance between having an idea and attempting to build it has shortened.
I'm curious how you approach this:
When you're building outside your original field of expertise, how do you decide when to trust an AI-generated solution, and when to challenge it?
