Urban Vitals

Diagram

Inspiration

We were inspired by a simple realization: people spend months researching which neighborhood to move to, comparing rent prices and commute times—but have no easy way to understand the environmental health of where they'll actually live.

Living in different cities, we each experienced this firsthand. One of us dealt with poor air quality that triggered asthma. Another lived in a "walkable" neighborhood that felt unsafe at night. A third watched their community struggle during extreme weather events with zero preparation.

The breaking point came when we discovered that critical environmental data exists—air quality indices, climate risk assessments, infrastructure ratings—but it's scattered across dozens of government databases, academic papers, and proprietary datasets. No one had connected the dots.

We realized sustainability isn't just about solar panels and recycling bins. It's about whether you can breathe clean air, walk to the grocery store, and know your home won't flood in five years. Environmental justice starts with environmental visibility. If we could democratize this data and make it as accessible as Yelp reviews, we could help millions make better decisions while giving cities the tools to improve where it matters most.

Urban Vitals was born from the belief that your zip code shouldn't determine your life expectancy—and that everyone deserves to know what makes their neighborhood thrive.

What it does

Urban Vitals is an AI-powered neighborhood sustainability platform that transforms complex environmental data into actionable insights through a simple Green Score (1-10).

Core Features:

🗺️ Interactive 3D Visualization

Real-time mapping of 200+ neighborhoods with color-coded sustainability markers
Toggle between layers (air quality, walkability, disaster risk, transit access)
Click any neighborhood for detailed metric breakdowns and historical trends

📊 Comprehensive Scoring System (13+ Metrics) We evaluate neighborhoods across four categories:

Environmental Quality: Air quality index, green space coverage, water quality, noise pollution
Infrastructure: Power grid reliability, road conditions, public cleanliness, waste management
Livability: Public safety scores, walkability index, transit accessibility, community amenities
Climate Resilience: Renewable energy adoption, disaster risk (LEWC modeling), flood zones, heat island effect

🤖 Eco-Friendly AI Assistant Powered by Tandemn's sustainable infrastructure, our chatbot:

Explains sustainability scores in plain language
Compares neighborhoods based on user priorities
Suggests actionable improvements for residents and city planners
Tracks real CO₂ savings (1.7mg per token) using refurbished hardware + renewable energy

🔍 Intelligent Data Pipeline

Automated scraping from OpenStreetMap, government APIs, weather services, and transit systems
Geographic validation and coordinate resolution for every neighborhood
Real-time updates for dynamic metrics (air quality, weather, transit delays)
AI-powered narrative generation explaining why each score matters

📈 Analytics Dashboard

City-wide sustainability statistics and trends
Identify environmental justice gaps (which neighborhoods are underserved)
Track improvement over time as cities invest in infrastructure

The Result: Anyone can search their address, see their neighborhood's Green Score, understand what's working and what's not, and make data-driven decisions about where to live or how to advocate for change.

How we built it

We built Urban Vitals as a full-stack application with an automated data pipeline, designed for scalability from day one.

Frontend (React + Vite)

Mapbox GL JS for 60fps 3D rendering with 200+ interactive markers
Color-coded visualization system (red = low scores, green = high scores)
Layer toggling for filtering by specific metrics
Responsive design system optimized for desktop and mobile
Real-time API integration with axios for dynamic data fetching

Backend (FastAPI + Python)

RESTful API with 8+ endpoints for neighborhood data, statistics, and AI chatbot
Structured JSON data management with validation schemas
CORS configuration for secure cross-origin requests
Integration with Tandemn AI Cloud for sustainable chatbot responses
Modular architecture for easy expansion to new cities

Data Pipeline (Python + Modal) We built a five-stage automated pipeline that can generate complete sustainability profiles for any city:

