CampusFlow AI

Smarter campus. Smoother days.

Comment

Inspiration

It was the third time in a week. A lecturer stood in front of fifty students. The attendance sheet said sixty-two. He looked up, counted again, and realized something quietly devastating: twelve students were "present" who weren't even in the country. Their friends had signed for them. A photo of the sign-in sheet was passing around a WhatsApp group. One student was at a wedding. One was at his grandmother's funeral. One had quit school three weeks ago but his name was still being signed every Monday morning. The lecturer didn't get angry. He just got tired. Because he knew the same way every teacher in every school in every country knows that the system wasn't built for the world we actually live in. A world where every student has a phone. A world where every paper trail can be photographed. A world where every shortcut has already been discovered, optimized, and shared. We looked at every existing school platform and asked one question: "If a student wanted to break this in under five minutes, could they?" The answer was always yes. CampusFlow AI is our answer to that question. We didn't set out to build a school app. We set out to build a system that couldn't be cheated by the very generation it was made for and to give lecturers, students, and administrators back the thing they've been quietly losing for years: trust in their own data.

What it does

CampusFlow AI is a complete campus operating system built for phones, designed for trust, structured for scale. It replaces attendance sheets, document submissions, departmental management, and administrative oversight with a single connected platform that runs an entire institution from one screen. Attendance that cannot be faked. Every attendance session runs on a QR code that rotates every five seconds. A student in the room scans it. A student on a bus, in a bed, in another city gets a screenshot that expired before the message even sent. We didn't make cheating harder. We made it physically impossible at distance. Documents that cannot be lost. Super admins define exactly which documents students must submit. Students see a living checklist of what they owe, what's pending, and what's been approved. Admins review with one click, reject with a reason, and every action lives in a permanent trail. No more chasing the bursar. No more "I submitted it last week, I promise." Departments that cannot collide. Every department runs as its own private universe, its own admin, its own lecturers, its own students, its own invite codes, its own data. Computer Science can't see Medicine. Medicine can't see Law. But the super admin sees all of them from a single command center, with the clarity of a control tower. Role-based dashboards for every user. Students scan in, submit documents, and track their status from their phones. Lecturers run live attendance and never chase paper again. Department admins manage their unit independently. Super admins see the entire campus in real time.

How we built it

We built CampusFlow AI mobile-first, because the real users (students and lecturers) live on phones, not laptops. The foundation is a properly normalized relational data model where every record every user, document, attendance session, invite code, and rotating token is scoped by department through foreign-key relationships. This makes multi-tenancy not a feature bolted on, but a property of the architecture itself. For attendance, we implemented a rotating-token system. Each active session has a persistent record, but inside it lives a short-lived token that regenerates every five seconds. The QR code on the lecturer's screen re-renders against the current token, and the server validates incoming check-ins against the live token window (with a small grace period for honest network lag). Even a screenshot taken seconds ago becomes useless before it can be shared. The document pipeline is built around an admin-defined DocumentType table students cannot upload arbitrary files; they pick from a checklist of required types, each with allowed formats, size limits, and department scoping. Every submission writes to file storage and a metadata record, and a strict review workflow ensures Super Admins see the actual file before approving or rejecting with a reason. Authentication is handled end-to-end: secure invite-code flows, role-based redirects after login, single-use password reset tokens, and session persistence that survives navigation, refreshes, and closed tabs. The UI is built on a unified design system. a single navy primary, a vivid accent, consistent spacing tokens, and components that reflow gracefully from a 320-pixel phone to a 1920-pixel monitor.

Challenges we ran into

Every challenge taught us something. And every fix made the platform harder to break.

The invite code that broke itself. Our first signup flow had a cooldown that fired when users were redeeming a valid invite not just requesting one. Users were getting locked out of completing their own signups. We had to redesign the flow so the cooldown only applied to requesting codes, not consuming them.

The QR that vanished on tab switch. Our first attendance feature held the session in page memory. The second a lecturer navigated away the session was gone. We rebuilt it so every session is a persistent database record, resumable from any device, any time, until it's manually ended or expires.

