AWS Builder Center

The Application Should Not Be the First Place You Discover a Defect

How a rejected student application became the reason we built a pre-submission checker for scholarship schemes

A ₹1,000 Problem

I come from a simple, peaceful town in Assam. Life here does not move with the urgency of a metro city. People know each other. Families manage what they have. Students learn to stretch a little money further than it was meant to go.
I have a friend I respect a lot. We help each other with things. Sometimes he helps me understand something; sometimes I help him get something done. We study in the same university, in the same batch, with many of the same classes and deadlines.
But the similarity ends there.
His father drives an auto-rickshaw. His mother passed away when he was seven. He is still dependent on his family for a large part of his expenses. For someone in that position, a few thousand rupees is not an abstract number. It is transport. Food between classes. A recharge. A book. It is the difference between asking home for money again and managing one more week on your own.
In August 2026, Assam began rolling out the Mukhya Mantrir Nijut Babu Aasoni, or MMNBA. The state-level launch and application-form distribution began on 6 August, and the programme was presented as financial support for male students from economically weaker families. The official Higher Education Department guideline specifies ₹1,000 per month for eligible UG first-year students, for up to ten months in an academic year, or ₹10,000 for the year. For eligible PG first-year students, the figure is ₹2,000 per month, again for up to ten months.
I was not personally eligible. My friend had a reason to care.
His application was rejected.
I do not know every internal reason for that rejection, and I do not want to invent one. What I did know was that government applications can be quite unforgiving about small differences between what a student types and what their documents say. The MMNBA guideline itself tells students to ensure that their submitted data is correct and complete, while registrars and principals are responsible for collecting and verifying student data before auto-verification in the Samarth portal. An income certificate or a parent's ration card is required for verification and upload.
That was the thought that stayed with me: what if a student could find the mistake before the application reached the person checking it?

The uncomfortable part was not the rejection

The uncomfortable part was how little visibility a student has into the gap between their documents.
A student does not usually think in terms of a data model. They think: 'I have my Aadhaar. I have my marksheet. I have my income certificate. I have the bank details. I filled the form. I should be done.'
A verifier sees something different. They see a set of records that are supposed to describe the same person.
One document may spell a surname one way. Another may spell it slightly differently. A bank record may contain a different account-holder name. An income certificate may put a number above the scheme's ceiling. A scan may be technically uploaded but practically unreadable. The student sees four PDFs. The verifier sees four claims that have to agree.
That difference in perspective is where we found the product.

So we built Defect Guard

Defect Guard is a pre-submission document checker for the Mukhya Mantrir Nijut Babu Aasoni. It is not the Assam government's portal. It does not submit an application. It does not decide whether the government will approve a student. It does one narrower thing: it tries to find document and application defects while the student can still fix them.
The workflow is deliberately simple:
·        Upload the documents that belong to the application.
·        Extract the relevant fields from each document.
·        Put those fields beside one another in an Application Snapshot.
·        Run the scheme rules against that snapshot.
·        Explain the defects and give a concrete fix.
·        Replace a document if necessary and run the check again.
The important word is again. We did not want to build a scanner that says 'something is wrong' and leaves the student staring at a red box. The useful loop is Upload > Extract > Snapshot > Check > Fix > Re-check > Ready.

The moment the product made sense

Imagine four documents on a desk.
The Aadhaar says:
ANTARJIT DAS
The marksheet says:
ANTARJEET DASS
The income certificate says:
₹4,50,000
The scheme's income ceiling is:
Below ₹4,00,000
And the bank proof says the account belongs to the same student under yet another representation of the name.
A normal form-filling workflow makes the student look at these documents one at a time. Defect Guard puts them in one table.
That table is our Application Snapshot. It is the heart of the product: one field, many documents, one place to see whether the story agrees with itself.
The snapshot does not magically prove truth. We don’t intend it do that really. It just makes disagreement visible.

We did not let the AI be the judge

