AWS Builder Center
ShopTrip: Building an AI-Powered Shopping Assistant from Scratch

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.

AI/ML Student | Building Real-World Solutions | Hackathon Enthusiast | Future Entrepreneur

๐Ÿ›๏ธ 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:
  1. Install Git
  1. Configure Git
  1. Clone the repository
  1. Install project dependencies
  1. Navigate into the correct project directory
  1. Start Expo
  1. Connect the application
  1. 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.json
does not exist
At 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\mobile
npx expo start --clear
That 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 --clear
We also used the web version during testing:
npx expo start --web --clear
At one point, Metro successfully started and we were able to connect the application through Expo.
We also encountered a bundling-related problem involving:
JSBigFileString::fromPath
After 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
โ”‚
โ””โ”€โ”€ Explore
We 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: 0
Potential 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.tsx
Then 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 routing
and 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 development
This 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
โ†“
Recommendations
But 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
โ†“
Repeat
That 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
โ†“
Delivered
The 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.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article