SchemeSathi: Making Government Schemes Easier to Discover with AI

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

SchemeSathi is an AI-powered government scheme navigator designed to help Indian citizens understand which welfare schemes they may qualify for.

India has numerous government schemes for students, farmers, senior citizens, and families. But finding the right scheme can be difficult when eligibility criteria are scattered across official websites and notifications.

SchemeSathi lets people describe their circumstances in everyday language, including English, Hindi, Punjabi, and Roman-script variations. It converts their responses into a structured citizen profile and checks that profile against curated eligibility rules.

The central idea is simple: AI should help people understand the system, not make opaque decisions about their eligibility.

Instead of relying on an LLM to decide who qualifies, SchemeSathi uses a deterministic Python rule engine. Users get explanations of which criteria match, which fail, and which cannot yet be evaluated because information is missing. It also provides links to official sources and a printable PDF checklist to help users prepare for Common Service Centre visits.

I started building this as a practical project for people who might otherwise struggle to navigate government benefits. The longer-term vision is to make it useful for citizens, community volunteers, and service centres that help people discover relevant schemes.

Who could pay for it? A future version could be offered to NGOs, citizen-service organisations, or service-centre operators through paid deployments or support plans, while keeping basic scheme discovery accessible to citizens. This is a potential business model, not an existing revenue stream.

Demo

Try SchemeSathi: https://schemesathi-bwqq.onrender.com/

GitHub repository: https://github.com/GargCodesT18/schemesathi

The live application is the best place to explore the citizen-facing experience.

Code

The project is open source under the MIT License.

Explore the source code: https://github.com/GargCodesT18/schemesathi

The repository includes the application, scheme data, eligibility services, architecture documentation, and an offline test suite. The aim is to keep the eligibility logic inspectable and the implementation open to review and improvement.

How I Built It

I built SchemeSathi around a separation between language understanding and eligibility evaluation.

The main stack includes:

• Python for the application and eligibility logic.
• OpenRouter with configurable open-weight LLMs for extracting structured information from conversational input.
• Pydantic for validating citizen profiles and scheme data.
• FastAPI and React + Vite for the web application, with a secondary Streamlit interface.
• Deterministic Python rules for evaluating scheme eligibility.
• Render for deploying the web application.
• Pytest for testing the core logic offline.

The request flow is:

1. A citizen describes their situation in natural language.
2. The language layer extracts relevant information into a structured profile.
3. Pydantic validates the extracted data, while missing information remains explicitly unknown.
4. A deterministic rules engine evaluates the profile against the curated scheme criteria.
5. The application explains the outcome and points users towards official sources.

One design decision mattered more than any particular framework: the language model does not make the final eligibility decision. That decision belongs to explicit, inspectable software rules.

This project also taught me that adding AI to an application is not enough on its own. For something that affects access to public benefits, the surrounding validation, provenance, uncertainty handling, and explanations matter just as much.

Why Does Open Innovation Matter?

SchemeSathi deals with information people should be able to inspect, question, and verify. That makes openness especially valuable.

Using configurable open-weight models through a provider abstraction gives the project flexibility to experiment with different models and potentially move towards local inference without rewriting the eligibility engine.

Open-source code also lets other developers inspect the rules, challenge mistakes in the curated data, improve language support, and contribute features for communities that existing tools may overlook.

The deterministic eligibility engine is particularly important here. Even when the language model changes, the core evaluation logic remains testable and independent of the model provider.

There is still work to do. The current application uses a hosted inference provider, so it is not yet a fully offline system. But keeping the model layer replaceable creates a path towards more private, locally deployable versions.

I believe open innovation is most useful when it provides more than access to code: it gives people the ability to understand, verify, modify, and improve the systems they depend on.

My Agent Session

I used AI-assisted development while building this project. I don't have a shareable DevRelay session link to include here, so I'm leaving this optional section out rather than claiming a session I cannot provide.

Prize Categories

• Best Use of Render — the project is deployed on Render.