AWS Builder Center
From 100+ SIH Problems to One: A Practical Guide to Finding the Right Problem Statement

From 100+ SIH Problems to One: A Practical Guide to Finding the Right Problem Statement

A practical guide to evaluating SIH problem statements based on user needs, existing gaps, innovation, MVP feasibility, team capabilities, and measurable impact before choosing the right one to build with AWS.

Cloud Computing Student | AWS Enthusiast | Exploring Cloud, DevOps & AI
When you first open the list of Smart India Hackathon (SIH) problem statements, the biggest challenge is often not building the solution.
It is deciding what to build.
With dozens of problem statements across different domains, it is easy to choose a problem because it sounds futuristic, mentions AI, or appears technically impressive.
But a good hackathon problem is not necessarily the most complex one.
The better question is:
Which problem gives our team the strongest combination of understanding, innovation, feasibility, and measurable impact?
This article presents a practical way to go from a large list of SIH problem statements to one problem your team can confidently build and demonstrate.

Start With a Shortlist, Not a Solution

One common mistake is selecting a problem and immediately discussing technologies.
For example:
"This problem uses AI, so let's build an AI model."
Instead, start by creating a shortlist.
From the complete SIH problem-statement list, select around 5–10 problems that genuinely interest your team.
At this stage, don't worry about architecture, frameworks, or AWS services.
Just ask:
  • Do we understand this problem?
  • Does it solve something meaningful?
  • Is the problem relevant to real users?
  • Does our team have some knowledge of the domain?
  • Can we imagine building a prototype?
The goal is to reduce the search space before making a technical decision.

The 7 Filters for Selecting an SIH Problem

Once you have your shortlist, evaluate every problem using seven filters.

1. Understanding

The first test is surprisingly simple:
Can your entire team explain the problem?
Take the official problem statement and rewrite it in your own words.
If your explanation still requires repeatedly reading the original statement, you probably haven't understood the problem well enough.
A good sign is when your team can explain:
Problem → Who faces it → Why it happens → What happens because of it
in less than a minute.

2. Real User

Every problem should have a real user behind it.
That user might be:
  • A government department
  • A citizen
  • A farmer
  • A healthcare professional
  • A student
  • A researcher
  • A field engineer
  • A disaster-response team
Now ask:
If we build this, who will actually use it?
This question changes how you design the entire solution.
A dashboard built for a government operator will have very different requirements from an application designed for citizens.

3. Current Situation

Before thinking about your solution, understand how the problem is handled today.
Research:
  • Existing government systems
  • Commercial platforms
  • Research projects
  • Open-source solutions
  • Existing workflows
  • APIs and datasets
This is where many hackathon teams discover something important:
The problem may already have a solution.
That isn't necessarily bad.
In fact, it can lead to a better project.
Instead of asking:
"Can we build a system for this?"
ask:
"Why is the existing system still not enough?"

4. The Missing Piece

This is where your actual opportunity can appear.
Maybe the existing solution is:
  • Too slow
  • Difficult to use
  • Expensive
  • Not real-time
  • Limited to certain regions
  • Dependent on manual processes
  • Missing useful analytics
  • Difficult to integrate
  • Unable to work with incomplete data
That missing piece becomes your potential innovation.
For example:
Existing approach
 Data → Manual Analysis → Decision 
Improved approach
 Data → Automated Processing → Prediction → Decision Support → Alert 
You don't always need to replace an existing system.
Sometimes, improving one critical part of it is enough.

5. The 24-Hour Question

Now comes one of the most important hackathon tests:
What can we actually demonstrate during the hackathon?
Don't design the final production system yet.
Design the smallest version that proves your idea works.
For example:
Full Vision
A nationwide intelligent disaster-management platform.
Hackathon MVP
One region + selected datasets + prediction model + dashboard + automated alert.
The second one is much easier to demonstrate.
A focused MVP allows your judges to see the actual value instead of listening to a long explanation about what the system could eventually become.

6. Team Fit

