What happens when a city of 13 million people has no reliable way to separate real emergencies from WhatsApp rumours? We built the answer in 30 hours.

The Team Behind NammaShanti

NammaShanti was built by a 4-member team at the Build for Bengaluru Hackathon, organized by Google Developer Groups (GDG) Bengaluru at REVA University.

This blog reflects my personal experience and contributions as part of the team. All credit for the complete project belongs equally to all four of us.

The Problem That Kept Us Up at Night

Bengaluru is one of India's most dynamic cities — and also one of its most rumor-prone. During communal tensions, protests, or local unrest, panic spreads faster than facts. A single forwarded video on Telegram can trigger mass fear, traffic chaos, and even violence — before anyone in authority has even confirmed whether the event is real.

The Bengaluru Police and BBMP receive hundreds of citizen reports daily. Most are noise. Some are critical. And there's no intelligent system to tell them apart.

That was our problem statement. And NammaShanti was our answer.

The Pivot That Defined the Project

Here's something that doesn't make it into most hackathon write-ups — the original idea was completely different.

We initially planned to build a bot that would automatically scrape messages from WhatsApp, evaluate them using AI, and push verified incidents to an authority dashboard. It was clean, powerful, and elegant in theory.

Then reality hit: WhatsApp requires higher-level business API permissions to access user messages and data. We couldn't clear that in the middle of a 30-hour hackathon.

So we pivoted — fast.

Instead of scraping WhatsApp, we built a Telegram bot where citizens could proactively forward suspicious messages, videos, or article links. The AI evaluation pipeline stayed the same. The authority dashboard stayed the same. We just changed where the reports came from.

And honestly? The Telegram approach turned out to be better — it made citizen participation explicit and consensual, rather than surveillance-based. That pivot taught us something important: constraints don't always kill ideas, sometimes they improve them.

What Is NammaShanti?

NammaShanti — "Our Peace" in Kannada — is a real-time AI-powered civic threat intelligence and rumour triage platform built for Bengaluru Police and BBMP. It ingests citizen reports from Telegram — text messages, video reels, and news article links — runs them through a custom AI engine, computes a Panic Index score, and surfaces verified incidents on a live police commander dashboard.

In simple terms: citizens report, AI triages, police act.

The Architecture

Here's a bird's-eye view of how data flows through the system:

Citizen (Telegram)
       │
       ▼
  NammaShantiBot → engine.py (Panic Index Engine)
       │                    │
       │         ┌──────────┴──────────────┐
       │         │  Static Scan   (30%)    │
       │         │  Velocity Score (40%)   │
       │         │  Gemini AI Score (30%)  │
       │         └─────────────────────────┘
       │
       ▼
  Firebase Firestore → React Dashboard (Live)
       │
       ▼
  Auto-Reply / Mass Broadcast → Citizen's Telegram

The entire pipeline runs with near-zero latency — from a citizen forwarding a message to a police officer seeing it on the dashboard takes seconds.

The Tech Stack

NammaShanti 2.0 was built end-to-end on the Google ecosystem:

The Heart of the System: The Panic Index

The most technically interesting part of NammaShanti is our custom Panic Index Engine — a weighted formula that combines three independent signals to score every incoming report from 1 to 10.

Panic Index = (Static Score × 0.3) + (Velocity Score × 0.4) + (Semantic Score × 0.3)

Clamped to 1–10. Auto-escalates to a minimum of 8 if 3 or more static triggers are detected.

Breaking Down Each Signal

1. Static Score (30%) — Keyword Intelligence

We built a curated list of Bengaluru-specific trigger keywords — neighbourhood names, political terms, Kannada phrases associated with unrest. A message mentioning "bandh + Silk Board + protest" scores higher than one mentioning just "crowd."

2. Velocity Score (40%) — The Crowd Signal

This is the most powerful signal. If 10 different citizens report the same type of incident from the same area within 15 minutes, the velocity score spikes sharply. This mimics how real emergencies actually work — one report might be noise, but ten reports in a short window almost never is.

3. Semantic Score (30%) — Gemini AI

Gemini 2.5 Flash reads the full message (or watches the video, or reads the scraped article) and returns a structured threat assessment including a severity score, whether it's likely fake or real, a summary, and a draft official police response — all in a single API call.

Why Velocity Carries the Highest Weight

We deliberately weighted velocity at 40% because it is the hardest signal to fake. You can engineer a single alarming message, but you cannot easily manufacture 15 independent citizen reports in 15 minutes. Velocity is the closest approximation we have to ground truth.

Multimodal AI: Beyond Just Text

One of our proudest features is handling video reels. When a citizen forwards a video to the bot:

1. The bot downloads the video file

2. Uploads it to Google Cloud via the Gemini File API

3. Gemini 2.5 Flash watches the video — analyzing both the visuals and audio

4. Returns a structured threat assessment

This means NammaShanti can detect mob violence, weapons, or crowd panic from a raw video clip — not just from keywords. That's genuinely powerful and, to our knowledge, rare in civic AI systems at this scale.

Similarly, when a message contains a URL, the backend automatically scrapes the article text and feeds it to Gemini — catching misinformation embedded in "news" links before they go viral.

The Live Commander Dashboard

