Everyone starts somewhere. For me, it was a laptop in Beldanga, Murshidabad, during the 2020 lockdown — self-teaching C from a YouTube playlist with no mentor, no coding community nearby, and nowhere else to be. I had no idea that a few years later, I'd be at IIT Patna building custom language models, integrating three different AI APIs into a single system, and shipping open-source tools tested by real CS students.
This is the honest story of how that happened — the wins, the late nights, the failed projects, and the mindset shifts that made all the difference.
IIT Year One: Formalising the Foundation
I arrived at IIT Patna in 2025 already knowing how to write code. Five years of self-teaching since 2020, two years of Diploma in Engineering in Kolkata, a deployed full-stack application — that was the baseline. What IIT did was formalise it. Suddenly the things I'd been doing by instinct had names, proofs, and complexity bounds.
The first-semester curriculum hit hard in a different way than I expected. Not because the concepts were new — I knew what a linked list was — but because the rigour was. I remember spending four hours debugging a linked list reversal in an assignment and realising the off-by-one error only after writing out the pointer state on paper. That kind of systematic thinking was the real upgrade IIT delivered.
"The best way to learn to code is to build something you actually want to exist." That realisation started in 2020. IIT gave it structure, vocabulary, and peers who pushed it further.
By the end of the first semester I had a stronger grasp of algorithms, data structures, and systems theory than four years of self-study had given me. More importantly, I had classmates who were as obsessed with building as I was.
Diploma Years: Going Full-Stack
Before IIT, during my Diploma in Engineering in Kolkata (2023–2025), is where I went from writing scripts to building real applications. I picked up JavaScript almost by accident — I wanted to build a simple web dashboard for tracking my study hours, and vanilla JS was the fastest path. Within a month I was deep into Node.js, Express, and React.
The Pathology Admin Panel
My first serious project came from an unexpected place. A relative who ran a pathology lab mentioned how painful it was to manage patient records, billing, and test reports using a patchwork of spreadsheets and paper forms. I offered to build something better.
What followed was three months of weekend work during the Diploma — designing a MySQL schema from scratch, building a REST API with Express, creating a React frontend with chart-based analytics, and handling edge cases I hadn't anticipated (like what happens when a test has multiple billing codes, or when a report needs to be regenerated without overwriting the original).
The panel went live and the lab still uses it today. That feeling — watching a non-technical person navigate something I built, with zero confusion — was more motivating than any grade.
The AI Turn
Toward the end of my Diploma years, I started noticing a pattern in my study group: everyone was struggling with the same core CS subjects — OS concepts, DBMS theory, algorithm complexity — and the existing resources either dumbed things down too much or assumed too much background knowledge.
Around the same time, the LLM explosion was happening. GPT-4 came out. Open-source models like LLaMA were being released. I started wondering: what if a language model was trained specifically on these CS topics?
Building Blix.ai
That question became Blix.ai — a privacy-first, self-hosted AI tutor for computer science students, currently running in closed beta. The goal was simple in concept but hard in execution: a model that could answer both theoretical questions ("explain the difference between process and thread") and practical coding questions ("why does this semaphore implementation deadlock?") with the depth of a senior TA.
Blix.ai is running in closed beta, free for all testers, and aligned with UN SDG4: Quality Education for All. The code is open-source. If it helps even a few students pass their operating systems exam, it was worth every debugging session.
Hackathons: Shipping Under Pressure
Nothing teaches you to build fast like a hackathon. I've competed in five national-level AI hackathons so far, reached the finals in two, and learned something important from each one — including the ones where we didn't place.
The biggest lesson: your first idea is almost never your best idea. The teams that win usually pivot hard somewhere in hour four or five, after they've built something and realised what the actual interesting problem is.
Competing with a team also taught me things about collaboration that solo projects can't. When you're tired at 2am and someone else's code breaks your integration, you learn a lot about communication and version control very quickly.
The AI Integration Hub
After working extensively with OpenAI's API for Blix.ai, I noticed a recurring pain point: every project that wanted to use AI had to re-implement the same boilerplate — authentication, rate limiting, error handling, response parsing, model selection logic. And if you wanted to switch providers or route to different models based on the task, you were essentially rewriting your integration layer from scratch.
So I built the AI Integration Hub — a single API layer that sits in front of OpenAI, Anthropic, and Google Gemini. You send one request, specify a task type, and the hub routes to the best model, handles retries, caches where appropriate, and returns a normalised response regardless of which provider served it.
// Before: vendor-specific boilerplate
const response = await openai.chat.completions.create({
model: "gpt-4o",
messages: [{ role: "user", content: prompt }]
});
// After: one interface, any provider
const response = await hub.complete({
task: "code_review",
prompt,
// hub picks the best model automatically
});The Hub now supports three providers, handles ~200 requests/day in testing, and has saved me personally from vendor lock-in twice. It's the kind of infrastructure that doesn't seem glamorous until you've had to rewrite it.
What I'd Tell My 2020 Self
Looking back across three-plus years of active building and ten-plus projects, a few things stand out as genuinely important:
- Build things that annoy you. The best projects solve a problem you personally experience. The motivation stays high because you're your own most demanding user.
- Ship early, even if it's embarrassing. Every project I'm most proud of started as something I was almost too embarrassed to show anyone. User feedback in the first week is worth a month of solo iteration.
- Learn the fundamentals deeply. Understanding why a database index speeds up a query, or how an attention mechanism actually computes similarity — this knowledge compounds. Abstractions leak eventually.
- Competition is a forcing function. Hackathons, competitive programming, open-source contributions with deadlines — external pressure produces focus that pure curiosity rarely does.
- The community matters more than the credential. The most valuable things I've learned came from conversations with seniors, lab partners debugging at midnight, and professors who pushed back on lazy assumptions.
Final Thoughts
The journey from a curious kid in Beldanga teaching himself C during a lockdown to building AI-powered products at IIT Patna hasn't been linear. There have been months where nothing shipped, projects that got abandoned halfway, and ideas that seemed brilliant at 1am and terrible by morning.
But the compounding effect of consistent building is real. Every project teaches you something the next one needs. Every failure rules out a direction that would have wasted more time later. And every tool that someone actually uses — however small — is a reminder of why this is worth doing.
If you're early in your own journey and this resonated, I hope it's useful. If you want to talk about anything covered here — Blix.ai, the AI Hub, hackathon strategy, or just what it's like studying CS at IIT Patna — reach out. I'm always happy to chat.