SafetyMapper - Community Safety Platform

Your AI Safety Assistant for Every Journey

Comment

About SafetyMapper

💡 What Inspired This Project

The inspiration for SafetyMapper came from a simple but concerning observation: walking home late at night in urban areas, I realized how little real-time safety information was available to help make informed decisions about routes and destinations.

The "Aha!" Moment

One evening, walking through downtown after work, I noticed several incidents that made me feel unsafe - but there was no way to share this information with others or get guidance about safer alternatives. Existing safety apps were either:

  • Outdated - showing crime data from months ago
  • Limited - basic incident reporting without intelligent analysis
  • Disconnected - no integration with modern AI or comprehensive mapping

The Vision

I envisioned a platform where communities could share real-time safety information and receive AI-powered guidance based on actual local data. The goal was to combine:

  • Google Maps Platform's comprehensive APIs for location intelligence
  • Vertex AI Safety for secure, professional interactions
  • Community reporting for real-time situational awareness
  • Intelligent routing that prioritizes safety alongside efficiency

🎓 What I Learned

Technical Mastery

Building SafetyMapper taught me to orchestrate 9 different Google APIs seamlessly:

Core Integration Challenge:

# Managing multiple API calls efficiently
async def get_comprehensive_safety_data(location):
    # Parallel API calls to optimize performance
    tasks = [
        gmaps.places_nearby(location, type='police'),
        gmaps.places_nearby(location, type='hospital'), 
        gmaps.geocode(location),
        firestore.get_incidents_near(location)
    ]
    results = await asyncio.gather(*tasks)
    return combine_safety_intelligence(results)

AI Safety Implementation

The most valuable learning was implementing Vertex AI Safety with Gemini AI. I discovered that effective AI moderation requires multiple layers:

  1. Content Safety - detecting harmful language
  2. Brand Safety - maintaining professional standards
  3. Alignment - keeping conversations safety-focused
  4. Privacy - protecting user information

Real-Time Data Architecture

Working with Google Cloud Firestore taught me to design for both immediate responsiveness and long-term scalability:

// Real-time incident updates
const unsubscribe = onSnapshot(
    query(collection(db, 'incidents'), 
          where('status', '==', 'active'),
          orderBy('created_at', 'desc')), 
    (snapshot) => {
        snapshot.docChanges().forEach((change) => {
            if (change.type === 'added') {
                addIncidentToMap(change.doc.data());
            }
        });
    }
);

User Experience Insights

Safety applications must work flawlessly on mobile devices. I learned that:

  • Response times must be < 2 seconds for safety queries
  • Touch interfaces need larger interaction areas
  • Offline functionality is critical for emergency situations
  • Trust building requires transparent data sources

🔨 How I Built This Project

Architecture Foundation

SafetyMapper uses a microservices-inspired architecture built entirely on Google Cloud Platform:

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Frontend      │    │   Flask Backend  │    │  Google Cloud   │
│   (Maps + AI)   │◄──►│   (API Layer)    │◄──►│   (Data + AI)   │
└─────────────────┘    └──────────────────┘    └─────────────────┘

Step-by-Step Development Process

Phase 1: Maps Foundation

Started with Google Maps JavaScript API for basic incident visualization:

// Initial map setup with custom styling
const map = new google.maps.Map(document.getElementById('map'), {
    zoom: 12,
    center: { lat: 38.9847, lng: -77.0947 }, // Bethesda, MD
    styles: customSafetyMapStyle // Enhanced visibility for safety markers
});

Phase 2: AI Integration

Integrated Vertex AI Safety and Gemini AI for intelligent safety assistance:

# Multi-layered AI safety check
def check_content_safety(message):
    safety_results = {
        'content_safety': vertex_ai_content_check(message),
        'brand_safety': check_professional_standards(message),
        'alignment': verify_safety_relevance(message),
        'privacy': scan_personal_information(message)
    }
    return evaluate_combined_safety(safety_results)

Phase 3: Route Intelligence

Implemented safety-aware routing using Directions API with custom scoring:

The safety score algorithm combines multiple factors:

$$\text{Safety Score} = w_1 \cdot I_{proximity} + w_2 \cdot R_{resources} + w_3 \cdot T_{time} + w_4 \cdot M_{mode}$$

Where:

  • \(I_{proximity}\) = incident proximity penalty
  • \(R_{resources}\) = safety resource bonus (police, hospitals)
  • \(T_{time}\) = time-of-day risk factor
  • \(M_{mode}\) = transportation mode safety modifier
def calculate_route_safety_score(route_segments, incidents, resources):
    total_score = 0
    for segment in route_segments:
        # Distance-weighted incident impact
        incident_penalty = sum(
            1/max(distance_to_incident(segment, incident), 0.1)**2 
            for incident in nearby_incidents(segment, incidents)
        )

        # Resource proximity bonus
        resource_bonus = sum(
            1/distance_to_resource(segment, resource) 
            for resource in nearby_resources(segment, resources)
        )

        segment_score = base_score - incident_penalty + resource_bonus
        total_score += segment_score * segment.distance

    return normalize_score(total_score, route.total_distance)

Phase 4: Data Management

Built comprehensive data layer with Cloud Firestore:

# Efficient incident storage with geospatial indexing
def store_incident(incident_data):
    incident_doc = {
        'type': incident_data['type'],
        'location': incident_data['location'],
        'coordinates': firestore.GeoPoint(
            incident_data['lat'], 
            incident_data['lng']
        ),
        'severity': incident_data['severity'],
        'created_at': firestore.SERVER_TIMESTAMP,
        'verified': False,
        'photo_url': upload_to_cloud_storage(incident_data.get('photo'))
    }

    doc_ref = db.collection('incidents').add(incident_doc)
    return doc_ref.id

