Start Small, Move Fast, Think Big.

Most ML apps die in the lab. Here’s what I learned building one anyway.

Machine learning is a solution looking for a problem.

Most teams get this backwards. They pick the coolest model, the biggest dataset, the most impressive architecture. Then they hunt for a problem worth solving.

We started differently.

Baldness goes unnoticed until it’s too late. No accessible tools. No early warning system. No affordable way to track it. That’s a problem worth solving. The ML came later.

My team spent our first week talking. Product managers, designers, developers—no code, just conversation. We asked: What problem are we actually solving? Not: What model should we use?

Our first idea was ambitious. Classify every scalp condition. Dandruff, psoriasis, different types of hair loss. We had research, datasets, team capacity. But we didn’t have the right technology stack. Apple’s frameworks couldn’t support it elegantly.

We pivoted. One condition. One area of the head. One demographic. Alopecia Androgenetic on the crown, for women. Based on the Sinclair Scale.

Suddenly, everything aligned. The problem, the resources, the timeline, the tech.

Three criteria guided every decision:

Does this solve a real problem?
Can we access what we need?
Can we ship this in three weeks?

If the answer was no, we cut it.

Perfect is the enemy of shipped.

We could have waited. Collected more data. Tuned the model. Chased 95% accuracy.

Instead, we shipped at 75%.

Not perfect. But useful. Good enough to validate the idea. Good enough to learn from real users. Good enough to prove we were solving the right problem.

1,100+ images. Three weeks. 75% accuracy. Six people.

Most ML teams would call that a failure. I call it proof of concept.

Real users break your beautiful model.

Here’s what the lab doesn’t teach you: Users don’t care about your accuracy metrics. They care whether your app works when they’re standing in their bathroom, holding their phone at a weird angle, with bad lighting.

We obsessed over two questions:

How do users actually capture this with their iPhone?
How do we show them results they understand?

The ML was straightforward. YOLOv8 for segmentation. CreateML for training. CoreML for on-device inference.

The hard part? Making it work in the real world.

We built head detection—ensuring the phone was positioned right. Sound and haptic feedback—guiding users without them looking at the screen. Visual overlays—translating ML output into something human.

And we designed for our context. Most Indonesians have black hair. Our dataset showed blonde, brown, red. If we trained on that alone, we’d fail on launch day. So we adjusted. Collected local data. Tested in real conditions.

Value comes from iteration, not inspiration.

After shipping our prototype, we didn’t celebrate. We talked to users. We consulted Dr. Desthi Minaristy, a dermatology specialist. We watched people use the app in real bathrooms, not demo videos.

Every conversation changed something. Refined the UX. Adjusted the model. Improved the guidance.

And we mapped the future:

Dandruff classification
Multiple baldness types
Scoring systems for progression tracking

Ship the core. Build the future in public.

The best model is worthless if no one uses it.

On-device processing. No server lag. Complete privacy. Seamless iOS integration.

We chose our tech stack—CreateML, CoreML, Swift, Haptics, Flask—not because it was cutting-edge. We chose it because it delivered the smoothest user experience within our constraints.

95% accuracy on a remote server that takes 10 seconds to respond? Users abandon it.

75% accuracy that runs instantly on-device? Users trust it.

Speed matters. Privacy matters. Experience matters.

The model is just one piece.

Heavy things take time. Light things disappear.

Three weeks isn’t long. But we didn’t build something disposable. We built a foundation. Something we could iterate on. Something that solved a real problem, imperfectly but honestly.

Most ML projects die because they optimize for the wrong thing. They chase perfect accuracy instead of user value. They build for the lab instead of the living room. They wait to ship until everything is flawless.

Flawless products ship never.

We shipped fast. Learned faster. And built something people actually used.

Start with the problem. Scope ruthlessly. Design for humans. Iterate publicly. Think big, but ship small.

That’s how you build ML apps that matter.

Rio Ikhsan is a Product Manager and Business Analyst at TurnkeyInside, and an Apple Developer Academy graduate from BINUS C7. He built Helai in three weeks with five teammates and 1,100 images. @ikhsanrio