Beyond the Pitch: Our SkillUp Hackathon 2026 Regional Finale Journey with CampusPulse AI

September 24, 2026 • 9 min read

Hook: Standing before the jury at the Regional Finale of the SkillUp Hackathon 2026 (organized in collaboration with IBM SkillsBuild), our demo screen lit up with real-time incident correlation telemetry. Every test passed, the dual-persona role switcher pivoted seamlessly, and our 4-factor math grouped raw grievances into actionable incident tickets in under 350ms. Yet, when the final results were announced, our name was not called for the National Finale. Here is the raw, honest post-mortem of our presentation, what we learned from falling short, and why I couldn't be prouder of the 4-member engineering team (Team Point Break) that built CampusPulse AI.

1. The Road to the Regional Finale

When we first submitted CampusPulse AI to the SkillUp Hackathon 2026, our mission was clear: campus infrastructure maintenance is fundamentally broken by communication fragmentation. Broken Wi-Fi routers in computer labs, leaking AC compressors in libraries, and water main disruptions are rarely reported with precise telemetry. Instead, administration desks are flooded with duplicate, emotional complaints across WhatsApp, email threads, and student union representations.

Over two intense phases—documented in Part 1: Foundation & Admin Intelligence and Part 2: Student Portal & Verification—our team engineered a high-density, explainable real-time incident intelligence platform:

• Express + SQLite 3 (WAL mode) persistence with zero external database dependencies.
• Dual-Tier AI Pipeline leveraging Google Gemini 2.5 Flash with 3,072-dimensional embeddings and offline mock resilience.
• 4-Factor Deterministic Correlation Engine combining semantic cosine similarity (55%), spatial proximity (20%), categorical affinity (15%), and temporal decay (10%).
• Dynamic Vector Centroid Clustering (centroidCalculator.ts) that recalculates multi-report cluster centers in real time.
• Emerging Velocity Surge Detection flagging rapid incident spikes with a +15 priority boost.
• A 58/58 automated test suite covering mathematical formulas, unit invariants, and REST integration.

When the notification arrived that CampusPulse AI was shortlisted as a Regional Finalist, it was an exhilarating validation of our architectural decisions.

2. The Regional Finalist Certificate

We are honored to have received our official SkillUp Hackathon 2026 Regional Finalist Certificate awarded in collaboration with IBM SkillsBuild:

Team Point Break • Certificate of Excellence

SkillUp Hackathon 2026 (in collaboration with IBM SkillsBuild)

Full Resolution

Official Regional Finalist Certificate awarded to Team Point Break at the SkillUp Hackathon 2026.

3. Presentation Day: Pitching on September 24, 2026

On September 24, 2026, our team arrived for the Regional Finale presentation. The format was demanding: a strict time-boxed pitch consisting of a live functional demonstration followed by an intensive jury Q&A.

The Demo Flow:

1. The Student Intake: Sreeshanth's mobile-first student portal was launched. We simulated a student submitting an urgent complaint: "The Wi-Fi access point in CSE Block Lab 3 has completely dropped offline during our practical exam."
2. Deterministic Clustering in Real Time: The backend parsed the complaint via strict JSON schema extraction, generated vector embeddings, and evaluated correlation against existing campus tickets. The system scored an 84.6% match against an open "CSE Block Switch Port Disruption" incident, dynamically updating the cluster's vector centroid.
3. Emerging Red Alert Surge: We triggered two additional reports from adjacent rooms within 15 minutes. The arrival velocity triggered our EmergingDetector, elevating the incident to CRITICAL with a live glowing red alert banner broadcasted across the Admin Command Center.
4. Audit-Ready Explainability: We showcased the generated natural language explainability report—proving that our clustering was mathematically grounded and auditable rather than a black-box LLM hallucination.

The technical presentation was smooth, responsive, and completely stable. Our local mock fallback and SQLite WAL configuration ensured zero API timeouts or latency hiccups on stage.

4. The Jury Room: Where Code Meets Operational Reality

While the jury appreciated the technical sophistication of our architecture, the Q&A pushed past our algorithms and straight into enterprise operational reality:

"Your correlation mathematics and vector centroid calculations are impressive. But how does this survive when 50 students spam malicious or troll reports during a campus festival? And how does your incident output bridge into legacy campus facilities ERP software like SAP or IBM Maximo?"

This question captured the core tension of any applied AI product:

1. Spammed & Adversarial Telemetry

Our engine had rate-limiting and duplicate clustering, but we had not implemented student reputation weighting or device-fingerprinted sybil resistance. If multiple bad actors intentionally report contradictory information, the centroid calculation could be skewed without human-in-the-loop validation thresholds.

2. Physical Campus Topologies vs. Spatial Distance

Our spatial score relied on Euclidean and building coordinate proximity. In real campus estates, adjacent buildings on a map might belong to entirely separate electrical grids or plumbing lines. Modeling infrastructure networks requires topological graphs, not just geographic coordinates.

3. Change Management & Administrative Buy-in

We designed a modern, Linear-inspired Admin Dashboard with dark mode and Cmd+K command palettes. However, university facilities staff often operate legacy desktop dispatch consoles and specialized ticketing systems. Bridging into existing institutional workflows requires enterprise middleware connectors, not just a standalone dashboard.

