Inspiration
Students looking for scholarships spend roughly 70% of their time just searching for opportunities they might qualify for, and only about 20% actually applying. That imbalance exists because every provider defines eligibility differently, and no existing platform verifies a student's identity and academic background once and reuses that verification everywhere. Students end up re-submitting the same documents over and over for scholarships they may not even qualify for — and a lot of them give up before finding the ones they'd actually win. We wanted to flip that ratio.
What it does
ScholarFit is a verification-and-matching platform, not a directory. A student builds one detailed profile and uploads their documents — ID, transcripts, proof of graduation — a single time. From there:
- An AI-assisted review checks the documents for consistency and legitimacy and produces a confidence score. High-confidence profiles are verified instantly; anything uncertain is routed to a human reviewer, so no account reaches the matching stage unverified.
- Every rejection or flag comes with a specific, human-readable reason (e.g. "passport expiry page missing") instead of a generic failure message, so a student can fix the actual problem and resubmit right away.
- Once verified, the profile is automatically checked against every scholarship's eligibility rules — whether entered directly by staff or pulled from a partner feed — and only the scholarships the student genuinely qualifies for are shown, ranked by fit.
- The student applies directly through the platform and tracks every application's status in one place.
How we built it
We started from the problem, not the interface: mapping out exactly where a student's time goes today (mostly search, barely any application) and asking what would need to be true to flip that. That led to three design decisions we treated as non-negotiable:
- Verify once, reuse everywhere — identity and academic verification is expensive to do well, so it should pay off across every future match, not just one application.
- AI clears the obvious cases; a person handles the rest — we didn't want to fully automate a decision that affects someone's access to funding, so anything the AI isn't confident about goes to a human, always.
- Every decision is explainable — a rejection without a reason is a dead end. A rejection with a specific reason is a task the student can actually complete.
From there we designed the platform as four layers — a presentation layer for students and admins, a business-logic layer that owns every rule, a background AI-processing layer so a slow verification check never freezes the app, and a data layer that keeps sensitive documents separately encrypted from structured records. We mapped the full student journey end to end (see the flow diagram) before worrying about screens, so the underlying logic would hold up regardless of what the interface eventually looked like.
Challenges we ran into
- Balancing automation with accountability. It would have been simpler to just auto-approve everything above a fixed threshold, but that risks silently verifying a fraudulent or mistaken profile. Routing every uncertain case to a human, and periodically spot-checking the automated decisions too, took more design work but felt like the only responsible option.
- Designing for explainability, not just accuracy. It's not enough for the system to be right — a student needs to understand why they were rejected well enough to fix it. That pushed us to define a real set of specific rejection reasons instead of a generic "verification failed."
- Keeping the eligibility model flexible. Scholarships come from very different sources (manual entry, partner feeds) with wildly inconsistent formats. We had to design a single shared eligibility-rule structure that both sources could feed into, so the matching engine could treat every scholarship the same way.
Accomplishments that we're proud of
A full, coherent system design — user journey, verification logic, matching logic, architecture, and a realistic phased build plan — built around one clear idea: students shouldn't have to prove themselves over and over to access funding they're already qualified for.
What we learned
The hardest part of a "matching" product usually isn't the matching algorithm — it's earning the trust to be allowed to match in the first place. Verification, explainability, and human oversight aren't compliance checkboxes here; they're the actual product.
What's next for ScholarFit
- Build the core profile, upload, and automated-review flow first, and validate it with a small real cohort of students.
- Partner with a handful of scholarship providers to seed a real catalogue before investing in large-scale partner-feed ingestion.
- Expand the fairness testing across a wider range of nationalities, education systems, and document types as the verification engine sees more real-world cases.
Built With
- ai
- canva
- document-verification
- education
- eligibility-matching
- market-research
- process-design
- product-design
- ux-research