Neighborhood Discovery (neighbourhood_scraper.py)
- Scrapes OpenStreetMap for neighborhood boundaries and names
- Validates geographic entities and filters out non-residential areas
- Outputs structured JSON with initial metadata
High-Precision Geocoding (enhanced_geocoder.py)
- Converts neighborhood names to exact coordinates
- Uses Google Maps API with fallback strategies for ambiguous locations
- Validates coordinates are within expected city boundaries
Sustainability Metrics Generation (data_exp_2.py)
- Pulls real-time data: air quality (Open-Meteo), weather, transit access
- Calculates composite scores for 13+ indicators
- Normalizes scores to 1-10 scale with statistical weighting
AI Content Enhancement (data_exp.py)
- Uses Cerebras Cloud SDK to generate human-readable explanations
- Creates personalized descriptions of what makes each neighborhood unique
- Identifies strengths, weaknesses, and improvement opportunities
Final Data Transformation (gs_converter.py)
- Structures data for API consumption
- Validates schema compliance and data integrity
- Outputs production-ready JSON

Scalability Infrastructure:

Modal.com for cloud deployment and parallel processing
One-command city generation: modal run modal_pipeline.py --city-state "Seattle, WA"
Containerized pipeline stages for reproducibility

AI Integration:

Tandemn Cloud API for eco-friendly LLM inference (refurbished hardware + green energy)
Cerebras API for fast content generation during data processing
Token counting and CO₂ tracking displayed in real-time

Key Technologies:

Frontend: React 18, Mapbox GL JS, Axios, Vite
Backend: FastAPI, Uvicorn, Python 3.8+
Data: OpenStreetMap Overpass API, Open-Meteo, Google Maps
AI: Tandemn Cloud, Cerebras SDK
Infrastructure: Modal (optional cloud scaling)

Challenges we ran into

1. Data Quality & Availability The biggest challenge was data inconsistency. Different sources use different neighborhood definitions—what OpenStreetMap calls "Downtown" might have different boundaries than census data. We solved this by:

Building a coordinate validation system that checks geographic plausibility
Implementing fuzzy matching algorithms for neighborhood names
Creating fallback strategies when primary data sources failed
Accepting that some metrics need simulated values until real-time APIs are available at scale

2. Geocoding Accuracy Converting "Maple Ash" or "College Avenue District" into exact coordinates was surprisingly hard. Generic geocoders often returned wrong cities or vague center points. Our solution:

Built a custom geocoder with city-context awareness
Implemented Google Maps API with confidence scoring
Added manual validation for ambiguous results
Created a two-pass system: fast OSM lookup, then precise Google verification

3. Real-Time API Rate Limits We wanted live air quality and transit data, but free APIs have strict quotas (often 60 requests/hour). Our workarounds:

Implemented intelligent caching strategies
Batched requests during pipeline runs
Used averaged/interpolated data for initial MVP
Designed architecture to swap in premium APIs when scaling

4. AI Model Integration Complexity Getting AI to generate relevant, accurate sustainability insights (not generic fluff) required extensive prompt engineering:

Iterated through 20+ prompt templates to get consistent output format
Added strict JSON schema validation to prevent hallucinations
Implemented context windows that include actual metric values
Built error handling for API timeouts and malformed responses

5. Scoring Algorithm Balance Deciding how to weight different metrics was subjective. Is walkability more important than air quality? We addressed this by:

Researching academic papers on urban livability indices
Testing multiple weighting schemes with diverse user feedback
Making weights transparent and eventually customizable
Planning feature: user-defined priorities (e.g., "I care most about transit")

6. Frontend Performance Rendering 200+ interactive markers on a 3D map initially caused lag. Optimizations:

Implemented marker clustering for zoomed-out views
Used Mapbox's GPU-accelerated rendering
Lazy-loaded detailed data (fetch on marker click, not page load)
Reduced polygon complexity for neighborhood boundaries

7. Hackathon Time Constraints Building a full-stack app + data pipeline + AI integration in 36 hours meant brutal prioritization:

