Seven

Inspiration

The inspiration for this project came from the need to digitalize and optimize the upsell process that traditionally happens in car rental services. Typically, when you rent a car, a sales agent evaluates your needs in person and may recommend a more luxurious vehicle based on factors like comfort, family size, or road conditions. However, the current digital experience lacks this personalized touch. The challenge was to build a system that could digitally replicate this process while being highly accurate and intuitive. Our goal was to create a digital recommendation system that would recommend cars based on customer preferences and route conditions, such as weather, terrain, and road complexity.

What it does

Seven is a digital car recommendation system that leverages route analysis and user preferences to provide personalized car recommendations at the time of booking or check-out. Here’s what it does: It receives data about the user’s trip (origin, destination, and optional waypoints) and customer preferences (e.g., number of travelers, preferred car type, confidence in bad weather). It calls external APIs (Google Maps, Weather, Elevation) to analyze the route for factors like: Slope and elevation changes (steep roads, mountain passes) Road type (motorway vs. narrow residential roads) Weather conditions (rain, snow, visibility)

Using this information, Seven then generates the most suitable car recommendations, taking into account: Vehicle type based on terrain and road complexity (e.g., SUV for hilly routes, compact for city drives) Preferences (e.g., safety features for a family trip, performance for business travelers) The overall comfort and suitability of the vehicle for the expected trip conditions.

How we built it

The core of Seven was built using the following technologies:

Backend: Written in Kotlin with the Spring framework (for REST APIs) and integrated external APIs:

Google Maps Directions API to retrieve route data (distance, polyline, travel time). Google Elevation API to get elevation profiles (for slope and ascent/descent). OpenWeatherMap API to forecast weather along the route. Overpass OpenStreetMaps API to analyze road types and classify them (motorway, residential, narrow roads).

Data Processing: Implemented logic to calculate the max slope, total ascent/descent, and overall difficulty of the route and built an intelligent recommendation engine that takes both route analysis and user preferences into account to provide personalized car suggestions.

Challenges we ran into

Complexity of integrating multiple APIs
Route data processing
Making it feel “personalized”
Time constraints

Accomplishments that we're proud of

Route-Driven Car Recommendations: We successfully implemented a route-aware recommendation system that takes into account real-world road conditions, terrain, and weather, making the digital experience closer or even better to what a human agent would provide in person.

What we learned

API Integration Best Practices: We gained a deeper understanding of integrating and managing multiple APIs (especially real-time ones like Google Maps and Weather APIs) and handling edge cases such as missing or incomplete data. Complex Data Processing: We learned how to analyze and combine multiple factors (weather, terrain, road type) into a single recommendation and adjust based on different customer preferences. Scalability Considerations: Building a backend that can scale with multiple API calls and handle large user requests efficiently taught us a lot about performance optimization.

What's next for Seven

Web App Integration
User Profile Integration: Adding the ability to create user profiles so that the app can remember preferences (e.g., preferred car types, typical routes) and offer more personalized recommendations over time.
AI-driven Learning: Introducing machine learning models that analyze past customer choices to fine-tune recommendations based on patterns and behavioral data.