NeuroCredit

• 

• 

• 

• 

• 

• 

Inspiration

Across the world, billions of people manage their money responsibly every day — paying bills on time, saving consistently, building stable lives — yet they're turned away the moment they ask for a loan. Not because they're untrustworthy, but because they're invisible. No credit card history, no formal credit score, no paper trail the system recognizes. Traditional credit scoring was built for a narrow slice of the population. It was never designed for gig workers, freelancers, informal traders, or anyone whose financial life doesn't fit neatly into a bank statement. 1.4 billion people globally are credit invisible — and the system wasn't built to see them. We asked a simple question: what if your daily financial habits could speak for you? What if paying your bills on time, transacting regularly, and saving consistently actually counted — verified, owned by you, and readable by any lender on earth? That question became NeuroCredit. We combined ML's ability to find trustworthiness in alternative data with blockchain's ability to make that trust portable and permanent. A credit score you own, carry in your wallet, and no institution can take away. We built NeuroCredit because financial access shouldn't depend on which system you were born into.

What it does

NeuroCredit is a decentralized alternative credit scoring system that gives anyone a verifiable credit score — without a bank account, credit card, or formal credit history. It works in three steps:

1. Score from alternative data Users submit 14 financial signals across five categories — payment consistency (utility, mobile, rent), transaction activity (UPI patterns), income stability, savings behaviour, and tenure. An XGBoost ML model processes these signals and outputs a credit score between 300 and 900 in under a second. No bank statement required.

2. Own your score on-chain The score is minted as an ERC-5484 Soul Bound Token on Polygon — a non-transferable NFT permanently bound to the user's wallet. It cannot be sold, faked, or taken away. The raw financial data never touches the blockchain; only the score and eligibility status are stored on-chain.

3. Lenders verify instantly Any lender or DeFi protocol can call a single smart contract function — verifyCredit(wallet) — and instantly receive the user's score, grade, and eligibility. No paperwork, no intermediaries, no personal data exposed. On top of this, NeuroCredit gamifies the entire experience. Users earn XP based on their score, level up through ten financial tiers (from Rookie Saver to Crypto King), unlock achievement badges for good habits, and track streaks for consistent payments. A visual risk avatar evolves alongside their financial health — turning credit improvement from a chore into a goal worth chasing. The result is a financial identity that anyone can build, own, and carry — regardless of where they live or which institutions they have access to. Model performance: $$\text{MAE} = 13.2 \text{ points}, \quad R^2 = 0.84$$

How we built it

We built NeuroCredit as three distinct technical layers that work together — an ML model, a smart contract, and a frontend — orchestrated by a FastAPI backend.

1)ML Layer — XGBoost Scoring Engine We started by designing a synthetic dataset of 5,000 profiles that mirrors the financial behavior of informal economy workers globally — varying UPI transaction patterns, bill payment histories, income sources, and savings rates. We trained a Gradient Boosting Regressor (scikit-learn) on this data, with 300 estimators, regularization, and an 80/20 train-test split. The model achieves an MAE under 20 points and R² above 0.95. Feature importance analysis confirmed that payment consistency and transaction regularity are the strongest predictors — which aligns with real-world credit intuition. The trained model and scaler are serialized with joblib and served via a scoring module.

2)Backend — FastAPI We built a REST API in FastAPI that acts as the central orchestrator. It exposes two core endpoints: POST /api/score, which validates the 14 input signals using Pydantic, runs them through the ML model, and returns a full score breakdown; and POST /api/verify, a lender-facing endpoint that returns only score and eligibility for a given wallet — no personal data. The backend is designed to be stateless and production-ready, with a clean separation between the ML layer and the blockchain layer.

3)Smart Contract — Solidity + ERC-5484 We wrote NeuroCredit.sol in Solidity 0.8.20, implementing the ERC-5484 Soul Bound Token standard. The contract enforces one SBT per wallet, restricts minting and score updates to an authorized issuer, and permanently locks transfer functions with a custom error. The verifyCredit(wallet) function is fully public — any lender can call it. We deployed and tested on Polygon Amoy testnet.

4)Frontend — Vanilla JS + Gamification Engine We deliberately avoided heavy frameworks to keep load times minimal. The UI is built in plain HTML, CSS, and JavaScript, with a custom gamification engine we wrote from scratch. This includes a 10-tier XP and leveling system, 9 dynamically unlocked achievement badges evaluated against the user's actual input data, a streak system based on payment consistency, and a risk avatar that evolves with the score. The result page opens as a standalone experience in a new tab, with cinematic loading, animated score counters, confetti bursts, and a 3D floating card with mouse parallax. Every animation is CSS-native — no animation libraries.