This was one of the most important design decisions we made.
There is a tempting version of this product where an LLM reads four documents and returns: 'Looks good.' We did not build that.
Some checks are not reasoning problems. They are arithmetic or validation problems.
Is ₹4,50,000 below ₹4,00,000? Python can answer that.
Is a required document missing? A rule can answer that.
Is an IFSC formatted correctly? A validator can answer that.
The deterministic engine in Defect Guard contains named MMNBA rules for identity consistency, missing documents, gender, income, document quality, declared document type and file constraints. The income ceiling check is pure arithmetic. The readiness score is also calculated in Python; the model never gets to invent the number.
Then there are questions that are genuinely messier.
Are 'DAS' and 'DASS' actually two different people, or did OCR and spelling variation get in the way? That is where Bedrock is useful. We use it as an ambiguity adjudicator and as a writer of evidence-grounded explanations and fixes, not as the source of scheme law.
Even there, we put guardrails around it. The model's output is schema-validated. It cannot invent a finding ID. Quoted evidence has to exist in the extraction data. Confidence below a threshold forces a more cautious outcome. And the score has no field in the model's schema at all.
Our strictness is simple for this: The LLM can help us interpret ambiguity. It does not get to decide what the scheme means.

AWS was not decoration

We were building for First Commit's Ship It track, so there was another constraint: AWS had to be part of the product, not a logo at the bottom of a slide. The hackathon's own brief says the blog prize is about writing up the problem, the stack, and what fought back; the main submission also requires the project, demo and AWS story to be concrete.
Our target architecture is a serverless pipeline.
The browser uploads documents directly to Amazon S3 using presigned URLs. That keeps the document bytes off the Lambda request path. Amazon Textract's AnalyzeDocument API reads the documents using QUERIES and FORMS, producing the raw evidence we need. Amazon Bedrock then has two focused jobs: mapping noisy extraction into typed fields and adjudicating the small number of ambiguous findings. DynamoDB stores packet state and verdicts, while API Gateway and Lambda provide the API and asynchronous workers. The frontend is a static export hosted through AWS Amplify.
There is a reason after all why the pipeline is asynchronous. Document extraction and model reasoning can take longer than an ordinary API request should. So the API accepts the work, workers process it, and the browser polls for the result. We chose not to introduce Step Functions, SQS, EventBridge or a larger orchestration layer for a workflow that can be handled by two workers. For a two-person hackathon team, every extra moving part is another place to lose a night.

Then AWS fought back

It would be dishonest to write this story as if the architecture appeared fully formed and everything deployed on the first try. Unpopular opinion but: Trying without regards to failing in a hackathon beats the people who build in their first try any day. That’s the spirit of First Commit too I would say: “To learn, and build, and relearn”.
For our team, AWS was one of the things that fought back.
We were new to parts of production AWS administration. IAM trust policies were not a checkbox. Bedrock model access was not a checkbox. Cross-region inference and service connectivity were not a checkbox.
The repository ended up containing the SAM infrastructure, Lambda handlers, Textract query definitions, Bedrock structured-output schemas, DynamoDB adapters and a substantial automated test suite. But we did not finish the live cloud-console integration during the hackathon. Rather than quietly pretending that a code-complete deployment blueprint was a live production system, we kept that limitation honestly and directly visible and built a deterministic offline Demo Mock Mode for judge evaluation. We were not going to be affording to ship anything that absolutely didn’t work.
That decision changed how I think about engineering under a deadline from now.
A fallback is not admitting defeat if the fallback preserves the product's truth.
Our mock mode is not a fake screenshot. It runs the actual verification lifecycle against validated fixtures and a deterministic state machine. The AWS mode remains the intended production path. The distinction is documented because we would rather lose a little glamour than lose trust.

The re-check is the part I care about most

Suppose the first report shows three problems.
A name mismatch. An income ceiling breach. A document-quality or file-size issue.
The student replaces the income certificate with a compliant one.
They click Re-check.
The income finding disappears. The score changes. The other findings remain because they were not magically fixed by replacing an unrelated document.
That sounds small. It is not.
It turns the system from a report generator into a correction loop.
Our demo is designed around exactly this moment: a first verdict, a document replacement, and a second verdict. The implementation plan treats the re-check as an important part of the MVP because the point is not merely to detect a defect but to let the student see the effect of fixing it.

The numbers are deliberately boring

I mean that as a compliment.
The MMNBA guideline says the eligible UG first-year student receives ₹1,000 per month, up to ten months, and the eligible PG first-year student receives ₹2,000 per month, up to ten months. The guideline also sets the family-income condition at below ₹4 lakh and requires a valid income certificate from the competent authority or a parent's ration card for verification and upload.
Those are not numbers an LLM should be asked to remember from a prompt.
They belong in a versioned ruleset.
That is why Defect Guard stores scheme rules as configuration and gives each rule a source. If a government guideline changes, the right response is not to retrain a model and hope. It is to update the rule, test it, and know exactly which behaviour changed.