A problem can be excellent and still be the wrong choice for your team.
Look at your team's actual strengths.
Requirement
Team Capability
Frontend
React / Web Development
Backend
Node.js / Java / Python
Cloud
AWS
AI/ML
Python / ML
Database
SQL / NoSQL
DevOps
Linux / CI/CD
UI/UX
Design
Then compare this with the selected problem.
If your team already has the majority of the required skills, you have a significant advantage.
You can spend more time solving the problem instead of learning an entirely new technology stack during the hackathon.

7. Impact

Finally, ask:
What changes if our solution works?
Avoid vague answers such as:
"It will improve efficiency."
Try to define something measurable.
For example:
  • Reduce processing time
  • Reduce manual verification
  • Improve prediction accuracy
  • Reduce false alerts
  • Increase accessibility
  • Reduce operational costs
  • Support more users
  • Expand geographical coverage
Impact gives your project a reason to exist beyond the technology.

Build a Problem Scorecard

Once you have evaluated your shortlisted problems, turn your analysis into numbers.
Give every problem a score from 1–5 for each category.
Criteria
Score
Problem Understanding
/5
User Clarity
/5
Existing Solution Gap
/5
Innovation Potential
/5
MVP Feasibility
/5
Team Fit
/5
Measurable Impact
/5
Total
/35
For example:
Problem
Score
Problem A
28/35
Problem B
23/35
Problem C
31/35
Problem D
25/35
Problem C becomes your strongest candidate.
This approach is much better than choosing a problem because everyone in the team happens to like its title.

Don't Force AI Into Every Problem

One of the biggest traps in modern hackathons is starting with AI.
You might think:
"We need an AI feature because AI is impressive."
But AI should answer a real requirement.
If the problem requires prediction, classification, recommendation, anomaly detection, natural-language interaction, or intelligent automation, AI may make sense.
Otherwise, a simpler solution can be better.
The same principle applies to cloud services.
Technology should support the solution — not define the problem.

Where AWS Can Fit

Once the problem and MVP are clear, AWS services can be selected based on the actual architecture.
A simple application might look like:
 Users → Application → API → Database 
A data-heavy system could become:
 Data Sources → Amazon S3 → Processing → Database → Application 
A machine-learning solution could involve:
 Data → Amazon S3 → Processing → ML Model → API → Dashboard 
A serverless architecture might use services such as:
  • Amazon S3 for storage
  • AWS Lambda for event-driven processing
  • Amazon API Gateway for APIs
  • Amazon DynamoDB or Amazon RDS for application data
  • Amazon SageMaker for machine-learning workflows
  • Amazon Bedrock for generative AI use cases
  • Amazon CloudWatch for monitoring
The important part is not how many AWS services you use.
The important part is why you use them.

A Simple Decision Flow

You can think about SIH problem selection as a funnel:
All Problem Statements
↓
Interesting Problems
↓
Problems We Understand
↓
Problems With Real Users
↓
Problems With a Clear Gap
↓
Problems We Can Prototype
↓
Problems That Fit Our Team
↓
Problems With Measurable Impact
↓
Final Problem Statement

This prevents your team from jumping directly from a problem title to a technology stack.

Before You Lock the Problem

Your team should be able to answer these questions:

Problem

What exactly is happening?

User

Who experiences it?

Current Approach

How is it handled today?

Gap

What is missing?

Solution

What are we proposing?

MVP

What can we demonstrate?

Technology

Which technologies actually help?

Impact

How will we measure success?
If your team can answer all eight clearly, you are probably much closer to the right problem.

Final Thought

The best SIH problem statement isn't necessarily the one with the most advanced technology.
It is the one where your team can connect the dots:
Real Problem → Real User → Existing Gap → Practical Solution → Demonstrable MVP → Measurable Impact
AWS can then become the foundation that helps you build that solution reliably and at scale.
So before asking:
"What should we build?"
ask something more important:
"Which problem is worth spending our time solving?"
Once you get that decision right, the technology choices become much easier.
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