AWS Builder Center
Weekend Showcase Challenge: AWS Service Picker

Weekend Showcase Challenge: AWS Service Picker

Describe your problem. Discover the right AWS services.

Series: Weekend Challenge (3 articles)

  1. 2
    Weekend Showcase Challenge: AWS Service Picker This article
Sharing, Learning, Growing Together
Built for the AWS Summer Builder Showcase.


Vision & What It Does

When I started building applications with AWS, one of the biggest challenges was not always understanding how a service works, but knowing which service to choose and why.
AWS provides a huge range of services, which can be overwhelming for students, beginners, and developers who are starting their cloud journey. Choosing between services such as Amazon S3, Amazon DynamoDB, AWS Lambda, and Amazon Bedrock depends on the application's actual requirements.
That is why I built AWS Service Picker.
AWS Service Picker is an AI-powered application that helps developers describe their application idea or technical problem in plain language and receive practical AWS service recommendations.
For example, a user can enter:
"I want to build an application where users upload images and receive AI-generated descriptions."
The application analyzes the requirements around compute, storage, databases, AI, networking, security, and scalability. It then provides:
  • A ranked list of relevant AWS services
  • A match score for each recommendation
  • A simple explanation of why the service was selected
  • An alternative service and its tradeoffs
  • A simple architecture diagram
  • A step-by-step implementation checklist
The complete transformation is:

Problem
↓
Requirements
↓
AWS Services
↓
Reasoning
↓
Architecture
↓
Build Plan
One of my favorite features is "Why not?". Instead of simply recommending a service, users can ask questions such as:
"Why DynamoDB and not RDS?"
The application explains the tradeoff in beginner-friendly language and helps the user understand when another service might be a better choice.
I also added Architecture Review, where users can describe an existing AWS architecture and receive feedback about unnecessary services, missing components, security, scalability, cost, and possible alternatives.
The goal is not just to give users a list of AWS services. The goal is to help them understand the reasoning behind an architectural decision.




How I Built It

I wanted to keep the application simple enough to build during a weekend while still demonstrating real AWS functionality.
For the frontend, I used HTML, CSS, and vanilla JavaScript without a frontend framework or build step. This made the application lightweight and easy to deploy as static files. I designed the interface as a developer-focused workspace rather than making it look like a generic chatbot.
The backend uses an AWS Lambda function written in Node.js behind an Amazon API Gateway HTTP API. The backend contains focused handlers for service analysis, the "Why not?" feature, architecture review, and project persistence.
For the AI layer, I used Amazon Bedrock with an Amazon Nova model through the Converse API.
One challenge was making AI recommendations reliable. I didn't want the model to randomly recommend AWS services or provide inconsistent information. To address this, I grounded the model with a curated knowledge base of common AWS services and required the model to return structured JSON. The application also parses the response defensively.
For persistence, I used Amazon DynamoDB to store project information, requirements, recommendations, architecture, implementation checklists, and creation dates.
Another important decision was building a deterministic fallback engine. If Amazon Bedrock is unavailable, throttled, times out, or produces an unusable response, the application can fall back to predefined rules. This means the core experience can still work instead of completely failing.
For operations and security, I added:
  • CloudWatch structured logging
  • Error monitoring
  • Least-privilege IAM permissions
  • Input validation
  • Configurable CORS
  • Friendly error and retry messages
I also created an AWS SAM template to provision the Lambda function, API Gateway, DynamoDB table, log groups, alarm, and required IAM permissions.
I built the application in stages:
MVP
↓
Problem Analysis
↓
AWS Recommendations
↓
Reasoning
↓
Architecture
↓
Build Plan
↓
DynamoDB History
↓
Architecture Review
↓
UI Polish
↓
Deployment
After implementing the main features, I tested the complete flow end to end.



AWS Services Used / Architecture Overview

The application uses a lightweight serverless architecture.

USER
|
↓
WEB APP
|
↓
AMAZON API GATEWAY
|
↓
AWS LAMBDA
/ | \
↓ ↓ ↓
AMAZON AMAZON AMAZON
S3 BEDROCK DYNAMODB
|
↓
AMAZON NOVA
↓
CLOUDWATCH

AWS Services

AWS Service
Role
Amazon Bedrock / Amazon Nova
AI-powered requirement analysis and AWS service recommendations
AWS Lambda
Runs the backend application logic
Amazon API Gateway
Provides the public HTTPS API
Amazon DynamoDB
Stores projects and recommendation history
Amazon S3
Static hosting / application assets
Amazon CloudFront
Delivers the web application
Amazon CloudWatch
Logs, metrics, and error monitoring
AWS IAM
Provides least-privilege permissions
The architecture is intentionally simple. Instead of introducing infrastructure that the application doesn't need, I focused on using managed AWS services that allow the project to remain lightweight and scalable.



What I Learned Across the Summer

Building this project helped me understand that creating an AI application is not just about connecting a model to a user interface.
One of my biggest lessons was that grounding matters.
Giving the model a curated knowledge base and requiring structured JSON output produced much more reliable and predictable results than using an open-ended prompt.
I also learned the importance of designing for failure.
AI services can experience throttling, timeouts, unavailable models, or unexpected responses. Adding a deterministic fallback allowed the application to degrade gracefully instead of completely breaking.
Another important lesson was least-privilege security.
Planning IAM permissions early helped keep the Lambda role focused on only the resources and operations it actually needed.
Most importantly, I learned that reasoning is more valuable than simply generating an answer.
If AWS Service Picker only returned:
"Use DynamoDB."
it would not teach much.
But when it explains:
"Use DynamoDB because your application needs simple, scalable access to structured data. RDS may be a better option if you need complex relational queries and joins."
the user learns how to make the decision themselves.
That became the core idea behind the project:
Don't just tell developers which AWS service to use. Teach them why.
The Summer Build Series also pushed me to think beyond building a prototype. I learned to consider deployment, reliability, security, monitoring, documentation, and the overall user experience.



Conclusion

Building AWS Service Picker was a valuable way to bring together everything I learned throughout the Summer Build Series. What started as a simple idea helping developers choose the right AWS service evolved into a practical AI-powered application that explains what to use, why to use it, and how to build with it.
Through this project, I learned that building a useful AI application requires more than connecting a model to an interface. Grounding, structured outputs, fallback handling, security, monitoring, and clear user experience are all important parts of a reliable solution.
The biggest lesson I’m taking forward is that good cloud architecture is not about using the most services it is about making the right decisions for the problem.
The Summer Build Series helped me move from experimenting with AWS services to actually building, deploying, testing, and showcasing a complete application.
AWS Service Picker Don't just choose an AWS service. Understand why.
Try AWS Service Picker

Live Application -  https://d3fv3i64u2ywb8.cloudfront.net  Repository -  https://github.com/dineshrajdhanapathyDD/AWS-Service-Picker.git  The live application is deployed on AWS.

Builder Inspiration

I was inspired by Usmani Mariyam Seemab (@mariyamseemab), a fellow AWS Community Builder 2026 and Cloud & AI enthusiast. Her passion for building, learning, and experimenting with cloud and AI encouraged me to keep exploring practical AWS solutions and turn my own idea into a working project for the Summer Build Showcase.
Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments; I’d love to hear from you.
If you want to connect or dive deeper into cloud, AI and DevOps, feel free to follow me on my socials:
💼  LinkedIn 
👨‍💻  DEV Community 
🛡️ Medium 
🐙  GitHub 



Series: Weekend Challenge (3 articles)

  1. 2
    Weekend Showcase Challenge: AWS Service Picker This article
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