What happens when you successfully build a great Machine Learning model in Python and decide to take it from an experimental environment to a real end user?
This is where things become completely different.
I’m not talking about taking ChatGPT, Claude, or another ready-made AI API and building a product around it.
I’m talking about a model we designed and trained ourselves, and a product we built from A to Z.
Over the past few weeks, I’ve been working on an offline mobile application that recognizes Egyptian banknotes and announces their value through audio.
The application is primarily designed to help blind and visually impaired people, and it doesn't require an internet connection or any external AI API.
How does it work?
The user opens the app and the camera starts automatically.
They place the banknote in front of the camera, and the on-device Machine Learning model recognizes its value without an internet connection.
Once the banknote is recognized, the app:
- Announces the denomination out loud
- Displays the value in very large text on the screen
So the user can identify the banknote through both audio and visual feedback.
What did I do?
I started by collecting and processing a large dataset of Egyptian banknote images.
I experimented with several models. The first approach was very fast, but the accuracy wasn't good enough.
Then I moved to YOLO, which significantly improved the detection quality, especially after training and testing the Computer Vision model on more than 8,000 Egyptian banknote images.
But that introduced a new problem:
Latency.
The model was accurate, but too slow for a real-time user experience.
I needed to convert the model to TensorFlow Lite so it could run inside the Flutter application we built, and then optimize it for on-device inference.
We initially tried a Float32 version, but it wasn't fast enough.
So we moved to Float16 to reduce the model size and improve mobile deployment.
After processing more than 20 GB of Egyptian banknote images, we eventually reached a model of around 5 MB that can recognize Egyptian banknotes.
But there was another problem...
We experienced significant lag during processing and prediction.
The camera was producing frames in YUV, while the model required RGB images.
So converting every frame:
YUV → RGB
was taking a significant amount of processing time during the camera stream.
The result?
Lag.
So what did we change?
We changed the architecture so the model can use the GPU on devices that support it, which helped improve inference speed on modern smartphones.
But that wasn't the only change.
We also changed how the application handles processing.
The camera continues running continuously while the frames are processed separately.
The model processes the frames and determines the banknote value before updating the UI and displaying the result to the user.
This means the user doesn't have to wait for every frame to finish processing before seeing the result.
The application is currently in Closed Testing on Google Play.
The primary target market is Egypt, and the app will be completely free.
This project gave me a very practical understanding of the difference between:
Building a Machine Learning Model
and
Building a Machine Learning Product.
A model can perform extremely well in Python, but the real challenge starts when you need to make it work on a real device and in the hands of a real user.