FloodMurmur

Inspiration

Flood warnings are global, but flood depth is hyper‑local. A few centimeters can stall a car or cause a fall—yet block‑level depth rarely exists in time to help. Cameras are expensive and raise privacy questions; gauges are sparse. The insight behind FloodMurmur: the phones people already carry have microphones and motion sensors that can “hear/feel” shallow water. If we fuse those signals on‑device and upload only derived features, we can build a privacy‑first, infrastructure‑free flood‑depth layer to reroute people around danger and help cities fix micro‑flood hotspots.

What it does

FloodMurmur (proposed) estimates block‑level flood depth from short, on‑device audio + IMU snippets and converts them into conservative depth bins (splash/ankle/knee/hubcap/unsafe). The app contributes tile‑level, confidence‑weighted votes (no raw audio, no exact GPS). A server aggregates votes with time decay and outlier trimming to produce a real‑time safe‑route map and a post‑storm hotspot dashboard.

Key behaviors (planned)

• Privacy by design: Derive features locally; discard raw audio; quantize location into tiles; per‑device rate limits.
• Safety over coverage: When sensors disagree or SNR is low, the client abstains and shows uncertainty.
• Actionable for cities: Persistent tiles reveal clogged drains or curb geometry issues for targeted micro‑fixes.

How we built it (proposed approach)

We have not implemented FloodMurmur yet. Below is the plan to build an MVP:

1. On‑device pipeline (Android/iOS)
   • Event detection → feature extraction (non‑speech audio + motion) → lightweight classifier → calibration + abstention.
   • Raw audio discarded after features are computed.
2. Privacy filter
   • Tile quantization, per‑device rate limiting, explicit opt‑in, local history view with delete controls.
3. Uplink & consensus
   • Each contribution: (tile, depth_bin, confidence, device_class, mode, timestamp).
   • Server applies confidence‑weighted consensus with exponential time decay and trims outliers.
4. APIs & UI
   • Depth Tile API for clients.
   • Routing overlay that avoids knee+ tiles and surfaces uncertainty.
   • Pilot dashboard to rank hotspots by persistence across storms.

Consensus with decay (planned) $$ S_t = \frac{\sum_i w_i(t)\, y_i}{\sum_i w_i(t)}, \qquad w_i(t) = c_i \, e^{-\lambda\, (t - \tau_i)} . $$

Where y_i is the encoded depth bin (ordinal), c_i is client confidence, tau_i is the contribution time, and lambda controls half-life.

Challenges we ran into (anticipated)

• In‑the‑wild variability: Tires, footwear, phone placement, speed, and ambient noise can distort signals. Plan: fusion features, device‑class normalization, conservative thresholds, and a strict abstention policy.
• Ground truth collection: Getting curb‑stick depth labels during storms is tricky. Plan: pre‑mark curb sticks at likely puddle sites and run structured “first rain” calibration windows.
• Privacy & trust: Even feature uploads require clear disclosures. Plan: transparent settings, local history controls, tile‑level quantization, rate limits, and no raw audio ever.
• Consensus robustness: Avoid stale or anomalous votes dominating. Plan: time decay, outlier trimming, and minimum‑support thresholds per tile.
• Coverage density: Early pilots may be sparse. Plan: recruit cyclists/delivery partners, lightweight incentives, and public preview maps to encourage participation.

Accomplishments that we're proud of (ideation phase)

• A crisp problem framing that targets block‑level, real‑time depth—something current systems rarely provide.
• A privacy‑first architecture with on‑device processing and derived‑feature uplinks only.
• A pilot plan with concrete, judgeable metrics (near‑miss reduction, detour efficiency, alert precision, coverage, hotspot stability, engagement).
• A consensus formula and abstention policy that foregrounds safety and reliability.
• A submission‑ready package: Word/PDF docs, architecture diagram, and Devpost story.

What we learned (ideation phase)

• Abstention is a feature—clarity about uncertainty improves trust.
• On‑device ML is viable for shallow‑water binning; we don’t need cameras or fixed sensors.
• Small fixes, big impact—persistent hotspot tiles often map to drains or curb geometry that cities can actually fix quickly.
• Scalability depends on people—coverage grows naturally with everyday movement if the UX is respectful and useful.

What’s next for FloodMurmur

1. MVP prototyping (4–6 weeks)
   • Implement event detection + feature extraction; train first classifier on controlled splashes + early field data.
   • Build Depth Tile API and basic client overlay.
2. Two‑week pilot
   • Recruit ~50 volunteers; pre‑mark curb sticks; collect first rain; calibrate; enable conservative live routing.
3. Evaluation & iteration
   • Target ≥20% near‑miss reduction, ≤15% detour overhead, ≥80% precision within one bin.
   • Analyze hotspot persistence and city operations feedback.
4. Beyond MVP
   • Depth regression with uncertainty bounds; placement‑aware models; outage‑resilient mesh relays; city work‑order integration; regional scaling.

Built With

• backend-api
• ci/cd
• cloud
• maps
• mobile-app
• on-device-ml
• postgresql