Focused on one city (Tempe) for MVP depth over breadth
Used simulated data for some metrics where APIs were too complex
Deferred features like user accounts, mobile app, multi-city support
Accepted technical debt to ship a functional demo

8. Environmental Data Interpretation Translating raw numbers (PM2.5: 12 µg/m³) into meaningful scores required domain knowledge we didn't have initially. We solved this through:

Research into EPA standards and WHO guidelines
Normalizing against city/national averages
Color-coding with clear thresholds (red/yellow/green)
AI explanations that contextualize what numbers mean for health

Accomplishments that we're proud of

🚀 We Built a Genuinely Useful Tool This isn't vaporware or a toy demo—Urban Vitals works. You can explore real Tempe neighborhoods, see actual sustainability metrics, and get meaningful insights. We validated our concept by showing it to strangers who immediately understood the value proposition.

🤖 Sustainable AI That Walks the Talk We're not just talking about sustainability—our AI infrastructure saves real CO₂. By using Tandemn's refurbished hardware and renewable energy, we avoid 1.7mg CO₂ per token compared to commercial LLMs. We built a carbon counter right into the interface because transparency matters. This project proves you can build powerful AI without environmental guilt.

📊 Comprehensive Data Pipeline Automation We didn't just scrape one dataset—we built a production-grade pipeline that orchestrates 5 different stages, integrates 10+ data sources, and can generate complete city profiles with a single command. The same code that mapped Tempe can map Seattle, Boston, or Austin with zero modification. That's real engineering.

🗺️ Stunning Visualization Our 3D Mapbox implementation is legitimately beautiful. Color-coded markers, smooth transitions, layer toggling, hover effects—it feels like a professional product, not a hackathon prototype. We obsessed over UX details: intuitive controls, clear legends, responsive design. Data visualization is hard; we nailed it.

⚡ Speed of Execution We went from idea to deployed full-stack application in 36 hours. That includes:

Frontend with complex mapping
Backend API with 8+ endpoints
Automated data pipeline with 5 stages
AI chatbot with CO₂ tracking
200+ neighborhoods fully profiled
Video demo and documentation

🔬 Rigorous Scoring Methodology Our Green Score isn't arbitrary—it's based on 13+ scientifically-backed metrics with transparent weighting. We researched academic urban planning literature, EPA standards, and walkability indices to build something credible. This project could legitimately inform policy decisions.

🌍 Real Impact Potential We've already identified environmental justice gaps in Tempe (neighborhoods with scores below 6 that need intervention). Imagine scaling this to 100 cities—suddenly you have a national map of sustainability inequality. That's data policymakers desperately need but don't have.

🤝 Seamless Team Collaboration Three people with different skill sets (frontend, backend, data science) integrated work flawlessly. We used clear API contracts, modular architecture, and constant communication. Zero merge conflicts. Zero blocking dependencies. That's rare in hackathons.

📈 Scalability Architecture We didn't build a throwaway demo—we built something that can grow. Modal integration means we can process cities in parallel. Our API design supports multi-city deployments. The codebase is clean, documented, and ready for contributors. This project has legs.

💡 Novel Problem Framing There are air quality apps. There are walk score websites. But nobody had combined environmental, infrastructure, livability, and climate resilience into one comprehensive neighborhood rating system. We identified a genuine market gap and filled it.

What we learned

🔍 Data is Messier Than You Think We assumed environmental data would be standardized and accessible—it's not. Every API uses different formats, update frequencies, and geographic boundaries. We learned to:

Always validate data before trusting it
Build robust error handling for incomplete datasets
Accept imperfection and communicate limitations transparently
Appreciate the work data engineers do to clean messy sources

🤖 AI Prompt Engineering is an Art Getting Cerebras and Tandemn to generate useful sustainability insights took 20+ iterations. Generic prompts gave generic outputs. We learned:

