AWS Builder Center
Weekend Showcase Challenge: StyleSeek AI

Weekend Showcase Challenge: StyleSeek AI

StyleSeek AI is a conversational fashion discovery assistant that combines deterministic product filtering with Amazon Bedrock and Amazon Nova to recommend real, in-stock products based on natural-language requests.

AWS Student Builder Group Leader at University of Jaffna

Vision and What It Does

Online shopping usually expects users to know exactly what they want. You choose a category, select a colour, set a price range, and then browse through dozens of products.
But people do not always think in filters.
Sometimes the request is much simpler:
"I need something casual for university."
Or:
"Show me black T-shirts under LKR 3,000."
Or:
"Suggest something comfortable for travelling."
That idea became StyleSeek AI, a conversational fashion discovery assistant that allows users to describe what they want in natural language and receive suitable recommendations from a controlled fashion catalogue.
The application contains a demonstration catalogue of 30 fashion products priced in Sri Lankan Rupees (LKR). It includes T-shirts, shirts, hoodies, jeans, trousers, dresses, jackets, shorts, and accessories.
One of my main goals was to reduce a common problem in AI-powered recommendation systems: allowing the model to invent products that do not actually exist.
StyleSeek AI does not treat the AI model as the source of truth.
Each catalogue item has a real product ID, product name, category, price, colours, sizes, stock status, quantity, description, and tags. Before a recommendation reaches the user, the backend validates it against the catalogue.
The principle behind the project became:
Use AI for understanding people, but use application logic for enforcing facts.
StyleSeek AI Home Page

StyleSeek AI home interface showing the conversational fashion discovery experience built around Amazon Bedrock and Amazon Nova.



How StyleSeek AI Works

The frontend is built with Next.js and provides the conversational assistant, suggested prompts, recommendation cards, and product catalogue.
When a user enters a request such as:
Show me black T-shirts under LKR 3,000.

the request is sent to the NestJS backend.
Before calling the generative AI model, the backend performs deterministic filtering.
For this request, the system can identify constraints such as:
Category: T-Shirts
Colour: Black
Maximum budget: LKR 3,000
Availability: In stock

These rules are applied directly to the catalogue.
This means requirements that must be exact, such as budget, category, colour, and stock status, do not depend completely on generative AI.
The relevant candidates can then be processed through Amazon Bedrock using Amazon Nova Micro for natural-language understanding and recommendation reasoning.
After the model responds, the backend validates the returned product IDs again.
It checks that:
  • the product really exists in the catalogue
  • the product is in stock
  • the product stays within the requested price limit
  • important deterministic constraints are still satisfied
  • the model has not introduced an unknown product
Only validated catalogue items are returned to the user.



AI Recommendation in Action

StyleSeek AI processing the request "Show me black T-shirts under LKR 3,000" and returning a catalogue-validated recommendation that satisfies the user's budget.



Architecture

The overall application flow is:
User
↓
Next.js Frontend
↓
Amazon API Gateway
↓
AWS Lambda
↓
NestJS API
↓
Deterministic Filter Engine
↓
Amazon Bedrock
↓
Amazon Nova Micro
↓
Recommendation Validation
↓
Verified Catalogue Products
↓
User

The frontend is responsible for the user experience, while the backend remains responsible for catalogue data, filtering, validation, and communication with Amazon Bedrock.
This separation was important because I did not want AWS credentials or direct model access exposed in the browser.

🧩 Architecture Diagram

Architecture Diagram

StyleSeek AI architecture showing the Next.js frontend, Amazon API Gateway, AWS Lambda, NestJS backend, deterministic filtering layer, Amazon Bedrock, Amazon Nova Micro, catalogue validation, CloudWatch monitoring, and AWS SAM infrastructure.
This hybrid architecture became one of the most important decisions in the project.
AI handles the parts that benefit from flexible language understanding.
Traditional application logic handles the parts that need predictable and verifiable behaviour.



How I Built It

