Why I Sunset Campus Blink — and Open-Sourced It Instead of Letting It Die Quietly

I called it. Here's the full story of why, and why the ending of Campus Blink isn't really an ending at all.

It started as UNIVERSE — and it wasn't supposed to work the first time

Before there was a Campus Blink, there was UNIVERSE.

UNIVERSE was my first attempt at the same idea: a hyper-local platform for my own campus at MAIT. I had the vision early, but I didn't have the engineering maturity to pull it off yet. I was still learning how to architect something that could survive real users, real edge cases, real failure modes — not just run on my laptop and look good in a demo.

So UNIVERSE never launched on campus. It stayed exactly what it was: a first draft. The code still lives on my GitHub, not as a failure I'm hiding, but as a checkpoint — proof of where I started and how far the gap was between "I can build this" and "I can ship this."

That gap is the whole point of this story.

Then Campus Blink shipped — and it actually worked

Months later, with more reps under my belt, I rebuilt the idea from scratch as Campus Blink — a MERN-stack marketplace built specifically for MAIT's campus economy:

• Peer-to-peer trading between students
• Canteen pre-ordering, so students could skip the lunch-rush line
• Stationery delivery, on-demand, across campus

This time it wasn't a demo. It was live, in production, in the hands of real students and real canteen vendors — and the adoption wasn't theoretical. Students started using it within weeks. Vendors started taking orders through it. For a solo-built campus project, that's the outcome you're chasing: people choosing to use the thing because it's genuinely useful, not because you asked them to.

For a while, Campus Blink was everything UNIVERSE was supposed to be.

The wall I didn't see coming — and couldn't code my way through

Here's what nobody tells you about building for the real world: sometimes your product's biggest threat isn't a bug, a competitor, or a slow user — it's hardware that doesn't exist yet on the other side of the transaction.

Canteen vendors had no POS system. None. They were running every single Campus Blink order off personal phones — manually checking notifications, manually marking orders complete, manually keeping up during the lunch rush while a line of hungry students formed in front of them. It worked when order volume was low. It started breaking the moment the platform did what it was supposed to do: get more people using it.

I went to the college to ask for proper POS equipment. The answer was no — no budget, no timeline, no path forward.

I could keep shipping features for a product whose foundation was a vendor's personal phone running out of battery during peak lunch hour, or I could be honest about what was actually broken.

This is the part of building something real that doesn't make it into most "founder journey" posts: sometimes the most disciplined move isn't pushing through — it's recognizing that you're optimizing the wrong layer of the stack entirely. No amount of clean code, clever caching, or UI polish fixes a hardware problem that the people you depend on can't afford to solve.

Why I chose to sunset it instead of limping it forward

I had options. I could've built workarounds — a lighter app, manual fallback flows, SMS-based order confirmations, anything to paper over the gap. But every workaround I sketched out had the same flaw: it was treating a structural problem like a UX problem. I would've been spending my time and the vendors' patience defending a broken foundation instead of building on a solid one.

So I made the call to sunset Campus Blink — not quietly, not by letting it rot in an unmaintained repo while pretending it was "on pause," but as a deliberate decision with a deliberate next step.

Why I open-sourced it instead of letting it die quietly

Killing a product you built alone, that real people used, that actually worked — that's not a fun decision. But letting it disappear into a private repo felt like an even worse one. Campus Blink had already proven something valuable: the architecture, the order-flow logic, the marketplace mechanics — all of it worked, in production, under real load, with real users. Burying that didn't serve anyone.

So I open-sourced the entire codebase on GitHub. Not a stripped-down version. Not a sanitized "look how good my code is" highlight reel. The whole thing — architecture, decisions, the working and the unfinished parts — available for any other student-builder who's staring at the same kind of campus problem I was.

Here's what that decision was really about:

• A discontinued product can still be a usable foundation. Someone at another campus with a vendor base that does have POS access could fork this and actually launch it.
• Failure that's hidden teaches nothing. Failure that's documented teaches everything. The most useful part of Campus Blink's story isn't the win — it's the constraint that ended it, and the reasoning behind walking away.
• Open code is a stronger signal than a polished case study. Anyone can write "I built a marketplace." Fewer people can point to the actual commits, the actual architecture, and the actual decision log behind why it stopped.

UNIVERSE taught me how to build. Campus Blink taught me when not to keep building. Both lessons mattered more than a permanently live app would have.

What I took with me

Campus Blink is gone from MAIT's campus, but nothing about it was wasted. The product instincts — building fast, listening to real usage instead of assumptions, and knowing the difference between a fixable bug and an unfixable constraint — are the same instincts I now bring into every build at Bivoxo, the AI-native development agency I run today. The difference is that now I'm applying that judgment for clients from day one, instead of learning it in public on a campus project.

If you're building something right now and wondering whether to keep pushing through a wall that isn't yours to fix — that's usually the moment to ask the harder question, not just push harder.

The UNIVERSE and Campus Blink codebases are both public on my GitHub. Go build the version that gets to stay live.