Specificity matters: "Explain in 2 sentences" > "Explain this"
Context windows are crucial: include actual metric values, not just names
JSON schema enforcement prevents hallucinations
Test prompts on edge cases (weird neighborhood names, missing data)

🗺️ Visualization Drives Understanding We initially planned to show data in tables—then built the 3D map and realized how much more powerful visual storytelling is. A red cluster of low-scoring neighborhoods communicates inequality instantly. We learned:

Invest in UX even during hackathons
Color theory matters (red/yellow/green is universally understood)
Interactive elements (hover, click, zoom) increase engagement
Animation makes data feel alive and dynamic

⚡ Scope Management is Critical We wanted to build multi-city support, user accounts, predictive modeling, and mobile apps—but had 36 hours. We learned to:

Pick one city and do it excellently > ten cities poorly
Use simulated data strategically (acknowledge it openly)
Build for scalability without over-engineering day one
Ship a complete narrow product > incomplete broad product

🌱 Sustainability Means Trade-Offs We discovered refurbished hardware AI (Tandemn) is genuinely greener—but slightly slower. We learned:

Environmental choices require measuring actual impact (CO₂ per token)
Marketing "green" isn't enough; show receipts (our carbon counter)
Users will accept minor performance hits for sustainability
Building climate-conscious tech means making intentional infrastructure choices

📊 Metrics Need Narrative Raw numbers (PM2.5: 12 µg/m³) are meaningless to most people. We learned:

Always contextualize ("That's below EPA safe limits")
Use comparisons ("20% better than the city average")
Explain consequences ("Reduces asthma risk by...")
Let AI translate technical jargon into plain language

🏗️ Architecture Matters From Day One We built modular, documented code because we knew we'd want to expand this. That discipline paid off when:

Adding new metrics took minutes, not hours
Team members could work in parallel without conflicts
Debugging was fast because each stage was isolated
We could demo confidently knowing nothing would break

🤝 Collaboration Beats Competition We complemented each other's skills perfectly:

One person owned frontend/design
One owned backend/API integration
One owned data pipeline/scraping Everyone trusted their domain expert. We learned:
Clear ownership reduces bikeshedding
Regular standups (every 4 hours) keep alignment
Celebrate small wins to maintain morale
Hackathons are marathons disguised as sprints

💡 Problem Definition is Half the Solution We spent the first 3 hours debating what to build. That upfront investment meant we never second-guessed our direction. We learned:

Start with user stories, not tech stack
Validate the problem exists (we polled friends about neighborhood data gaps)
Simplify the value prop to one sentence
Technical complexity is fine; unclear purpose is fatal

🌍 Social Impact Requires Evidence Saying "we help the environment" isn't enough. We learned to:

Quantify impact (CO₂ saved, neighborhoods analyzed, gaps identified)
Show real examples (Tempe neighborhoods below score 6)
Connect data to policy (where should cities invest?)
Measure what matters (not just pretty visualizations)

What's next for Urban Vitals

🚀 Immediate Next Steps (Next 3 Months)

1. Multi-City Expansion Our pipeline is ready—we just need to run it. Goals:

Deploy to 10 major US cities (Austin, Boston, Seattle, Denver, Portland, Chicago, NYC, LA, SF, DC)
Validate scoring consistency across different climates and urban densities
Build city comparison features (how does Austin's average score compare to Seattle's?)
Create a public API for researchers and journalists

2. Real-Time Data Integration Replace simulated metrics with live feeds:

Partner with air quality sensor networks (PurpleAir, AirNow)
Integrate real transit APIs (GTFS feeds for every city)
Connect to municipal open data portals for infrastructure metrics
Implement webhook-based updates for dynamic scores

3. Mobile Application Build native iOS/Android apps with:

Location-based notifications ("You just entered a low-score zone—here's why")
Augmented reality overlay showing sustainability metrics as you walk
Offline mode with cached neighborhood data
Sharing features ("Check out my neighborhood's Green Score!")

