
ShopTrip: Building an AI-Powered Shopping Assistant from Scratch
ShopTrip is an AI-powered shopping assistant that helps users find where to buy products from a simple product image. Users can upload or capture a product and explore purchasing options across platforms like Amazon, Flipkart, and Blinkit. ShopTrip aims to simplify product discovery by helping users compare options based on price, availability, and delivery priority, saving time and making shopping decisions faster and easier.
๐๏ธ ShopTrip: Building an AI-Powered Shopping Assistant from Scratch
By Kaustubh Sanjay Shinde
Introduction
What if you could simply take a picture of a product in a store and immediately find out where you could buy it online, how much it costs, and which option makes the most sense for you?
That was the idea behind ShopTrip.
ShopTrip is an AI-powered shopping assistant designed to simplify product discovery and comparison. Instead of manually searching across multiple shopping platforms, a user can capture or upload a product and use ShopTrip to explore purchasing options based on factors such as price, availability, and delivery priority.
The project started as an idea, but quickly became much more than that.
It became a lesson in building a real application from scratch โ including Git, GitHub, React Native, Expo, routing, state management, debugging, testing, deployment problems, and working under a very real deadline.
๏ปฟ
๐ก The Problem
When shopping in a physical store, we often see products that we might want to compare with online prices.
The traditional process looks something like this:
See product โ Search product manually โ Open multiple apps โ Compare prices โ Check delivery โ Decide
That process becomes repetitive and time-consuming.
We wanted to simplify this into:
See product โ Capture it โ ShopTrip โ Compare options
The goal was not simply to build another shopping website.
The goal was to build a decision-support layer for shopping.
ShopTrip is intended for everyday shoppers who want to quickly compare purchasing options without manually searching through several platforms.
๏ปฟ
๐ Starting the Project
We started building ShopTrip as a practical project rather than trying to design a perfect architecture from day one.
The initial focus was on getting the application running and creating the core user experience.
Our technology stack included:
- React Native
- Expo
- Expo Router
- TypeScript
- Git
- GitHub
- VS Code
The mobile application was created using Expo SDK 57 with Expo Router.
The project repository was maintained on GitHub so that the development process and commit history could be tracked.
๏ปฟ
๐ป The First Challenge: Setting Up a New Computer
One of the interesting parts of this project was that development wasn't happening on a fully prepared development machine.
At one point, we had to move back to the original computer, where we had essentially just VS Code available.
That meant setting up the development environment again:
- Install Git
- Configure Git
- Clone the repository
- Install project dependencies
- Navigate into the correct project directory
- Start Expo
- Connect the application
- Continue development
It sounds simple.
It wasn't always simple. ๐
๏ปฟ
๐งฉ The First Major Lesson: The Directory Matters
One of our errors looked like this:
ConfigError:The expected package.json path:D:\Kaus_project\ShopTrip\package.jsondoes not existAt first, it looked like something was wrong with the project.
The actual problem was much simpler.
Our Expo application was inside the ย
mobileย directory.The structure was essentially:
ShopTrip/โโโโ mobile/โ โโโ package.jsonโ โโโ src/โ โโโ ...โโโโ ...We were starting Expo from:
ShopTrip/instead of:
ShopTrip/mobile/The fix was:
cd /d D:\Kaus_project\ShopTrip\mobilenpx expo start --clearThat small mistake taught us something important:
Many development errors are not caused by the framework itself. Sometimes we're simply running the right command from the wrong place.
๏ปฟ
๐ฑ Getting Expo Running
Once we were inside the correct directory, we started Expo using:
npx expo start --clearWe also used the web version during testing:
npx expo start --web --clearAt one point, Metro successfully started and we were able to connect the application through Expo.
We also encountered a bundling-related problem involving:
JSBigFileString::fromPathAfter restarting the Expo environment and clearing the cache, Android bundling worked again.
This became another recurring lesson:
When working with JavaScript/React Native tooling, clearing the development cache can be an important debugging step.
๏ปฟ
๐งญ Building the Navigation
After getting the application running, we started building the actual product flow.
We wanted users to be able to move from the home experience into a shopping trip.
The application eventually included routes such as:
Home โ โโโ Product โ โโโ Trip โ โโโ ExploreWe initially faced an issue where the homepage appeared correctly but the trip screen wasn't being reached.
The problem involved the interaction between:
- Expo Router
- ย
_layout.tsxย
- custom tab navigation
- route structure
We simplified and corrected the routing architecture.
The ย
/tripย route was then successfully connected.The first version of the trip screen showed information such as:
Shopping Trip #001๏ปฟ
Products Checked: 0Potential Savings: โน0๏ปฟ
[ Scan Product ]๏ปฟ
[ Finish Shopping Trip ]It wasn't the final product.
But it was the first real step toward the intended shopping workflow.
๏ปฟ
๐ ๏ธ Then We Broke the Code
One of the most memorable debugging moments happened while working on the product screen.
A file became heavily corrupted during an edit.
The resulting difference was enormous โ roughly 2,500 lines of changes where only a relatively small modification had actually been intended.
Some of the corruption involved escaped characters such as:
\`\<Instead of trying to manually repair thousands of lines, we compared the file against the known-good Git version.
We restored the original product screen:
git restore --source=HEAD -- src/app/product.tsxThen we preserved the intended changes in the relevant context/state file.
This was a major lesson in why Git is not just a place to upload code.
Git gave us a recovery point.
Without version control, debugging that corruption would have been much harder.
๏ปฟ
๐ Building the Shopping Trip Experience
Once routing and product screens were stable, we started expanding the shopping workflow.
The idea was to let a user create a shopping trip and add products to it.
The product flow included concepts such as:
- Product discovery
- Retailer selection
- Price comparison
- Adding a product to the shopping trip
- Tracking the selected retailer
- Opening the retailer
- Tracking shopping activity
We also added retailer-selection information to the trip context.
The intention was to distinguish between:
"The user viewed a product"
and
"The user actually selected a retailer."
That distinction matters if the application eventually evolves into a genuine shopping assistant.
๏ปฟ
๐ GitHub Became Part of the Product Journey
Another important part of the project was learning to work with GitHub properly.
Instead of keeping the project only on one computer, we maintained it remotely.
Our repository:
We worked with commits such as:
Add shopping trip screen and routingand pushed the changes to the ย
mainย branch.This became especially important when we switched computers.
The project could be cloned again instead of rebuilding everything from zero.
๏ปฟ
๐ป Switching Computers Under a Deadline
One of the biggest practical challenges came when we had to work on another computer.
The original development environment wasn't available with all the tools and downloads we had previously used.
So we had to start again with:
VS Code โGit โClone GitHub repository โInstall dependencies โRun Expo โContinue developmentThis experience made us realize something that isn't always obvious when following tutorials:
A project isn't really portable until someone else can clone it, install its dependencies and run it.
That changed the way we thought about our README and project setup.
๏ปฟ
๐ The Deployment Problem
Running the application locally was one thing.
Getting the application to work as a live, publicly accessible project was another.
Our local environment worked differently from the live environment, and we encountered situations where the live version didn't behave the same way as the localhost version.
That forced us to separate two questions:
Does the code work?
and
Can another person access and use it?
The second question is much more important when building something for real users.
It also became one of the reasons we started looking more seriously at cloud deployment and AWS.
๏ปฟ
โ๏ธ Our AWS Challenge
AWS was one of the areas where we initially encountered problems rather than immediately having a perfect implementation.
We attempted to work with AWS resources, but we ran into account/login/access-related issues during the process. At one point, access/session restrictions meant that we couldn't simply continue as if everything were configured normally.
Instead of hiding that part of the experience, it became one of the most useful lessons from the project.
Cloud development isn't only about writing code.
It also involves:
- Accounts
- Authentication
- Permissions
- Regions
- Service configuration
- Environment variables
- Deployment
- Access control
- Security
A locally working application doesn't automatically become a cloud application.
๏ปฟ
๐ง What We Learned About AWS
The ShopTrip experience changed our understanding of AWS.
Initially, cloud services seemed like something we could simply "add" to a project.
In practice, every cloud component needs a real purpose.
For example, an application like ShopTrip could eventually use cloud services for areas such as:
User authentication โProduct image storage โAI processing โProduct information โShopping comparison โRecommendationsBut we learned an important principle:
Don't add a cloud service just because its name looks impressive on a project submission. Add it because the application actually needs it.
That principle is something we want to carry into our future projects.
๏ปฟ
๐งช Debugging Became Part of the Project
Looking back, the most valuable part of ShopTrip wasn't just writing features.
It was debugging.
We encountered problems involving:
- Incorrect working directories
- Missing ย
package.jsonย
- Expo startup issues
- Metro bundling
- Routing
- Navigation
- Corrupted source files
- Git changes
- Switching development machines
- Localhost vs deployed behavior
- AWS account/access issues
- Authentication problems
- Time pressure
Every problem forced us to understand the system a little better.
๏ปฟ
โฑ๏ธ Building Under a Deadline
Another challenge was time.
We weren't working on ShopTrip with unlimited time.
We had a submission deadline, a demo to prepare, a GitHub repository to maintain, a resume to create, and a YouTube demonstration to record.
That meant we couldn't spend hours making every feature perfect.
We had to constantly ask:
What is essential for the next working version?
That changed our development strategy.
Instead of attempting to build everything at once, we moved toward incremental development:
Run โFix โCommit โAdd feature โTest โCommit โRepeatThat workflow was much more manageable.
๏ปฟ
๐ฎ What's Next for ShopTrip?
The current project is only the beginning.
The long-term vision includes a much more intelligent shopping workflow.
Possible future capabilities include:
๐ธ Product recognition
Take a picture of a product and identify what it is.
๐ Marketplace discovery
Find matching purchasing options across different platforms.
๐ฐ Price comparison
Compare prices rather than simply listing products.
๐ Delivery-aware recommendations
Allow users to prioritize:
- Lowest price
- Fastest delivery
- Availability
- Overall value
๐๏ธ Shopping-trip intelligence
Remember the products selected during a shopping trip and track the user's progress.
๐ Purchase lifecycle
Eventually, the system could track states such as:
Viewed โRetailer Selected โOpened โIn Cart โOrdered โDeliveredThe important part is that these are future directions, not claims that every capability already exists in the current version.
๏ปฟ
๐ What Building ShopTrip Taught Us
If I had to summarize the biggest lessons from this project, they would be:
1. Start before everything is perfect.
We didn't have the perfect development environment.
We built anyway.
2. Read the error message.
The missing ย
package.jsonย error looked serious.The actual problem was that we were in the wrong directory.
3. Git is a safety net.
The corrupted product file demonstrated why version control matters.
4. Build incrementally.
Small working features are easier to debug than one huge unfinished feature.
5. Localhost is not production.
An application working on your computer doesn't automatically mean it works for everyone.
6. Cloud architecture should solve real problems.
AWS services should be connected because they provide a meaningful capability โ not simply because they can be mentioned in a submission.
7. Documentation matters.
A project becomes much more useful when another developer can understand:
What is it?Why does it exist?How does it work?How do I run it?What technologies does it use?What problems were solved?What comes next?๏ปฟ
๐ Final Thoughts
ShopTrip started as an idea for making online shopping comparisons easier.
Along the way, it became something much more valuable for us: a practical introduction to real software development.
We learned how to set up a development environment, work with Git and GitHub, build with React Native and Expo, debug routing and bundling issues, recover from broken code, maintain project state, move between computers, and confront the difference between a local application and a deployable product.
Most importantly, we learned that building software isn't a straight line.
Sometimes the application works.
Sometimes the route doesn't.
Sometimes the terminal gives you an error that looks terrifying.
Sometimes a file gets corrupted.
Sometimes the cloud login doesn't cooperate.
And sometimes you have a deadline in a few hours. ๐
But every one of those problems becomes part of the engineering process.
ShopTrip is still evolving โ and that's the point.
We're not just trying to show a finished screen.
We're documenting the journey of turning an idea into a working product.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article