
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.
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.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article