4. User-Generated Content Empower communities to improve data quality:

Verified resident reviews and updates
Photo uploads of local conditions (trash, green space, infrastructure)
Community-reported issues (broken streetlights, air quality complaints)
Gamification: earn points for contributing validated data

🌍 Medium-Term Vision (6-12 Months)

5. Advanced Analytics & Predictive Modeling Move from descriptive to predictive:

What-if simulator: "If we add a light rail station here, how does walkability improve?"
Trajectory forecasting: "This neighborhood's score is declining—here's why"
Climate change projections: "In 2030, flood risk here increases 40%"
Investment ROI calculator: "Adding bike lanes here would improve scores by 1.2 points"

6. Policy & Planning Tools Build an enterprise dashboard for city governments:

Identify environmental justice gaps with heat maps
Track sustainability KPIs over time (are interventions working?)
Generate automated reports for city council meetings
Budget optimization: where to allocate resources for max score improvement
Compliance tracking: monitor progress toward climate goals

7. Real Estate Integration Partner with Zillow, Redfin, Apartments.com to:

Display Green Scores on every listing
Create sustainability filters (show me homes in 8+ neighborhoods)
Price correlation analysis (do sustainable neighborhoods appreciate faster?)
Buyer preference data (what % prioritize sustainability?)

8. Insurance & Financial Applications Work with insurance companies and lenders:

Risk-adjusted premiums based on disaster scores
Green mortgages with lower rates for high-scoring neighborhoods
Resilience bonds tied to score improvements
Climate disclosure requirements for property transactions

🔮 Long-Term Ambitions (1-3 Years)

9. International Expansion Adapt methodology for global cities:

Europe: integrate EU environmental directives and local data
Asia: account for different urban density patterns and metrics
Developing nations: partner with NGOs for ground-truth data collection
Global sustainability index: create cross-border comparability

10. Research Partnerships Collaborate with academia and policy think tanks:

Open-source our dataset for urban planning research
Co-author papers on environmental justice and neighborhood sustainability
Provide data for climate adaptation strategies
Build tools for university urban planning programs

11. Platform Ecosystem Become the infrastructure layer for sustainable urban tech:

Public API marketplace: Developers build on our data
Third-party integrations: Smart city IoT sensors feed into our platform
B2B SaaS model: Subscription tiers for cities, developers, researchers
Carbon offset marketplace: Link low-scoring neighborhoods to improvement funding

12. Behavioral Interventions Move beyond data to action:

Gamified challenges: "Improve your neighborhood's walkability score"
Resident organizing tools: petition city council with data-backed demands
Local business incentives: shops get visibility boosts for sustainability practices
Crowdfunding infrastructure improvements tied to score projections

🎯 Success Metrics (How We'll Measure Impact)

Reach: 50 cities mapped, 10M+ neighborhoods profiled by 2027
Adoption: 1M monthly active users exploring neighborhood data
Policy Impact: 100+ cities use our data for sustainability planning
Environmental Justice: Identify and track 1,000+ underserved neighborhoods
Real Estate Integration: Green Scores on 50%+ of major listing platforms
Carbon Savings: Track cumulative CO₂ saved through eco-friendly AI infrastructure
Research Output: 50+ academic citations, 10+ partnerships with universities
Community Engagement: 10,000+ user-contributed data points validated
Revenue: Sustainable B2B SaaS model supporting continued development

💡 Why This Matters

Urban Vitals isn't just a hackathon project—it's the foundation for how we'll make climate-conscious decisions in the coming decades. As extreme weather intensifies, housing costs rise, and environmental inequality grows, people need tools to protect themselves and advocate for change.

We're building the sustainability layer for cities—making invisible environmental factors visible, actionable, and equitable. Every neighborhood deserves a Green Score. Every resident deserves to know what they're breathing. Every city deserves data to guide climate adaptation.

This is just the beginning. 🌱