
Bharat Builds Tour Project : SchemeLearn
An Integrated Platform for Jobs, Internships, Govt. Schemes and Certifications.
From Idea to Implementation: Building SchemeLearn with AWS at Bharat Builds Tour
Building a software product in a hackathon is not only about writing code. It is about taking an ambiguous problem, turning it into a usable product, making engineering trade-offs, integrating unfamiliar technologies, and getting the system into a working state within a limited amount of time.
For Bharat Builds Tour, I decided to build SchemeLearn, an India-focused platform that brings jobs, internships, government schemes, and free learning and certification opportunities together in one place.
I built the project independently as a solo participant.
The Problem
Students and early-career professionals often have to search across many different websites to find useful opportunities.
A job may be available on one platform, an internship on another, a government scheme on an official portal, and a free certification somewhere else. This creates several problems:
- Information is fragmented across different platforms.
- Relevant opportunities can be difficult to discover.
- Users may not know which opportunities are relevant to them.
- New opportunities are continuously being published.
- Information shared by users needs some level of verification.
- A platform that simply collects links can quickly become difficult to maintain.
The problem, therefore, is not just finding information. It is creating a structured discovery layer that can organize, search, and maintain opportunities while keeping user contributions under control.
The Solution: SchemeLearn
SchemeLearn is designed as a centralized discovery platform for:
- Jobs
- Internships
- Government schemes
- Free courses and certifications
Instead of requiring users to repeatedly search multiple websites, SchemeLearn provides a single interface where they can discover and explore these opportunities.
The platform is intended to complement the original sources rather than replace them. When an opportunity originates from another website, SchemeLearn can direct the user to the relevant source for the actual application or resource.
A Community Submission + Verification Model
One of the important workflows I implemented is the ability for users to contribute new opportunities.
A user can submit a link for a:
Job → Internship → Government Scheme → Course/Certification
However, I did not want every user submission to immediately become public.
The submission first goes into an administrative review workflow. The administrator can review the information and then approve, update, or reject it.
This creates a simple but important separation:
User contribution → Review → Verification → Approval → Public discovery
This approach makes the platform more maintainable and provides a mechanism for dealing with incorrect or potentially invalid information.
I also considered the reverse workflow: if users discover an invalid or outdated opportunity, they should have a way to report it so that an administrator can review the information.
Connecting Everything Into One System
One of the biggest parts of the project was not creating individual features, but connecting them into a coherent workflow.
The user-facing application, opportunity data, search functionality, submission system, administrative controls, authentication/authorization, and AI experimentation all had to work together.
This changed the way I approached development.
Instead of asking:
“How do I implement this feature?”
I increasingly had to ask:
“How does this feature interact with the rest of the system?”
That distinction becomes important when building a real application.
A feature can work perfectly in isolation and still create problems when it interacts with authentication, the backend, the database, external services, or deployment infrastructure.
Using AWS
The project also gave me an opportunity to work with several AWS technologies, many of which I was using for the first time.
Amazon OpenSearch
I used Amazon OpenSearch for search and discovery across the platform’s opportunity data.
This introduced me to concepts such as indexes, documents, queries, service endpoints, and connecting an application to a dedicated search service.
More importantly, it showed me the difference between implementing a feature locally and integrating a managed cloud service into an actual application.
Strands Agents SDK
I explored the Strands Agents SDK for agent-based AI functionality.
This helped me understand how AI agents can be incorporated into application workflows rather than treating AI as only a simple prompt-and-response interface.
PartyRock
I used PartyRock for generative-AI experimentation and prototyping.
It provided a relatively quick way to experiment with AI application ideas and understand how generative AI could fit into the product before integrating concepts into the broader system.
Cedar
I also explored Cedar for policy-based authorization.
This was particularly relevant to SchemeLearn because the platform has different types of users and administrative actions. The user-submission workflow requires certain actions to be available to administrators while keeping other functionality available to normal users.
Working with Cedar introduced me to the idea of expressing authorization policies separately from application business logic.
AWS SAM CLI
I used the AWS SAM CLI as part of the serverless development workflow.
It helped me understand how serverless applications can be structured and developed using a more defined infrastructure and deployment workflow.
The Reality of Cloud Integration
One of the most valuable lessons from the project was that cloud integration is not simply:
“Connect service → write code → done.”
For example, while integrating OpenSearch, I initially worked with the required configuration and connection details. Later, when I tried to modify the access configuration to allow broader access, I encountered issues with the expected configuration.
This forced me to think about access policies, security, application requests, and the difference between a service working from one environment versus another.
I eventually added local/fallback functionality so that the application would not completely fail when the external search service was unavailable.
This was not just a workaround. It taught me an important engineering principle:
A dependency should not automatically become a single point of failure when the product can reasonably degrade gracefully.
Deployment Was Another Learning Curve
The local application environment and the deployed environment were not identical.
When moving the project toward deployment, I encountered issues involving backend connectivity, environment variables, service configuration, and frontend-backend communication.
Deploying the frontend through platforms such as Vercel also highlighted the difference between:
“The application works on my machine.”
and
“The application works reliably in a production-like environment.”
Some backend errors only became apparent after deployment.
This forced me to make configuration changes, debug integrations, and repeatedly deploy and test the application.
That experience was particularly valuable because deployment is not an afterthought in software engineering. It is part of the system.
What I Learned
The biggest learning from Bharat Builds Tour was not a particular programming language or AWS service.
It was learning how to think about a product as a system.
1. Building is different from coding
Coding solves individual technical problems.
Building requires solving the entire chain:
Problem → Users → Product → Architecture → Implementation → Integration → Testing → Deployment → Iteration
2. Integrations are often harder than individual features
Writing a search function locally is relatively straightforward.
Connecting a real cloud search service to a deployed application introduces authentication, access control, networking, environment configuration, error handling, and deployment considerations.
3. Fallbacks matter
External dependencies can fail.
Designing fallback behavior can prevent one unavailable service from bringing down the entire application.
4. Authorization deserves architectural attention
Working with Cedar made me think more clearly about the difference between:
Authentication: Who is the user?
and
Authorization: What is that user allowed to do?
For an application with administrative workflows, this distinction is fundamental.
5. First-time technology adoption requires experimentation
I was using several of these AWS technologies for the first time. The process involved reading documentation, experimenting, encountering errors, changing the implementation, and testing again.
That cycle is a normal part of engineering.
6. A hackathon is an exercise in prioritization
With limited time and as a solo developer, it was impossible to build every possible feature.
The challenge was deciding what was necessary to demonstrate the core value of the product and what could be developed later.
That is one of the most important differences between building a demo and building a production-scale system.
What Bharat Builds Tour Meant to Me
Bharat Builds Tour gave me a practical environment to take an idea from a blank page to a working product.
The most useful part was the constraint.
Limited time forces decisions.
Should I add another feature or fix the existing workflow?
Should I spend another hour improving the UI or solve a deployment issue?
Should I use a new AWS service or keep the architecture simpler?
These decisions are difficult because there is rarely a perfect answer.
The hackathon therefore became an exercise in engineering judgment, not just implementation.
Looking Ahead
SchemeLearn is currently an MVP, but the underlying problem extends beyond the hackathon.
The long-term vision is to make opportunity discovery more intelligent, reliable, and personalized.
Future improvements could include stronger verification mechanisms, better recommendation systems, resume-based opportunity matching, automated information extraction, improved reporting workflows, richer search, and a more scalable cloud architecture.
The fundamental idea remains simple:
Make useful opportunities easier to discover, understand, and access.
Bharat Builds Tour gave me the opportunity to test that idea by building it rather than simply describing it.
And for me, that was the most important outcome of the project: moving from thinking → designing → building → breaking → debugging → deploying → improving.
That is where the real learning happened.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article