Smart Route Planner

Graph-powered logistics and routing, built on Neo4j and Google Maps.

Comment

Inspiration

Our inspiration came from the limitations of standard navigation apps for commercial and logistical use. While great for consumers, they often fail to consider business-critical factors like delivery priorities, vehicle size, or historical road safety data. We saw an opportunity to create a smarter system by leveraging the power of graph databases to find the truly optimal route, not just the fastest one.

What it does

Smart Route Planner is a full-stack mobile application that calculates the most efficient travel path between two points using graph-based logic. Unlike typical GPS apps, our solution uses a Neo4j backend to model the road network, allowing for complex, weighted pathfinding. The Flutter app provides a clean user interface on Google Maps where users can select their origin and destination, choose a travel mode, and view a detailed, road-snapped route along with its estimated distance and duration.

How we built it

The application consists of two core components:

  • Backend: We used Python with the FastAPI framework to build a lightweight and fast API. This server connects to a Neo4j graph database where locations are stored as nodes and roads as weighted relationships. The API exposes a /route endpoint that uses the APOC library's Dijkstra algorithm to find the most efficient path.
  • Frontend: The mobile app was built using Flutter and Dart for cross-platform compatibility. It integrates the Google Maps SDK for the map interface and user interaction. On the backend's response, the app uses the Google Directions API to transform the key waypoints into a smooth, turn-by-turn polyline that's drawn on the map.

Challenges we ran into

Integrating the full stack presented several challenges. We first had to solve networking issues between the Android emulator and our local backend server (the classic 127.0.0.1 vs. 10.0.2.2 problem). We also hit the Google Directions API's waypoint limit, which required us to write logic to simplify complex routes before rendering them. Finally, we debugged several subtle data type mismatches between the Python backend and the Dart frontend to ensure smooth data serialization.

Accomplishments that we're proud of

We are most proud of building a functional, end-to-end application that successfully integrates a powerful graph database with a modern mobile frontend. Seeing the optimized route from Neo4j correctly rendered on the map was a major milestone. The final product is more than a concept—it's a working tool that solves a complex, real-world problem.

What we learned

This project was a deep dive into graph database modeling, full-stack architecture, and API integration. We learned how to represent a physical network as a graph and apply algorithms to derive valuable insights. We also gained practical experience in debugging communication between different technology stacks and handling asynchronous operations in both Python and Dart.

What's next for Smart Route Planner

The future of the project is focused on adding more intelligence and user-centric features:

  • Real-Time Traffic: Integrate a live traffic API to dynamically update the relationship weights in Neo4j for on-the-fly route adjustments.
  • Multi-Stop Optimization: Allow users to input multiple destinations and calculate the most efficient order to visit them (solving the "Traveling Salesperson Problem").
  • User Profiles: Introduce user accounts to save vehicle profiles (e.g., car vs. truck), preferred routes, and delivery history.

Built With

Share this project:

Updates