Tamper-proof credentials, anchored on-chain.
- Project CertChain
- Year 2026
- Role Lead Developer
- Stack Solidity, React, ethers.js, Polygon
Background
Paper certificates and PDF transcripts are easy to forge and impossible to verify at scale. Institutions issue thousands of credentials a year; employers and admissions offices have no fast way to confirm any of them are real.
CertChain anchors every certificate to a public blockchain. Issuers sign a hash of the credential on-chain through MetaMask; anyone can verify authenticity and revocation status by querying the smart contract directly — no central server, no trust required.
Challenge
Build a working blockchain credentials system without locking users into expensive gas fees or a clunky Web3 UX. The chain has to enforce trust; everything else — issuing, browsing, verifying — should feel like a regular SaaS app.
The hard part: keep the on-chain footprint tiny (just a hash and a status flag), store rich metadata off-chain without compromising the trust model, and surface live blockchain events in the UI without polling.
How it works.
Issue on-chain
Admin fills in recipient, course, and issuer. The app hashes the credential client-side, the issuer signs the hash with MetaMask, and the smart contract records it on Polygon Amoy. Metadata is then stored server-side, keyed by the on-chain hash.
Verify instantly
Anyone can paste a certificate hash into the verifier page. The app reads directly from the smart contract — issuer address, status, timestamp — without needing the original issuer to be online.
Revoke when needed
If a credential is compromised or issued in error, the original issuer can revoke it in one signed transaction. Verification immediately reflects the new status across every consumer.
Live event log
A WebSocket subscription to the contract streams every IssueCertificate and RevokeCertificate event into the dashboard in real time. No refresh, no polling — the UI just updates as the chain does.
Under the hood.
| Smart Contract | Solidity on Polygon Amoy testnet |
| Frontend | React + Vite |
| Web3 | ethers.js + MetaMask provider |
| Real-time | WebSocket RPC for contract events |
| Visualization | D3.js force-directed graph |
| Backend | Node.js + Express (metadata store) |
| Hosting | Vercel |
Architecture
Features.
What I built.
CertStore smart contract
A minimal Solidity contract that stores certificate hashes mapped to issuer address, status, and timestamp. Emits IssueCertificate and RevokeCertificate events for off-chain consumers. Gas-optimized to keep issuance affordable on testnet and mainnet alike.
Real-time admin dashboard
Stats cards, recent issuances table, and a live event log streamed straight from the chain via WebSocket. Block height ticks up in the sidebar so you can see the network is alive.
Network topology visualization
A D3 force-directed graph centered on the contract, with issuer wallets as middle nodes and individual certificates as outer nodes. Revoked certs render red — fraud and patterns become visually obvious.
Trustless verifier
The verifier page talks only to the smart contract — no auth, no server dependency. Paste a hash, get the on-chain truth. Works even if my backend is down.
Challenges.
Keeping on-chain data minimal
Storing names, courses, and dates on-chain is expensive and leaks PII. I keep only the hash on-chain and store metadata in a server-side DB keyed by that hash — the chain proves authenticity, the DB serves rich data.
Web3 UX without alienating users
Most people have never touched MetaMask. The UI explicitly states when a wallet is needed, what network to switch to, and what the next signed transaction will do. Errors get translated into plain English.
Reliable event subscriptions
RPC providers drop WebSocket connections constantly. I added auto-reconnect with backfill — on reconnect, the client queries past events from the last seen block so the live log never misses an issuance.
What's next
Mainnet deployment with a custom issuer registry. Batch issuance via Merkle roots so a university can issue thousands of certificates in one transaction. PDF certificates with embedded QR codes that link straight to the verifier. ENS-based issuer identity.