CrisisMesh

Inspiration:

During disasters — floods, earthquakes, fires — critical information doesn't fail to exist, it fails to reach the right people in time. Reports arrive scattered across WhatsApp messages, SMS, and social posts, often describing the same emergency multiple times in different words. Research on humanitarian response consistently identifies fragmented information flow and coordination gaps as major recurring obstacles during crisis response — this isn't a rare edge case, it happens in nearly every large-scale disaster. We wanted to build something that attacked that specific failure point, not just visualize a crisis, but actually untangle it.

What it does:

CrisisMesh is a crisis-response coordination layer that turns chaotic, unstructured messages into clean, prioritized, assignable action. It extracts key details — location, urgency, type of need, affected population — from incoming reports, merges duplicate reports describing the same incident into a single consolidated case, and scores priority transparently through a Priority Engine (showing exactly why one case outranks another — medical urgency, vulnerable population, time sensitivity, and more). Verified incidents are matched with the right available volunteer based on skill and proximity, everything is visualized on a live operations map, and every decision the system makes is logged in a full audit trail — so the reasoning is never a black box.

How we built it:

We built CrisisMesh with Lovable, using a TanStack Start template for the frontend scaffold. The core AI Processing layer uses the Gemini API to extract structured data (location, urgency, resource needs) from raw incoming messages and drive the deduplication and prioritization logic. We simulated a real-world scenario — a Chennai flood response — feeding synthetic WhatsApp/SMS-style reports through the system to test incident consolidation, priority scoring, and volunteer matching end-to-end across the full dashboard: Live Incidents, Incoming Reports, Operations Map, Volunteers, Resources, Tasks, Analytics, and Audit Trail.

Challenges we ran into:

Getting duplicate detection right was harder than expected — real reports describe the same incident with wildly different wording ("need insulin near bus stand" vs. "diabetic patient stranded"), so reliably clustering them without merging genuinely distinct incidents took careful tuning. We also had to think carefully about the ethics of a priority-scoring system — making sure the scoring logic was transparent and explainable (via the audit trail) rather than an opaque black box, since trust matters enormously in an emergency context.

Accomplishments that we're proud of:

We're proud that CrisisMesh isn't just a concept — it's a working system with a real, functioning pipeline from raw message to assigned task, tested against a full simulated incident scenario. Getting the deduplication and transparent priority scoring working end-to-end, as a two-person team, is what we're most proud of.

What we learned:

We learned that the hardest part of "AI for good" projects isn't the AI — it's the workflow design around it: how information should flow, what needs to stay human-in-the-loop, and how to make automated decisions explainable rather than opaque. We also got hands-on experience integrating the Gemini API into a real extraction-and-reasoning pipeline, not just a chatbot interface.

What's next for CrisisMesh:

Next, we want to test CrisisMesh against real (anonymized) historical disaster-report data rather than synthetic messages, add multilingual support for outgoing updates so it works across diverse communities, and explore integrations with existing humanitarian coordination platforms rather than operating as a standalone tool — since the goal isn't to replace what responders already trust, but to make it faster and clearer.

Built With

• api
• firebase
• gemini
• mapbox
• react
• start
• supabase
• tanstack
• typescript
• vite