StyleSeek AI is built as a TypeScript monorepo.
The main structure is:
styleseek-ai/
├── apps/
│ ├── web/
│ └── api/
├── packages/
│ └── shared/
├── infrastructure/
├── docs/
└── amplify.yml

The frontend lives inside  apps/web  and uses:
  • Next.js 16
  • React
  • TypeScript
  • Tailwind CSS
  • Lucide Icons
The backend lives inside  apps/api  and uses:
  • NestJS
  • TypeScript
  • class-validator
  • Amazon Bedrock Runtime SDK
  • Serverless Express
The  packages/shared  workspace contains TypeScript interfaces, enums, and constants that are shared between the frontend and backend.
This keeps structures such as products, assistant requests, recommendation responses, and API contracts consistent throughout the application.
The product catalogue remains on the backend as the single source of truth.
A simplified product looks like this:
{
"id": "STY-001",
"name": "Essential Black Oversized T-Shirt",
"category": "T-Shirts",
"price": 2890,
"currency": "LKR",
"colours": ["Black"],
"sizes": ["S", "M", "L", "XL"],
"stockStatus": "IN_STOCK"
}

The frontend does not trust product information created by the AI model.
Instead, the backend validates the recommendation and retrieves the real product details from the catalogue.



Deterministic Filtering Before AI

I did not want to give the AI model full control over recommendation rules.
Some requirements are too important to leave entirely to probabilistic behaviour.
For example, if a user asks for:
under LKR 3,000

the system should not return a product that costs LKR 3,500.
For this reason, I created a deterministic filtering service.
It can extract requirements such as:
  • maximum budget
  • colour
  • product category
  • stock availability
It also recognises different ways users may describe a budget, including:
under 3000
below LKR 4000
less than Rs. 5000
I have LKR 6000

The AI layer is then used for the more subjective parts of the request.
For example:
  • "something relaxed"
  • "good for university"
  • "suitable for a birthday party"
  • "comfortable for travelling"
  • "something that matches black jeans"
This gave me a useful balance between the flexibility of generative AI and the reliability of normal application logic.



Amazon Bedrock and Amazon Nova Micro

The AI layer uses Amazon Bedrock.
I integrated Bedrock through the AWS SDK for JavaScript and the Bedrock Converse API.
The model configured for the project is:
us.amazon.nova-micro-v1:0

Amazon Nova Micro helps understand natural-language fashion requests and produce recommendation reasoning.
A simplified AI interaction looks like this:
Filtered Catalogue Candidates
+
User Request
↓
Amazon Bedrock
↓
Amazon Nova Micro
↓
Recommendation IDs + Reasons
↓
Backend Validation
↓
Verified Products

The model is never treated as the final source of product information.
If it returns an invalid product ID, that recommendation is rejected.
If a product is out of stock, it is rejected.
If a recommendation violates a hard budget limit, it is rejected.
This was important because I wanted StyleSeek AI to demonstrate practical AI engineering rather than simply placing a chatbot on a web page.



Handling Bedrock Limits Gracefully

Another challenge I faced was Amazon Bedrock throttling and account token limits.
During development, Bedrock could temporarily become unavailable due to service limits.
Instead of allowing that to break the complete application, I created a fallback recommendation flow.
If Bedrock cannot complete a request, the deterministic engine can still analyse the user's requirements and return valid catalogue matches.
The user therefore receives something useful instead of a raw infrastructure error.
The fallback still respects important constraints such as:
  • product existence
  • budget
  • category
  • colour
  • stock availability
This taught me an important lesson:
An AI feature should improve an application, but the whole application should not necessarily stop working when the AI service is temporarily unavailable.



AWS Services Used

AWS Lambda

The NestJS backend is deployed using AWS Lambda.
One of the biggest challenges during deployment was package size.
My original backend package became too large for a practical serverless deployment.
I used  esbuild  to bundle the NestJS backend and reduced the Lambda deployment package to approximately 3.7 MB.
This also required careful handling of NestJS dependency injection metadata.

Amazon API Gateway