How it all connects The user fills in their financial signals on the frontend → the FastAPI backend validates and scores them via the ML model → the result is passed to the frontend via sessionStorage and rendered on the result page → the user can then trigger an SBT mint on Polygon. If the backend is unavailable, the frontend falls back to a local JavaScript scoring function that mirrors the Python logic exactly, so the demo always works.

Challenges we ran into

1)Designing meaningful alternative signals The hardest early decision was choosing which 14 signals to use and how to weight them. We didn't want features that correlated too strongly with income — that would just recreate the same bias traditional credit scoring already has. We spent significant time researching which behavioral signals genuinely predict financial responsibility across different economic contexts, and iterating on the synthetic data generation to make sure the score distribution was realistic — not clustered at the extremes — and that the model rewarded habits over wealth.

2)Making the ML model fair by design Training on synthetic data meant we had full control over the distribution — but that's also a trap. It's easy to accidentally bake in assumptions that favor certain profiles. We had to be deliberate about ensuring the model didn't implicitly penalize gig workers or people with variable incomes simply because their patterns looked "irregular." Balancing income volatility as a signal without making it a proxy for employment type required multiple rounds of feature engineering and importance analysis.

3)ERC-5484 implementation — getting Soul Bound right The ERC-5484 standard is newer and less documented than ERC-721. Implementing the transfer lock correctly — ensuring transferFrom, safeTransferFrom, and approval functions all revert with the right custom errors — while still keeping the contract upgradeable for score updates was a careful balancing act. We also had to handle the one-SBT-per-wallet constraint cleanly, so re-scoring a wallet updates the existing token rather than minting a duplicate.

Accomplishments that we're proud of

1)A model that rewards behavior, not wealth We're proud that the ML model genuinely does what we set out to do — score financial responsibility independently of income level. A gig worker with variable earnings but consistent bill payments scores higher than a high-income individual with erratic habits. That was the entire point, and seeing it hold up across the synthetic dataset felt like a real validation of the approach.

2)A fully working end-to-end system in hackathon time Three distinct technical layers — a trained ML model, a deployed smart contract, and a gamified frontend — all talking to each other, all working, all demoable. Most projects at a hackathon nail one layer. We're proud we built all three and connected them cleanly, with a FastAPI backend that makes the handoff between ML and blockchain feel seamless.

3)Soul Bound Token that actually behaves correctly Getting ERC-5484 right — one token per wallet, transfer permanently locked, score updatable by issuer only, public lender verification — is something we're genuinely proud of. It's not a toy NFT. It behaves exactly the way a real-world credit credential should: owned by the user, readable by anyone, manipulable by no one.

What we learned

Alternative data is powerful — but requires intentional design We came in assuming the hard part would be the ML model. It wasn't. The hard part was deciding what to measure and why. Building a scoring system on alternative data forces you to confront questions traditional credit bureaus quietly sidestep — whose definition of "responsible" are we encoding? Are we measuring financial health or just financial conformity? Working through those questions made us much more thoughtful about what fairness in a model actually means in practice, not just in theory.

Blockchain is most useful when it's invisible We learned that the best use of a smart contract isn't to put everything on-chain — it's to put exactly the right thing on-chain. The breakthrough moment in our design was realizing that lenders don't need your data. They need your score and a guarantee it hasn't been tampered with. Once we accepted that, the contract got simpler, the privacy model got stronger, and the user experience got better. The blockchain isn't the product. The trust it creates is. Keeping two implementations in sync is a real engineering discipline

Maintaining the JavaScript fallback alongside the Python scoring logic taught us something we hadn't fully appreciated before — parallel implementations of the same logic in different languages are a form of technical debt from day one. Any change to the formula has to propagate to both. We learned to treat them as a matched pair with a shared test contract, not two independent functions that happen to do the same thing.

What's next for NeuroGuard AI

Short Term Improve document parsing accuracy Add support for multiple policy types (health, auto, life) Enhance AI explanations with real-world claim scenarios

Mid Term Partner with insurance providers Integrate real-time claim prediction models Launch mobile app for wider reach

Long Term Build a universal insurance intelligence layer Enable users to compare policies across providers Expand globally

Built With

• css
• fastapi
• git
• hardhat
• html
• javascript
• numpy
• pandas
• polygon-(amoy)
• pydantic
• python
• scikit-learn
• solidity