BetterMap

Looking to better plan your trips? Get the most efficient route to save time!

Comment 1

BetterMap 🗺️

The smarter way to plan your journey

Inspiration

We've all been there — you have five errands to run, three stores to hit, and a mental list of items scattered across your notes app, your memory, and a crumpled receipt in your pocket. Navigation apps tell you how to get somewhere, but none of them help you figure out where to go first, what to grab when you get there, or how to make the whole trip actually efficient.

That frustration is what sparked BetterMap. We wanted to build something that didn't just route you from point A to point B, but understood the purpose behind every stop. Something that felt less like a GPS and more like a brilliant travel companion who had already done all the thinking for you.

We were also inspired by the way people naturally talk about their trips:

"I need to swing by Food Lion for some tomatoes and cereal, then hit Home Depot for screwdrivers and drywall, and then head home before going to my cousin's place."

No app understood that sentence. So we built one that does.

What It Does

BetterMap is an intelligent trip-planning application that:

  • Parses natural language — type or speak your entire trip plan in plain English, and BetterMap breaks it down into destinations, purposes, and shopping lists automatically.
  • Builds the optimal route — using real-time traffic data, BetterMap calculates the most time-efficient order to visit every stop.
  • Tracks your items per store — for each destination, BetterMap attempts to locate your needed items by pulling aisle and product data directly from the store's website. If no website is available, it lets you know clearly.
  • Shows real-time arrival estimates — not just trip duration, but exact finish times. If you leave at $t_0 = 1\text{:}30\text{ PM}$ and your trip takes $\Delta t = 40$ minutes, BetterMap tells you:

$$t_{\text{finish}} = t_0 + \Delta t = 1\text{:}30\text{ PM} + 40\text{ min} = 2\text{:}10\text{ PM}$$

  • Remaps on demand — don't like the suggested route? Hit Remap to cycle through alternative routes, ranked from most to least efficient.
  • Filters for every journey type — scenic routes, avoid tolls, avoid highways, suggested stops, and food hotspots along the way.
  • Keeps the UI minimal — while navigating, the only thing that ever surfaces on screen is what you asked for. No clutter, no noise.

How We Built It

BetterMap was built as a full-stack web/mobile application using the following stack and APIs:

Frontend

  • React Native for cross-platform mobile UI
  • Tailwind CSS principles for minimalist, clean design
  • Black background with purple route overlays rendered via MapBox GL JS
  • Animated route lines on the home screen to showcase the app's personality before you even start a trip

Backend & APIs

  • Google Maps Platform — Directions API for routing, Distance Matrix API for time estimation, Roads API for real-time traffic
  • Google Places API — location search, ratings, hotspot discovery
  • Web Speech API — browser-native voice input for the mic feature
  • Kroger API / Walmart Open API — product and aisle lookup per store
  • Custom web scraper — for stores without a public API, we built a lightweight scraper to pull item/aisle data from store websites
  • Geolocation API — to anchor the trip to the user's real-time position

Route Optimization

The core routing logic uses a nearest-neighbor heuristic approximation of the Travelling Salesman Problem (TSP). Given $n$ destinations, the brute-force solution has complexity:

$$O(n!) \quad \text{(exact TSP)}$$

We use a greedy nearest-neighbor approach that runs in:

$$O(n^2)$$

Which is fast enough for typical trip sizes $(n \leq 20)$ while still producing routes within a reasonable approximation of optimal. When the user hits Remap, we surface the next-best permutation from a pre-ranked list of candidate routes sorted by estimated total time $T$:

$$T = \sum_{i=1}^{n} d(s_i, s_{i+1}) \cdot v^{-1}$$

Where $d(s_i, s_{i+1})$ is the distance between stops and $v$ is average speed adjusted for real-time traffic conditions.

Challenges We Ran Into

1. Natural Language Parsing Getting the app to correctly extract destinations, purposes, and item lists from a single freeform sentence was harder than expected. We went through multiple iterations of prompt engineering and NLP parsing before it reliably handled messy, real-world input.

2. Inconsistent Store Data Not every store has a clean API or even a searchable website. Aisle data is notoriously unstructured — what one store calls "Aisle 4B" another calls "Dry Goods Section." We had to build normalization logic and fallback messaging when data simply wasn't available.

3. Balancing Minimalism with Functionality BetterMap does a lot, but we were committed to showing as little as possible on screen at any given moment. Deciding what to surface, when, and how — without overwhelming the user — required constant design iteration.

4. Real-Time Time Estimation Static ETAs are easy. Real-time ETAs that update as traffic changes, as stops are completed, and as the user edits the route mid-trip — that required careful state management and live API polling without killing battery life.

Accomplishments That We're Proud Of

  • Successfully parsing complex, multi-destination, multi-item natural language prompts with high accuracy
  • Building a Remap system that gracefully degrades route efficiency while still feeling intentional and useful to the user
  • Pulling live aisle/item data from real store websites and surfacing it natively inside the app
  • Achieving a genuinely minimalist navigation experience — when you're driving, the screen stays clean unless you asked for something
  • The home screen — we're proud of how it looks. Purple routes glowing on a black map background, before the user has even typed a word, immediately communicates what BetterMap is about

What We Learned

  • Natural language is messy, and users don't speak in structured data — your app has to meet them where they are
  • Route optimization is a well-studied problem, but real-world routing (traffic, store hours, task time) adds layers that pure algorithms don't account for
  • Great UX is mostly about what you remove, not what you add
  • APIs are only as reliable as their underlying data — always build graceful fallbacks
  • Voice input is underutilized in productivity apps and users genuinely love it when it works well

What's Next for BetterMap

  • Collaborative trips — share a trip plan with others so multiple people can contribute stops and items in real time
  • Store membership integration — connect your loyalty cards so BetterMap can factor in personalized deals and coupons along your route
  • Smart scheduling — integrate with your calendar so BetterMap can automatically suggest the best time to leave, not just the best route
  • Offline mode — pre-download route data so BetterMap works in areas with poor connectivity
  • Expanded retailer database — deeper integrations with more store APIs for richer item and aisle data
  • AI trip memory — learn your habits over time, so BetterMap starts suggesting trips before you even ask

BetterMap — because the journey should be as good as the destination.

Built With

Share this project:

Updates