Amazon API Gateway exposes the backend through HTTP endpoints.
The main routes include:
GET /
GET /health
GET /api/products
POST /api/assistant/recommend

API Gateway allows the frontend to communicate with the serverless backend through HTTPS.

Amazon Bedrock

Amazon Bedrock provides the generative AI layer.
All Bedrock requests happen from the backend, so the browser never receives AWS credentials or direct access to the model.

Amazon Nova Micro

Amazon Nova Micro provides natural-language understanding and recommendation reasoning.

Amazon CloudWatch

Amazon CloudWatch is used for Lambda logging and troubleshooting.
I also added request IDs so individual recommendation requests can be followed through the backend without exposing sensitive information.

AWS SAM

I used the AWS Serverless Application Model (AWS SAM) to define and deploy the serverless backend.
The infrastructure configuration covers resources such as:
  • AWS Lambda
  • Amazon API Gateway
  • IAM permissions
  • environment variables
  • CloudWatch logging
This allowed me to keep the AWS infrastructure defined as code alongside the application.



AWS Backend Running




StyleSeek AI backend running through Amazon API Gateway and AWS Lambda, exposing the API used by the fashion discovery assistant.



The Hardest Part: Deployment

The application worked locally before everything worked properly in a cloud environment.
Deployment ended up teaching me more than I expected.
One major challenge came from the TypeScript monorepo.
Both the frontend and backend depend on the shared package:
@styleseek/shared

The project worked locally, but the clean AWS Amplify build environment exposed a TypeScript path-resolution problem.
The frontend TypeScript configuration defined its own  paths  configuration, which replaced inherited path mappings rather than merging with them.
I fixed this by explicitly mapping the shared workspace package inside the frontend TypeScript configuration.
I also configured Next.js with:
transpilePackages: ['@styleseek/shared']

I worked through several other deployment-related issues as well, including:
  • Lambda deployment package size
  • API Gateway routing
  • JSON catalogue bundling
  • npm workspace resolution
  • TypeScript path inheritance
  • Next.js build configuration
  • CORS
  • environment variables
  • CloudWatch permissions
  • Bedrock throttling
The frontend works correctly in my local development environment, but I chose not to present an unstable public frontend deployment as a completed live application.
Instead, I am demonstrating the working frontend through screenshots while keeping the complete project available through the public GitHub repository. The serverless backend infrastructure is deployed on AWS.
This was one of the biggest lessons from the project:
A successful local build and a reliable production deployment are two different engineering problems.



User Experience

I wanted StyleSeek AI to feel like a dedicated AI application rather than a normal search form.
The frontend uses a dark cyber-style interface with:
  • conversational messages
  • recommendation cards
  • LKR pricing
  • stock indicators
  • category labels
  • catalogue filters
  • suggested prompts
  • responsive layouts
  • loading feedback
The application also contains a separate catalogue view where users can explore all 30 products.
Each product card displays information such as:
  • product ID
  • product name
  • description
  • price
  • category
  • colour
  • stock availability



Product Catalogue




The StyleSeek AI catalogue showing 30 fashion products with Sri Lankan Rupee pricing, product categories, colours, and stock availability.
The assistant and catalogue are connected to the same source of truth.
This is important because the products shown by the assistant must correspond to items that actually exist in the catalogue.
A typical request is:
Show me black T-shirts under LKR 3,000.

StyleSeek AI can then return a recommendation containing:
  • a verified product ID
  • product name
  • price
  • stock status
  • description
  • category
  • available sizes
  • recommendation reasoning
One UI issue I also faced was automatic scrolling.
When new assistant messages appeared, the browser could scroll the entire page unexpectedly.
I changed this behaviour so only the internal chat container scrolls while the main page remains stable.



Testing and Validation

I did not want to consider the project complete simply because the interface looked correct.
The final verification included:
npm run lint
→ Passed

npm run typecheck
→ Passed

npm run test
→ 12/12 tests passed

npm run build
→ Passed

The automated tests cover important behaviours including:
  • budget parsing
  • deterministic filtering
  • stock checking
  • catalogue lookup
  • invalid product IDs
  • malformed AI responses
  • Bedrock failure handling
  • input validation