Privacy had to be part of the design

There is an obvious problem with building software that reads Aadhaar cards and bank documents: the easiest demo data to use would also be the data we absolutely should not use.
So the demo pack is synthetic. The documents are fictional specimens and are visibly marked as such. No real citizen Aadhaar, bank account or income certificate is used in the repository, video or writeup. Aadhaar is masked before persistence, logs contain field names and operational metadata rather than field values, S3 objects are designed to expire after one day, and DynamoDB records use a 24-hour TTL.
That is not just a compliance paragraph at the bottom of a README.
It changes what we build.

What we learned that had nothing to do with AI

The first lesson was that a vertical slice beats a beautiful architecture diagram.
We built the contracts and fixtures early so the frontend could keep moving even when AWS configuration was blocked. That meant the UI did not depend on a perfect backend on Friday. It also meant that when the cloud path fought back, we still had something real to test.
The second lesson was that deterministic code is underrated. A small Python function that compares a number against a ceiling is easier to test, explain and trust than a paragraph asking a model to reason about the same number.
The third lesson was that AI needs boundaries and guardrails more than it needs freedom…
During development, the model could produce plausible text that was not actually grounded in the extracted evidence. The evidence-grounding guardrail caught that class of failure. Without it, a beautifully written defect report could have been confidently wrong. Ah, the beauty of AI hallucinations.
And the fourth lesson was much more personal…
When I started this project, I thought I was building a document checker. I was actually building a small piece of distance between a student's mistake and a lost opportunity.

Why I keep thinking about my friend

I do not know whether a tool like Defect Guard would have changed my friend's application. I cannot honestly say that a document checker would have guaranteed approval. Government verification is still government verification, and a lot of actual decisions require a human institution to make them.
But I keep coming back to the possibility that the rejection might have contained a fixable mistake.
If the problem was a spelling mismatch, show the two spellings.
If the problem was the income document, point to the number.
If the bank proof is inconsistent, show which name or account field disagrees.
If the scan is unusable, say that before submission.
Do not make a student wait until after the application has left their hands to learn what they could have fixed at home.

Our goal wasn’t to build a smarter application form

We built a second pair of eyes. That distinction matters.
Defect Guard does not replace the Assam government's verification process. Rather than creating documents, forging records, submitting applications, or promise a benefit, it gives the student a structured pre-flight check and lets them decide what to do with the result. That boundary is intentional.
The bigger idea is not limited to Nijut Babu.
The same pattern exists anywhere a person has to assemble a packet of evidence: scholarships, fee waivers, grants, admissions, reimbursements and other public-benefit applications.
The document set is usually the user's responsibility. The cross-document consistency check may be not.

A small product, for a very human problem

WeMakeDevs asked us to build something that solves a real problem. For me, this was real before it became technical.
The stack matters. The architecture matters. The test suite matters. The AWS services matter. But none of those were the starting point.
The starting point was a friend who could have used another ₹1,000 a month.
Maybe software cannot solve the larger economic problem. It cannot replace a parent, a steady income, or a better safety net.
But sometimes software can remove one stupid obstacle.
That is what I wanted Defect Guard to do. Period.

Some Sources and build notes (‘Cuz I did my homework)

Official scheme source: Government of Assam, Higher Education Department, Executive Order / guideline for Mukhya Mantrir Nijut Babu Aasoni. The document states the target student categories, income condition, document-verification requirements, and monthly assistance amounts.
Launch reporting: India Today NE reported that Assam began distributing Nijut Moina and Nijut Babu application forms statewide on 6 August 2026; college reporting from CNB College records the same date and the live state-level launch programme.
National Scholarship Portal reference: the 2026–27 portal explicitly exposes a 'Defective Application Verification' stage for multiple scholarship schemes. Defect Guard is not an NSP plugin; this is included only as evidence that defective-application verification is a real stage in scholarship workflows.
Project: Defect Guard: A Scholarship Pre-Submission Checker. The project documentation defines the Application Snapshot, deterministic rule engine, AI adjudication boundary, re-check loop, privacy model and synthetic-data policy.

Editorial note from Antarjit: This article intentionally avoids claiming that clerical defects are the majority cause of scholarship rejections; the project notes explicitly reject using an unsourced rejection-rate statistic. The personal story is presented as the author's experience and motivation, which may or may not be adapted from real-life scenarios and facts, and is not an evidence of a general rejection pattern.
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