SchemeFinder : Helping People Find the Government Schemes They're Already Entitled To
SchemeFinder is a multilingual assistant that helps Indians discover government welfare schemes they qualify for. Describe yourself in English, Hindi or Bengali and it shows matching schemes, why they match, the documents needed, and where to apply. Eligibility is decided by a tested Python rule engine, not an AI model, so it never invents rules.
What We Built
We built SchemeFinder, a highly scalable, mobile-optimized digital platform designed to instantly connect rural citizens with the exact government schemes they are eligible for. By capturing just a few data points —such as age, gender, occupation, income level, and state—the application dynamically filters through hundreds of welfare programs to deliver personalized, actionable results. Instead of forcing users to navigate complex government portals or read through 50-page legal PDFs, SchemeFinder outputs a simplified, localized dashboard. It tells the user exactly what the scheme is, the financial or social benefits provided, and a checklist of the precise documents required to apply.
The Problem
India operates one of the largest welfare networks in the world, with state and central governments rolling out schemes for farmers, students, small business owners, and marginalized communities. Yet, the friction to access these benefits is immense. The core problems are: The Information Labyrinth: Eligibility rules are highly conditional and scattered across entirely different departmental websites. The Language Barrier: Crucial documentation is often locked in formal English or highly bureaucratic regional dialects, making it inaccessible to the average villager. The Middleman Tax: Because the system is so opaque, citizens in rural areas often have to rely on local brokers who charge exorbitant fees just to tell them what forms to fill out.
The stack
- Frontend: plain HTML, CSS and JavaScript, with no build step, so it's fast on a basic phone.
- Backend: Python, structured as an AWS Lambda handler, with a standalone local server that wraps the same handler for development.
- Rule engine: checks age limits, income ceilings, target occupations, and state residency against a scheme database in JSON.
- Search: OpenSearch for weighted full-text search over scheme names, objectives, and benefits, with an automatic keyword-scoring fallback.
- Agent layer: [only keep this line if true: built with the AWS open-source Strands Agents SDK, with tools for eligibility checks, scheme details, and search].
- Deployment: a AWS SAM template for deploying behind API Gateway. Ready to deploy.
- Testing: [N] unit tests in pytest covering rule boundaries.
How AWS fits in
The backend is a Lambda-style handler with a SAM template, so the same code that runs on my laptop is what would run in the cloud. OpenSearch handles the search: when the server starts, it checks for an OpenSearch node, and if it's available, it creates and updates the
government_schemes index from the scheme data automatically. Queries then use weighted multi-field matching, giving scheme names three times the weight of other fields, so people find schemes without knowing exact names.What fought back
1. Keeping the AI out of the eligibility decision. It's tempting to let a language model read a profile and say "you qualify." But I wanted answers I could test. So the rule engine takes a profile and returns matches with the reasons, and I wrote tests for the boundaries: an income exactly at the limit, an age exactly at the cutoff, a state-specific scheme for someone from another state.
2. Making sure the app never breaks in a demo. Search depends on OpenSearch, and OpenSearch depends on Docker being up. So I built a fallback: if OpenSearch isn't reachable, the app switches to a built-in token-scoring search over scheme titles, objectives and categories. I did the same for setup: a plain Python server runs the Lambda handler without needing Docker or SAM CLI, so I could keep building even when those tools were slow.
What We learned
The biggest lesson: when real people's benefits are at stake, AI should explain and code should decide. We also learned to design for failure. Every external dependency (search, language models, Docker) has a fallback, so the core experience always works. Including OpenSearch and using AWS Lambda Handler was a very challenging task for us. The project is totally built in, we couldn't deploy it.
What's next
- Verify every scheme's rules against official sources, and add many more state schemes.
- Add voice input so people who can't read can still use it.
- Add a merged document checklist across all matching schemes.
Try it
- [Code]: ( https://github.com/Soumya9107/SchemeFinder )
- [Demo video]: ( https://youtu.be/fKAFbSxnKos )
Ai tools used
Google Antigravity
Claude ai
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article