Inspiration
If you're a college student, you know the math we do at the pump. You pull in with the light on, watch the numbers climb, and quietly decide whether this fill-up means skipping takeout this week. Then you drive ten minutes down the road and see gas 30 cents cheaper.
For a lot of us at UCF, driving isn't optional. It's how we get home for the holidays, to internships and jobs, to visit family, or on a road trip with friends that we saved up for. And every time, we fill up the same way: wherever we happen to be when the tank gets low. That's almost never the cheapest place.
We wanted to change that by building a real plan for the whole drive: where to stop, how much to buy, and what you'll save.
What it does
You enter where you're starting, where you're going, your car's MPG, tank size, and how much gas you have right now. SaveGas looks at the gas stations along your route and builds a fuel plan for the whole trip:
- Where to stop, shown as pins on a map of your route
- How much to buy at each stop, and what it'll cost
- How full your tank will be when you arrive at each stop and when you leave
- Your total fuel cost for the trip, and how much you saved
It never lets your tank drop below a quarter, and it only picks stations along your route. Sometimes the smartest move is to fill up before you even leave, even with half a tank, because the gas near you is cheaper than anything on the highway.
How we built it
We built SaveGas as a team of four for our Girls Who Code at UCF project. Here's how each part came together:
- Design: We started in Figma, designing the logo and every screen: the home screen, the trip form, and a Tesla-style results screen. We used Figma Make to prototype how the app looks and feels.
- The app: We built the mobile app with React Native and Expo, and tested it on our own phones with Expo Go.
- The planner: The core algorithm was written first in Python, with tests, then ported to TypeScript so it runs right on the phone.
- The backend: We built a FastAPI server with a
/planendpoint, so the planner can later run on a server when we add live data. - The map: We used react-native-maps to draw the route and drop a pin at each recommended stop.
Challenges we ran into
- Getting Expo Go to run. This was our first mobile app, and just getting Expo Go to load on a phone took hours of debugging in the terminal.
- From web to mobile. Figma Make generates React code for websites, not React Native, so we rebuilt each screen in Expo to run on phones.
- Python doesn't run on phones. Our gas-stop planner was written in Python, which Expo Go can't run, so we ported it to TypeScript.
- No free gas price data. OpenStreetMap shows where stations are but not their prices, so we used sample prices along Florida's Turnpike.
- Learning Git as a team. Errors like
refusing to merge unrelated historiestaught us to usegit clone, branches, and pull requests. - Coding as beginners. Some of us came in knowing only beginner Python and SQL, including a business major who took on the front end.
- Finding time. Balancing the project with classes, work, and other commitments meant planning carefully and splitting the work.
Accomplishments that we're proud of
- Our first mobile app. None of us had built one before, and now it runs on our own phones.
- A calculator that runs on the phone. The planner does real math: change your fuel level or MPG, and the stops and costs update.
- Design to working app. We took our Figma designs all the way to working React Native screens.
- Everyone shipped something new. From a business major learning front-end tools to first-time React Native developers, each of us built something we never had before.
What we learned
- Mobile development. How to build with React Native and Expo, and how it differs from building for the web.
- New tools. How to use Figma, GitHub, and Expo Go, many of them for the first time.
- Translating code. How to turn Figma Make code into React Native, and Python into TypeScript.
- APIs. How apps talk to servers and outside data, and why live gas price data is so hard to get.
- How gas prices work. How much prices vary along a route, and how much planning ahead can save.
- Teamwork. How to split up work, use Git together, and make the most of limited time.
What's next for SaveGas
- More gas stations. Grow our station database beyond Florida's Turnpike so SaveGas can plan trips anywhere.
- Export your route. Send your planned route and stops to Google Maps, Apple Maps, or Waze to navigate turn by turn.
- Live gas prices. Pull real, up-to-date prices instead of sample ones, so every plan reflects what you'll actually pay.
- Any start and destination. Plan real routes for any trip, not just our demo routes.
- Pick your car from a list. Choose your make and model to fill in MPG and tank size automatically.
Built With
- expogo
- fastapi
- figma
- react-native
- typescript