LumenPath

Inspiration

In 2026, we have the most advanced mapping technology in human history. Yet, every day, millions of people, especially women walking home at night, students, and tourists, open a maps app and get directions optimized for exactly one metric: speed. Mainstream navigation apps are entirely blind to human safety. They have no idea if they are routing you past the highest-crime block in the city, through a stretch of road with broken street lights, or across a dangerous intersection, just to save you two minutes. Navigation is not just a routing problem; it is a safety problem. We realized that if cities publish massive amounts of open safety data, we could build an engine that actually uses it. That is why we built LumenPath.

What it does

LumenPath is a real-time pedestrian safety routing engine. You enter a starting point and a destination. Within seconds, LumenPath analyzes every possible street segment between you and your goal using live city data sources. It scores each segment on a 0–100 risk scale and returns the route that avoids the highest-risk zones. The interface provides:

• A Safest Route (teal) that actively avoids crime clusters, dark streets, and traffic hazards.
• A Fastest Route (amber) so users can clearly see the safety vs. time tradeoff.
• A Dynamic Heatmap overlaying high/medium/low risk zones across the city.
• A Google Maps Handoff button that pushes the calculated safe route directly into the user's native Google Maps app for live GPS turn-by-turn navigation. ## How we built it The Tech Stack:
• Backend: Python 3.11 and FastAPI.
• Frontend: Vanilla JavaScript, Leaflet.js, and CartoDB dark tiles.
• Routing Engine: OSRM (Open Source Routing Machine). The Data Pipeline: We wrote asynchronous Python workers (asyncio.gather + httpx) to pull live data concurrently from the Chicago Open Data Portal (SODA APIs). Within milliseconds, we aggregate:
• 30-day rolling crime reports.
• Active 311 street lighting outages.
• 7-day traffic crash data. The Algorithm: Instead of standard shortest-path routing, we built a custom Multi-Criteria Decision Analysis (MCDA) engine. We calculate a severity-weighted risk score for every street segment. To ensure mathematical accuracy, we process this weight through a Logistic (Sigmoid) Decay Function, giving each route a defensible 0–100 safety score.

Challenges we ran into

Concurrency vs. Latency: Naively querying the Chicago Data Portal for every GPS point on a 3-mile route would take over 15 seconds. We solved this by intelligently sampling waypoints and using Python's asyncio.gather to fire all data requests in parallel. This reduced our fetch and compute time to under 3 seconds. Scoring Normalization: Raw crime counts are misleading. A block with 10 minor incidents (like pickpocketing) might actually be safer for a pedestrian than a block with 2 violent assaults. Tuning our severity-weights to feed into the logistic curve was a major mathematical challenge. Cross-Platform Deep Linking: We didn't want LumenPath to just be a visualization; we wanted users to walk the routes. Generating a universal Google Maps URL payload that successfully forces the native iOS/Android app to navigate custom waypoints required extensive URL schema testing.

Accomplishments that we're proud of

• Zero Mock Data: Every score generated in our live demo is computed from actual, real-time Chicago city data.
• End-to-End Execution: We built a full geocoding, custom A* scoring, and interactive mapping pipeline in just 72 hours.
• The UI/UX: The "Fastest vs. Safest" side-by-side comparison makes an invisible problem (urban risk) instantly visible and understandable to the user.

What we learned

We learned that open city data is remarkably rich and largely untapped for consumer applications. Chicago's portal alone has dozens of datasets we didn't even touch yet. We also learned a valuable lesson in UX framing. Presenting safety as a quantitative, objective score (e.g., 84/100) rather than a qualitative warning ("this is a dangerous zone") encourages logical, informed decision-making instead of fear.

What's next for LumenPath

Predictive ML Scoring: Currently, we react to past data. We want to train a machine learning model on historical data to forecast risk by time-of-day and day-of-week. IoT Edge Integration: Syncing the routing engine directly with smart-city infrastructure (like smart streetlights) to reduce cloud latency and improve real-time awareness. Global Expansion: Cities like New York, Los Angeles, and London expose similar open data APIs that use the SODA standard, making LumenPath highly scalable.

Built With

• 3.11
• and
• cartodb
• leaflet.js
• osrm
• python
• vanilla-javascript