More project photos (2)
The problem
Students miss scholarships they were eligible for every admission cycle. Schemes are scattered across the National Scholarship Portal, state DBT portals and dozens of private CSR pages, and each scheme has its own eligibility maze — category allowlists, income caps, minimum marks, domicile rules, gender or year restrictions. A student typically learns about a scheme from a forwarded message days after its deadline. Existing aggregator sites list schemes but do not tell a specific student which ones they can actually apply for. This project closes that gap: a web app with a curated scheme directory, a rule-based eligibility matcher that evaluates the student's profile against every scheme's hard criteria, live deadline countdowns, and an alert signup so no deadline slips by. The demo runs as one dependency-free HTML file — profile in, ranked eligible matches out, each with the exact criteria it satisfied.
Fills one profile form, browses matches and signs up for deadline alerts.
Follow the working sequence
How it works
- The student fills one profile form: course level, study year, gender, category, domicile state, family income, last-exam percentage, and minority/disability flags.
- On submit, the matcher runs checkEligibility() against every scheme: each hard rule (level membership, category allowlist, income ≤ cap, marks ≥ minimum, gender/domicile/year gates) is evaluated, and any scheme with a failing rule is excluded.
- Eligible schemes receive a match score — base 95, +5 when marks exceed the scheme minimum by 10+ points, +2 for schemes with no marks bar — capped at 100, then sorted best-first.
- The deadline engine computes days-left from the current system date; ≤14 days renders urgent, ≤45 days closing-soon.
- The directory view filters client-side by search text and scope chip, and sorts by deadline, amount or name without any server round-trip.
- The detail modal assembles key facts, apply steps and the document checklist directly from the scheme's structured record.
- Alert signup validates the email format, persists the alert in localStorage, and the deadlines view lists active alerts with a remove option.
Tech stack:
- HTML5 · CSS3 · JavaScript (ES6)
- Rule-based eligibility engine (deterministic, no ML)
- Browser localStorage (alert persistence)
- Responsive CSS Grid · Flexbox layouts
- System font stack (zero external dependencies)
- Chrome DevTools Protocol (demo screenshots)
- reportlab (abstract PDF generation)
- Git
| Parameter | Value |
|---|---|
| Directory size | 18 schemes: national, state, private/CSR (demo build) |
| Eligibility criteria per scheme | 7–9 hard rules evaluated (design) |
| Match computation | Client-side; full directory in well under 50 ms (expected) |
| Match score range | 95–100 for eligible schemes (design target) |
| Deadline basis | System date; days-left rounded up (expected) |
| Alert storage | Browser localStorage, per-scheme (design) |
| External dependencies | None — single HTML file, no network calls (design) |
| Demo file size | Approximately 46 KB (demo build) |
| Browser support | Any modern browser with ES6 + localStorage (expected) |
Project features
- [Rule-based eligibility matcher] Evaluates every scheme's hard criteria — course level, category allowlist, income cap, minimum marks, gender, domicile, study year — and returns only schemes the profile fully satisfies, each with a match score and per-criterion ticks.
- [Curated scholarship directory] 18 national, state and private/CSR schemes with indicative amounts, deadlines, document checklists and step-by-step apply guidance in a searchable grid.
- [Live deadline countdowns] Days-left computed from the system date for every scheme; deadlines within 14 days flagged urgent and within 45 days flagged closing-soon, with color-coded progress bars.
- [Deadline alert simulation] Per-scheme alert signup with email validation, stored in the browser's localStorage, simulating a reminder 7 days before the deadline; alerts can be added or removed.
- [Search, filter and sort] Full-text search across names, providers and tags, scope chips (National / State / Private), and sorting by deadline, amount or name.
- [Scholarship detail view] Modal showing key facts (amount, income cap, marks bar), the how-to-apply steps and the documents usually needed, with a one-click alert button.
- [Zero-dependency single-file build] Pure HTML/CSS/JS with the system font stack — no frameworks, no build step, no network calls; runs offline after download.
What is included
- Working single-file demo web app (matcher, 18-scheme directory, deadlines, alerts)
- Complete source code with the documented rule-engine logic
- Curated scheme dataset as a structured, extensible JS array
- Project report PDF (background, requirement analysis, system design, matching logic, testing)
- PPT presentation for final review
- Viva Q&A preparation document (rule-based vs ML matching, web architecture, validation, data freshness)
- Abstract PDF (10-section structure)
Limitations & prerequisites
- The demo ships with 18 curated schemes; a production build needs a maintained database because scheme rules, amounts and deadlines change every academic year.
- Amounts and deadlines in the demo are indicative placeholders for demonstration — the buyer verifies current figures on official portals (NSP, state DBT) before relying on them.
- Matching is a deterministic rule engine, not ML: it cannot judge ambiguous cases such as "equivalent" qualifications or schemes with subjective interview rounds.
- Alerts are a localStorage simulation — no real email or SMS is sent; the full build needs a backend plus a mail/SMS provider.
- The profile lives in the browser session only; there are no user accounts or server-side saved profiles in the demo build.
- Deadline countdowns use the device's system date, so a wrong device clock produces wrong countdowns.
- North-East domicile schemes can show as ineligible in the demo because the state list does not enumerate NE states individually.
Frequently Asked Questions
Does the app use AI or machine learning?
No — and that is deliberate. Eligibility matching here is a deterministic rule engine: each scheme's published criteria (category, income cap, marks, domicile) are encoded as hard rules and evaluated exactly. This makes every match fully explainable — the app shows which criteria passed — which is both more correct for this problem and much easier to defend in a viva than a black-box model.
Where does the scholarship data come from?
The demo ships with 18 realistically curated schemes (national, state and private/CSR) with indicative amounts and deadlines for demonstration. The dataset is a plain structured array designed to be extended — the built-to-order report documents exactly how to add schemes, and a production version would replace it with a maintained database or admin panel.
How do the deadline alerts work?
In the demo, setting an alert validates your email and stores the alert in the browser's localStorage; the deadlines view lists your active alerts and the app simulates a reminder scheduled 7 days before the deadline. The full build described in the report adds a backend service with a real mail/SMS provider for actual delivery.
Can this be extended with a real backend?
Yes. The report's future-scope section sketches the natural next step: a REST API (e.g. Node/Express or Django) with a schemes database, user accounts for saved profiles, an admin panel for updating deadlines, and a scheduled job that sends real reminders. The frontend's scheme-record structure is already shaped to map 1:1 onto database rows.
Is this project suitable for a final-year project?
Yes — for Computer Science, IT and Web Development programs. It demonstrates requirement analysis, data modeling of real-world rules, algorithm design (the matching engine), responsive frontend engineering, and honest handling of data freshness — all with a working demo you can show end-to-end. Suitable for B.E./B.Tech final-year projects in Computer Science, IT and Web Development.
Components & software requirements
- HTML5 · CSS3 · JavaScript (ES6)
- Rule-based eligibility engine (deterministic, no ML)
- Browser localStorage (alert persistence)
- Responsive CSS Grid · Flexbox layouts
- System font stack (zero external dependencies)
- Chrome DevTools Protocol (demo screenshots)
- reportlab (abstract PDF generation)
- Git
Delivery information
Built-to-order project. Delivery timeline is shared after order confirmation based on current queue.
Support terms
Complete documentation, setup guide, and viva preparation included. Support for setup and explanation provided.
Download free synopsis (PDF)
Enter your name and email — the synopsis PDF downloads immediately. We may send occasional project updates; no spam, unsubscribe anytime.