The police-facing dashboard is a React application powered by Firebase Firestore's real-time listeners. Every new incident pushed to Firestore immediately appears on the dashboard without any page refresh.

Key dashboard features:

• Live Google Maps with incident markers colour-coded by Panic Index (red / yellow / green)

• Heat map overlay showing geographical clusters of incoming reports

• Nearby police unit overlays showing patrol positions relative to the incident

• Status management — authorities can update the status of any incident (acknowledged, deployed, resolved)

• One-click Mass Broadcast — commanders can push a verified counter-message to all registered citizens simultaneously

• Auto-approval loop — low-threat incidents (Panic Index < 4) are automatically approved and responded to; high-threat incidents wait for a human commander's review

Note: The police unit deployment feature was implemented as a demo — showing how an authority could flag and assign units to incidents. Full GPS-based live dispatch was scoped for future development.

Testing With Real Bengaluru Scenarios

We built a test suite of 6 real-world scenarios — no Telegram interaction needed — that injects incidents directly into the engine and measures the Panic Index output:

The system correctly distinguished between a routine metro question and a water mafia protest — without any human intervention. That's the benchmark we're proud of.

The Night the Backend Died (And What We Did About It)

No honest hackathon write-up is complete without the disaster story. Ours happened during deployment.

At some point deep into the 30-hour sprint, we attempted to deploy the backend on Google Cloud. It crashed — completely. Not a small bug, not a broken route. The entire backend went down.

In that moment, we did what every good engineer does: we went back to Git.

We retraced every change, commit by commit, using GitHub's history to understand what broke and when. It was painstaking and stressful — but it worked. Git wasn't just version control that day, it was our lifeline.

But we didn't stop at recovery. We went further.

We built a complete clone of the backend — fresh API keys, fresh configuration — and ran it locally on a separate system. The same React frontend was then connected to both systems, with each frontend instance isolated to its own backend. The result: if the Google Cloud deployment failed again, we had a fully functional locally-running fallback ready to go.

Two systems. One frontend design. Zero single point of failure.

It wasn't elegant. It wasn't in the original plan. But it worked — and more importantly, it taught us something that no course ever could: real engineering isn't about writing perfect code, it's about recovering when things break and building systems that don't let failures cascade.

What We Learned

1. Pivot fast, pivot smart Our WhatsApp-to-Telegram pivot happened under time pressure and ended up being a better design decision. Never fall so in love with your original idea that you can't adapt when reality pushes back.

2. Git is not optional — it's your safety net We recovered a crashed backend using commit history. Every engineer who thinks "I'll push later" is one crash away from losing hours of work.

3. Build for failure, not just success Our failover clone architecture was born out of crisis, but it's actually standard practice in production systems. Hackathons that push you to your limits teach you production-grade thinking faster than any classroom.

4. Multimodal AI changes everything Text-only moderation is 2022. Gemini's ability to watch a video and return a structured JSON threat assessment in a single call is genuinely game-changing for civic applications.

5. Velocity beats sentiment every time Our early versions relied heavily on keyword matching. The velocity signal was the single biggest accuracy improvement — it's the closest thing to real-time ground truth you can get without physical verification.

6. Schema enforcement is non-negotiable for AI pipelines We enforced a strict JSON output schema (contract.json) on every Gemini response. Without it, you get beautifully written AI text that breaks your downstream code at 2 AM. Lesson learned the hard way.

The Outcome

We didn't win.

But we walked out of that 30-hour hackathon with something more valuable than a trophy — a fully functional system, a story we're proud of, a team that communicated well under pressure, and the satisfaction of knowing we built something genuinely useful from scratch.

NammaShanti is real. It works. And it solves a real problem for a real city.

That felt like enough.

What's Next for NammaShanti

The hackathon was the beginning, not the end. Our roadmap includes:

• Voice Note Processing — Transcribing Telegram voice messages via Gemini for regional language support

• Kannada-First Translation — Auto-translating all responses back to Kannada for local citizens

• Automated FIR Drafting — Generating Karnataka Police FIR-format documents for high-threat incidents

• Real-time GPS Fleet — Replacing demo patrol markers with live KSRP vehicle tracking

• Firebase Auth — Restricting dashboard access to authenticated officers only

Try It Yourself

The full source code, architecture diagrams, and test suite are available on GitHub:

🔗 github.com/seamykiin/NammaShanti

If you're a developer interested in civic AI, a police tech researcher, or just someone who wants to see how Gemini's multimodal capabilities can be applied to real public safety problems — we'd love your feedback, contributions, or a star on the repo. ⭐

Acknowledgements

Huge thanks to my incredible teammates — Chandan U Achar, Jalaj Krishna B S, and Manish L — for their dedication, sleepless effort, and teamwork throughout those intense 30 hours. This project is as much theirs as it is mine.

Thanks also to Google Developer Groups (GDG) Bengaluru and REVA University for organizing the Build for Bengaluru Hackathon and giving us this platform.

Built with 🧡 for Bengaluru. "Shanti" means peace in Kannada. NammaShanti means "Our Peace."

Tags: #AI #GeminiAI #Firebase #HackathonProject #CivicTech #Python #React #GoogleCloud #MachineLearning #Bengaluru #BuildForBengaluru #GDGBengaluru #FakeNewsDetection #TelegramBot