Roam

Roam helps new drivers build confidence by turning every route and practice drive into personalized coaching.

Comment

Inspiration

Roam started from something pretty personal. My parents were once in a car crash caused by an inexperienced driver, and that stuck with me. It made me think about how new drivers are expected to just get more hours on the road, but there usually is not much helping them understand what they are actually improving at or whether a route is too difficult for their current experience level.

Back in June, I started working on an idea that could make practice driving more intentional. I wanted to build something that could look at an upcoming route, estimate how difficult it might be, and then use real driving data to help someone improve over time.

That became Roam.

What it does

Roam is an iPhone driving coach built for new drivers.

Before a trip, a driver can enter a destination and Roam analyzes the route to estimate its difficulty. Instead of only looking at distance or travel time, it considers things like traffic, road layout, turns, weather, daylight, and other conditions that can make a route harder for a new driver.

During a drive, Roam uses the iPhone's GPS and motion sensors to track things like speed changes, braking, acceleration, and cornering.

After the drive, it turns that data into feedback and progress tracking. Drivers can see how many miles they have practiced, how much experience they have on faster roads or at night, and how their driving is improving over time.

The main goal is to make driving practice feel less random and more measurable.

How we built it

The iPhone app is built with Swift and SwiftUI.

I used CoreLocation for GPS data and CoreMotion for motion data during driving sessions. A lot of the work went into filtering bad readings and making sure that random sensor noise did not automatically count as bad driving.

For route scoring, I built a backend with Node.js, Express, and TypeScript. It combines data from Google Routes, Google Roads, Open-Meteo, and OpenStreetMap so the score is based on multiple real-world factors.

Roam also uses PostgreSQL, Render, Google Cloud Run, and Clerk for things like data storage, deployment, and authentication.

I also built a Next.js web version of the route-scoring system so people could try the main idea without needing the iOS app.

Challenges we ran into

The biggest challenge was honestly realizing how much work a real app takes.

At the beginning, I thought the hardest part would be building the main features. Once I got deeper into it, I realized almost every feature had its own problems.

GPS data is noisy. Motion data is noisy. A sudden slowdown does not always mean the driver did something wrong. Route difficulty is also really subjective, so I had to think about how to combine things like traffic, road type, intersections, weather, and time of day into something that was actually useful.

It got pretty intimidating at times because every time I finished one part, I would find three more things that needed to be improved. Roam ended up becoming a much bigger technical project than I expected.

Another challenge was distribution. I do not currently have the budget for an Apple Developer Program account, so I was not able to release the app through TestFlight or the App Store.

Instead, I made a video demo of the iOS app and built a basic website for the route-scoring system so the project could still be tested and demonstrated.

Accomplishments that we're proud of

I am most proud that Roam became more than just an app mockup.

It has a working native iOS app, real GPS and motion tracking, route difficulty scoring, driving history, progress tracking, backend services, authentication, and a database. It also supports things like shared routes, Live Activities, and a CarPlay view.

I am especially proud of the route scoring because it is not just a random number. The system tries to explain what actually makes a route harder and gives the driver useful context before they start.

For me, the biggest accomplishment was taking an idea I had in June and actually turning it into a full system with multiple parts working together.

What we learned

The biggest thing I learned is that building something for the real world is very different from building a small coding project.

With Roam, I had to deal with imperfect data, multiple APIs, backend services, device sensors, edge cases, and user experience all at the same time.

I learned a lot about iOS development, APIs, backend architecture, databases, deployment, and working with real-time data.

I also learned that the best solution is not always the most complicated one. A big part of building Roam was figuring out how to take a lot of information and turn it into something simple enough for a new driver to actually understand.

What's next for Roam

The biggest next step is improving Roam with more real-world driving data.

I want route scoring to become more personalized over time. For example, a highway route might be difficult for someone who has only driven a few hours, but easy for someone who already has a lot of highway experience.

I also want to improve the driving feedback, expand route comparisons, improve CarPlay support, and eventually add better ways for parents and new drivers to look at progress together.

If I am able to get an Apple Developer account, I would also like to release Roam through TestFlight and eventually put it on the App Store.

Roam started as a simple idea: help new drivers understand what they are ready for and get better with every drive. That is still the main goal.

Built With

Share this project:

Updates

Submission history