🚧 Challenges Faced and Solutions

Challenge 1: API Rate Limiting

Problem: With 9 different Google APIs, hitting rate limits during testing.

Solution: Implemented intelligent caching and request batching:

from functools import lru_cache
import asyncio

@lru_cache(maxsize=128)
def cached_places_search(location, radius, place_type):
    """Cache frequently requested place searches"""
    return gmaps.places_nearby(
        location=location, 
        radius=radius, 
        type=place_type
    )

async def batch_api_requests(requests):
    """Batch multiple API calls with rate limiting"""
    semaphore = asyncio.Semaphore(5)  # Limit concurrent requests

    async def limited_request(request):
        async with semaphore:
            await asyncio.sleep(0.1)  # Rate limiting delay
            return await request()

    return await asyncio.gather(*[limited_request(req) for req in requests])

Challenge 2: AI Safety Balance

Problem: Vertex AI Safety was either too restrictive (blocking legitimate safety questions) or too permissive (allowing inappropriate content).

Solution: Implemented contextual safety scoring with manual tuning:

def contextual_safety_check(message, context):
    # Base safety check
    base_safety = vertex_ai_safety_check(message)

    # Context-aware adjustments
    if is_safety_related_query(message):
        # More lenient for legitimate safety questions
        safety_threshold = 0.3
    elif is_emergency_context(context):
        # Very lenient for emergency situations
        safety_threshold = 0.1
    else:
        # Standard threshold for general chat
        safety_threshold = 0.5

    return base_safety.confidence_score < safety_threshold

Challenge 3: Real-Time Performance

Problem: Initial version had 3-5 second delays for route calculations with safety analysis.

Solution: Implemented progressive enhancement and background processing:

# Progressive route enhancement
async def get_enhanced_route(origin, destination):
    # Quick basic route (< 1 second)
    basic_route = await gmaps.directions_async(origin, destination)
    yield basic_route

    # Enhanced with safety data (2-3 seconds)
    incidents = await get_nearby_incidents_async(basic_route.bounds)
    safety_route = enhance_route_with_safety(basic_route, incidents)
    yield safety_route

    # Full analysis with resources (3-5 seconds)
    resources = await get_safety_resources_async(basic_route.bounds)
    complete_route = add_resource_analysis(safety_route, resources)
    yield complete_route

Challenge 4: Mobile Responsiveness

Problem: Google Maps interface wasn't touch-friendly on mobile devices.

Solution: Custom mobile controls and gesture handling:

// Custom mobile-optimized map controls
function initMobileControls() {
    if (window.innerWidth < 768) {
        // Larger touch targets for mobile
        const controls = document.querySelectorAll('.control-btn');
        controls.forEach(control => {
            control.style.minHeight = '44px';
            control.style.minWidth = '44px';
            control.style.fontSize = '1.2rem';
        });

        // Touch-friendly incident reporting
        map.addListener('click', (event) => {
            showMobileFriendlyReportDialog(event.latLng);
        });
    }
}

Challenge 5: Data Quality and Trust

Problem: How to ensure incident reports are accurate and trustworthy?

Solution: Multi-layered verification system:

def calculate_report_trustworthiness(report, reporter):
    trust_score = 0.5  # Base trust

    # Reporter history
    if reporter.verified_local:
        trust_score += 0.3
    if reporter.accurate_reports_ratio > 0.8:
        trust_score += 0.2

    # Report characteristics  
    if report.has_photo:
        trust_score += 0.2
    if report.details_length > 50:  # Detailed reports more trustworthy
        trust_score += 0.1

    # Community verification
    trust_score += min(report.community_confirmations * 0.1, 0.3)

    return min(trust_score, 1.0)

🎯 Technical Achievements

Performance Metrics

  • API Response Time: < 500ms for 95% of requests
  • Map Load Time: < 2 seconds on 3G connections
  • AI Chat Response: < 1.5 seconds average
  • Incident Upload: < 3 seconds including photo processing

Scalability Features

  • Horizontal scaling ready with Google App Engine
  • Database sharding prepared for city-wide deployment
  • CDN integration for global photo delivery
  • API versioning for backward compatibility

Security Implementation

  • End-to-end encryption for sensitive data
  • Rate limiting on all API endpoints
  • Input sanitization with parameterized queries
  • Audit logging for all user actions

🚀 Impact and Future Vision

SafetyMapper demonstrates how modern AI and mapping technology can be combined to create real community value. The project serves as a proof-of-concept for enterprise-ready safety solutions that could be deployed at city scale.

Current Status:

  • ✅ Live production deployment with real users
  • ✅ 9 Google APIs integrated seamlessly
  • ✅ Enterprise-grade security implemented
  • ✅ Mobile-responsive design completed

Future Expansion: The architecture is designed to scale from 9 to 21+ Google APIs, enabling features like predictive analytics, augmented reality safety overlay, and smart city integration.

SafetyMapper proves that with the right combination of Google Cloud Platform services, individual developers can create professional-grade applications that make real communities safer.

Built With

  • 9-google-apis-(maps-javascript
  • directions
  • firestore
  • firestore-api)
  • gemini-ai
  • geocoding
  • geometry
  • google-cloud-platform-(app-engine
  • html5/css3
  • javascript-(es6+)
  • places
  • progressive-web-app-technologies
  • python-3.9+-(flask)
  • rest
  • vertex-ai)
  • vertex-ai-safety
  • visualization
Share this project:

Updates