5. The Verdict: Falling Short of the National Finale

When the results were announced at the conclusion of the Regional Finale, CampusPulse AI did not make the cut for the National Finale.

I would be lying if I said there was no initial sting. When you invest sleepless nights, resolve 10-file merge conflicts, author comprehensive unit math tests, and deliver a live demo that functions without a single error, you naturally dream of taking the project all the way to the national stage.

However, once the adrenaline settled, the clarity was undeniable: the judges made the right call. The teams that advanced presented not just working software, but deeply validated commercial distribution strategies, institutional pilot agreements, and comprehensive answers to operational edge cases.

Building a world-class prototype is only 50% of the journey. The remaining 50% is understanding customer workflows, institutional inertia, and edge-case security.

6. What This Hackathon Taught Us

Reflecting on the SkillUp Hackathon 2026, four profound engineering lessons will stay with us forever:

                  ┌─────────────────────────────────────┐
                  │      SkillUp Hackathon Journey      │
                  └──────────────────┬──────────────────┘
                                     │
         ┌───────────────────────────┴───────────────────────────┐
         ▼                                                       ▼
┌─────────────────────────────────┐             ┌─────────────────────────────────┐
│       Technical Mastery         │             │       Product & Business        │
├─────────────────────────────────┤             ├─────────────────────────────────┤
│ • 58/58 Verified Unit & API     │             │ • Enterprise ERP Integration    │
│ • Deterministic 4-Factor Math   │             │ • Adversarial Sybil Resistance  │
│ • Zero-Crash Offline Resilience │             │ • Institutional Change Adoption │
│ • Multi-Report Centroid Vectors │             │ • Real Estate Topology Graphs   │
└─────────────────────────────────┘             └─────────────────────────────────┘

1. Deterministic Grounding is King in Enterprise AI: Our decision to use Gemini for language extraction while keeping correlation scoring in transparent, deterministic math was universally praised. Enterprise stakeholders want audit trails, not stochastic guesses.
2. Resilience Saves Live Demos: Having our MockAIService offline layer meant our presentation was bulletproof against convention hall Wi-Fi instability. Never rely on external cloud APIs without a deterministic local mock during live pitches.
3. Product Framing Matters as Much as Architecture: As software engineers, our instinct is to talk about vector embeddings, Write-Ahead Logging, and latency. But in product competitions, what wins hearts is the answer to: "How does this make a facilities director's life 10x easier on Monday morning?"
4. Testing Under Pressure Builds Unbreakable Bonds: The discipline required to merge parallel branches, maintain strict API contracts, and hit a 58/58 test pass rate under strict hackathon deadlines forged us into a vastly stronger engineering unit.

7. A Heartfelt Thank You to My Teammates (Team Point Break)

None of this would have been possible without the dedication, brilliance, and relentless commitment of my teammates. Entering a hackathon of this scale requires trust, egoless code reviews, and mutual respect.

Special Gratitude to Team Point Break:

• Sreeshanth S (Student Frontend Lead): For designing and shipping a beautiful, mobile-first reporting interface from scratch. Your category presets, auto-suggest inputs, and instant receipt modals gave our project a polished, user-friendly face that the judges loved.

• Vignesh Mandadapu (Admin Frontend Lead): For architecting the high-density Admin Command Center. The telemetry KPI bar, multi-factor triage filters, and incident event timeline drawers transformed raw database rows into an executive-level command dashboard.

• Sumanth Teju (Integration & Demo Lead): For tirelessly bridging client-server endpoints, authoring our canonical 6-incident demonstration dataset, and making sure our live database seeders ran flawlessly every single time on presentation day.

• Vaibhav Bharathula (Backend & Architecture Lead): It was an absolute privilege to lead the architecture, design the Express + SQLite WAL core, engineer the 4-factor deterministic correlation engine and centroid calculator, and write the 58/58 automated test suite.

8. What's Next for CampusPulse AI

The hackathon competition may have ended at the Regional stage, but CampusPulse AI is far from finished:

1. Open Source & Code Transparency: The complete codebase, test suite, and seed scripts remain 100% open-source on GitHub.
2. Graph Topology Integration: We plan to explore graph database models (such as building connectivity matrices) to represent physical campus utilities alongside geographical distance.
3. Enterprise Webhook Dispatch: Adding outbound webhook connectors so that correlated incidents can automatically dispatch into Slack, Discord, or campus facilities ticketing systems.

Reaching the Regional Finale among hundreds of competing teams was a massive milestone. We walk away with deeper technical skills, battle-tested teamwork, and the hunger to build even better systems for our next challenge.

To IBM SkillsBuild, the SkillUp Hackathon organizers, and most of all, to my incredible team—thank you for an unforgettable journey.

Series Links & Navigation

• Read Part 1: Building CampusPulse AI (Part 1): Foundation, Multi-Factor Correlation & Admin Command Center
• Read Part 2: Building CampusPulse AI (Part 2): Student Portal, Dual-Persona Unification & End-to-End Verification
• Interactive Project Case Study: CampusPulse AI Portfolio Showcase
• GitHub Repository: https://github.com/Vaibhav-1819/CampusPulseAI