The "approved" document nobody had actually seen. Super Admins were clicking approve on documents they couldn't view. The file was uploaded but never rendered. We had to rebuild the entire review pipeline to surface real previews PDFs inline, images inline, structured fallbacks for everything else.

The password reset that didn't actually reset. Our most serious bug. Users would reset their password, see a success message, and find the old password still worked. We traced it to a workflow that wasn't writing to the real user record a fix that required rebuilding the auth chain end-to-end, with database-level verification that the hash actually changed.

The database that defended itself. A check constraint blocked us from ending attendance sessions because the workflow was writing a status value the database wasn't expecting. It was, in retrospect, the database doing its job correctly, we just had to teach the rest of the app to speak the same language.

Department isolation, without leaks. Building true multi-tenancy meant auditing every single query in the system. One missed filter and a Department Admin could see another department's data. We had to treat permission boundaries as physics not policy. Each of these bugs forced us to confront the same truth: shortcuts in architecture become exploits in production. So we stopped taking shortcuts.

Accomplishments that we're proud of

We built a campus platform where cheating attendance isn't just discouraged. it's architecturally impossible at distance. That alone changes what attendance data means in a school. We built a document workflow where "submitted" means seen, judged, and resolved not forwarded into a black hole. Students finally know the status of their own paperwork. We built true multi-department isolation. Each department operates as its own world, while the super admin sees all of them. No leaks. No exceptions. We built an auth system that withstood multiple rounds of hostile failure invite codes, password resets, session persistence, role-based redirects and made it boring in the best possible way. It just works. We built it all to be mobile-first, because we refused to ship a product that punished the very people who'd use it most. And we did it as a single connected system, where one accent color, one type scale, and one design language carries from the login screen to the super admin dashboard. We're proud that none of these features feel like demos. They feel like infrastructure, the kind a school could quietly run on for years.

What we learned

Most school software digitizes bad processes. The hard work is redesigning them. Putting a sign-in sheet on a phone doesn't solve cheating, it accelerates it. Real solutions live in the architecture, not the interface. Every "small" bug is a symptom of a structural decision. The vanishing QR was about persistence. The unviewable document was about storage flow. The unreset password was about auth identity. Every fix we shipped taught us to stop treating bugs as accidents and start treating them as signals. Permissions are physics, not policy. If a Department Admin can technically see another department's data they eventually will. The only safe permission boundary is one the system can't violate, not one we politely ask it not to. Generic error messages are a form of dishonesty. "Something went wrong" is the enemy of progress. We learned to surface real errors so we could fix real problems. Mobile-first isn't a slogan, it's a discipline. Every feature was harder to design for a 375-pixel screen first, but every feature became simpler because of it. Trust is the actual product. Everything else the QR codes, the documents, the dashboards is just the delivery mechanism. What schools really need is a system whose data they can believe in. That's what we built.

What's next for CampusFlow AI

The foundation is done. The intelligence is next. Attendance pattern detection. Identifying the student whose attendance is quietly collapsing three weeks before the breakdown, not three weeks after. Document compliance forecasting. Telling admins which students are on track for deadlines, which aren't, and which need a nudge before anyone fails. Natural-language campus queries. Letting admins ask, "How many CS students still owe their fee receipts?" and getting an answer in plain English instead of clicking through five menus. Automated weekly intelligence reports. Turning seven days of activity into one paragraph an administrator can read with their morning coffee surfacing what mattered without making them dig for it. Bluetooth and geofencing. Adding a second physical-presence layer for institutions that want defense-in-depth against even more sophisticated cheating attempts. Open API for campus integrations. Letting CampusFlow AI connect to existing LMS systems, payment processors, and student information systems so it amplifies what schools already use instead of replacing it. Multi-institution federation. Letting universities run multiple campuses, satellite locations, and even partner schools through one unified platform — with the same department-level isolation guarantees we already enforce. The destination is a campus that runs itself quietly in the background — so the humans inside it can focus on the one thing they actually came for: teaching and learning.

Built With

Share this project:

Updates

Submission history