-
Dashboard (route & hospital data)
-
Login Page
-
Route alerts, Hospital alerts, AI reports
Inspiration
In medical emergencies, even a few minutes of delay can become life-threatening. Ambulances often get stuck in traffic, hospitals may already be overloaded, and patients are frequently taken to facilities that are not best suited for their condition.
We wanted to build a smarter emergency response system that could make intelligent decisions in real time — selecting the right hospital, reducing delays, and improving coordination between patients, ambulances, and hospitals.
This idea led to the creation of ClearRoute AI.
What it does
ClearRoute AI is an intelligent emergency response and hospital routing platform.
When a user reports an emergency, the system:
- Analyzes the condition using AI-driven triage logic
- Classifies the severity level of the emergency
- Dynamically identifies nearby hospitals based on location
- Simulates ICU and hospital load balancing
- Automatically reroutes patients if a hospital is overloaded
- Generates medical summaries and emergency alerts
- Optimizes emergency routing decisions in real time
The platform aims to reduce emergency response time:
$$ T_{optimized} < T_{traditional} $$
where:
- $T_{optimized}$ = AI-optimized emergency response time
- $T_{traditional}$ = conventional response time
How we built it
We built ClearRoute AI using:
- Python Flask for backend APIs and routing logic
- HTML, CSS, and JavaScript for the frontend
- SQLite for lightweight authentication and storage
- OpenStreetMap APIs for dynamic hospital discovery
- AI-based emergency classification logic
- Render for deployment and hosting
The hospital selection system calculates proximity using the Haversine distance formula:
$$ d = 2r \arcsin \left( \sqrt{ \sin^2\left(\frac{\phi_2-\phi_1}{2}\right) + \cos(\phi_1)\cos(\phi_2) \sin^2\left(\frac{\lambda_2-\lambda_1}{2}\right) } \right) $$
where:
- $\phi$ = latitude
- $\lambda$ = longitude
- $r$ = Earth radius
This allows the system to intelligently determine the nearest suitable hospital.
Challenges we ran into
Some major challenges included:
- Integrating real-world hospital discovery APIs
- Managing API key and deployment issues
- Handling database schema migration problems
- Resolving Git and project structure conflicts
- Designing fallback logic when AI services are unavailable
Another major challenge was balancing realism with hackathon feasibility, especially for features like:
- real-time ICU availability
- traffic signal overrides
- live ambulance coordination
Accomplishments that we're proud of
We are proud that we successfully built:
- A fully functional emergency response platform
- Dynamic hospital discovery instead of static datasets
- AI-assisted emergency classification
- Intelligent rerouting and load balancing
- A complete end-to-end deployed application
We are especially proud of transforming a real-world healthcare problem into a scalable software solution within a limited timeframe.
What we learned
Through this project, we learned:
- Full-stack system design
- API integration and deployment workflows
- Backend optimization techniques
- Real-world routing and geospatial logic
- Team collaboration and rapid debugging
Most importantly, we learned how AI and software engineering can be combined to solve meaningful real-world problems.
What's next for ClearRoute
Our future roadmap for ClearRoute AI includes:
- Real-time ambulance tracking
- Live traffic integration
- Real hospital ICU and bed availability APIs
- Predictive emergency analytics
- AI-powered dispatch optimization
- Voice-assisted emergency reporting
- Multi-city and nationwide scalability
Our long-term vision is to evolve ClearRoute AI into a fully integrated intelligent emergency coordination platform.
Future optimization target:
$$ \min (Response\ Time + Hospital\ Overload + Route\ Congestion) $$
to maximize emergency response efficiency and patient survival outcomes.
Log in or sign up for Devpost to join the conversation.