I also manually tested prompts such as:
Show me black T-shirts under LKR 3000.

I need something casual for university.

Find me something under LKR 100.

I also tested requests designed to push the assistant outside the catalogue or expose information it should not provide, such as asking it to invent products or reveal system information.
The main goal was making sure that an invented AI product could never become a trusted catalogue recommendation.



Test Results

Automated verification of the StyleSeek AI backend, including unit tests for recommendation filtering and validation.



What I Learned Across the Summer

The biggest lesson I learned is that adding generative AI to an application is not mainly about writing a clever prompt.
The software around the model matters just as much.
For StyleSeek AI, traditional application logic handles the parts that must be exact:
  • product IDs
  • price limits
  • stock availability
  • catalogue validity
The AI model handles the parts that benefit from natural-language understanding:
  • style
  • occasion
  • preference
  • user intent
  • recommendation reasoning
I also gained more practical experience with serverless architecture.
Working with Lambda, API Gateway, Bedrock, Nova, CloudWatch, and SAM showed me how different AWS services can work together as one application.
Another major lesson was deployment.
Local development can hide assumptions about dependency resolution, operating systems, file paths, build outputs, and environment variables.
Moving the same project into cloud environments forced me to understand these details properly.
I also learned to think more carefully about graceful failure.
If a generative model is temporarily unavailable, the user should not necessarily lose access to the complete application.
The deterministic fallback layer made StyleSeek AI more resilient.



What I Would Improve Next

The current catalogue contains 30 demonstration products.
A future version could move the catalogue into a managed database and support a much larger inventory.
I would also like to explore:
  • vector-based product retrieval
  • product embeddings
  • image-based fashion search
  • outfit generation across multiple categories
  • user preference profiles
  • stronger conversation memory
  • real inventory integration
  • product similarity search
  • improved AI observability
  • a stable public frontend deployment
For a much larger catalogue, the same architecture could use deterministic filtering or retrieval to reduce thousands of items into a smaller candidate set before generative AI performs the final reasoning and ranking.



Project Repository

The complete project is available here:
The repository includes:
  • Next.js frontend
  • NestJS backend
  • shared TypeScript contracts
  • 30-item fashion catalogue
  • Amazon Bedrock integration
  • Amazon Nova Micro integration
  • AWS SAM infrastructure
  • automated tests
  • architecture documentation
  • deployment configuration
The screenshots in this article demonstrate the working frontend experience, while the backend infrastructure is deployed on AWS using Lambda and API Gateway.



A Builder Who Inspired Me

One project that caught my attention during the Summer Build Series was Rusiru Randika's "Roast My Code".
I came across the project last week, and I really liked the idea of turning code review into something more creative and engaging instead of making it feel like a normal static analysis tool.
What stood out to me was how the project used AI as part of a complete experience rather than simply sending a prompt to a model and displaying the response.
Seeing another Student Builder Group Leader build something creative like this encouraged me to think more carefully about the experience around the AI itself.
With StyleSeek AI, I tried to follow a similar principle by making Amazon Nova one component inside a broader recommendation system.
The AI helps understand user intent and generate useful reasoning, while deterministic filtering and backend validation remain responsible for catalogue accuracy, budget limits, stock availability, and verified product matching.
You can check out Rusiru's project here:



Final Thoughts

StyleSeek AI started with a simple question:
What if online shopping search felt more like explaining what you need to another person?
That idea eventually turned into a project involving frontend development, backend architecture, deterministic recommendation logic, generative AI, serverless AWS infrastructure, testing, security, and deployment troubleshooting.
The final result is more than a fashion chatbot.
It combines two different approaches.
Generative AI provides flexible natural-language understanding.
Traditional application logic provides control, validation, and reliability.
The most valuable thing I learned while building StyleSeek AI is that strong AI applications are not always the ones that give the model the most control.
Sometimes the better design is knowing exactly where AI should help and where normal software engineering should remain in charge.
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