DEV Community

Shubhdeep Chhabra
Shubhdeep Chhabra

Posted on

Ion - A Realtime Ride Coordination Platform

#builtwithmedo

Most motorcycle group rides are honestly chaotic.

Someone always misses a turn.
Someone gets stuck behind a signal.
Half the group disappears after 10 minutes.
And communication while riding is terrible.

People usually rely on:

  • Bluetooth helmet communicators
  • random WhatsApp calls
  • location sharing apps
  • or straight-up shouting at fuel stops

None of those really solve the actual problem.

So during the MeDo hackathon, I decided to build something specifically for motorcycle groups.

That project became Ion.

A realtime platform where riders can:

  • see each other live on a map
  • talk using push-to-talk voice
  • send SOS alerts
  • coordinate rides directly in the browser

No app installs.
No setup headaches.
Just create a ride and share a room code.

The Original Idea

The idea started very small.

I just wanted:

“a simple live map for group rides.”

But once realtime syncing started working properly, the project kept expanding.

Suddenly it became:

  • live GPS tracking
  • realtime member presence
  • voice communication
  • hazard markers
  • ride events
  • emergency alerts
  • automatic ride cleanup
  • mobile-first UI

And honestly, this project became way more technically complex than I initially expected.

Building Realtime Systems Is Weird

The hardest part was not the UI.

It was syncing everything reliably in realtime.

I used:

  • React + TypeScript
  • Vite
  • Supabase
  • PostgreSQL
  • Supabase Realtime
  • WebRTC
  • Leaflet maps

The realtime architecture became the core of the project.

Every rider joining a ride creates a live synchronized session:

  • location updates
  • ride events
  • chat
  • presence state
  • emergency alerts

Everything updates instantly across all connected riders.

One of the best decisions during development was using Supabase Realtime subscriptions instead of manually building websocket infrastructure.

That alone saved an insane amount of time.

The Feature That Surprised Me the Most

Ironically, the most impressive feature was not voice chat.

It was automatic ride cleanup.

Sounds boring, but it solved a real problem.

Imagine this:

  • everyone closes the tab
  • someone loses internet
  • the ride creator disconnects
  • nobody clicks “End Ride”

Without cleanup logic, rides would stay alive forever as ghost sessions.

I explained this problem conversationally while building with MeDo, and it generated:

  • PostgreSQL cleanup functions
  • realtime triggers
  • SECURITY DEFINER helpers
  • recursion-safe logic
  • abandoned ride handling

It even handled edge cases I had not considered:

  • browser crashes
  • temporary disconnects
  • simultaneous exits

One helper function looked like this:

CREATE FUNCTION has_active_members(ride_id_param uuid)
RETURNS boolean
LANGUAGE sql
SECURITY DEFINER
SET search_path = public
STABLE
AS $$
SELECT EXISTS (
SELECT 1 FROM members
WHERE ride_id = ride_id_param
AND connection_status != 'offline'
);
$$;

That entire cleanup system probably saved me weeks of future debugging.

WebRTC Was Both Fun and Painful

Push-to-talk voice communication was another huge challenge.

WebRTC gets complicated very fast:

  • signaling
  • peer connections
  • reconnect handling
  • audio state management
  • browser inconsistencies

Initially I expected this part to completely break the project.

But surprisingly, MeDo helped generate large parts of the signaling flow and realtime communication logic.

Eventually I had working browser-based group voice chat running directly between riders.

That was probably the moment Ion started feeling like a real product instead of a hackathon experiment.

Security Became Important Very Quickly

Once live location sharing entered the picture, security became critical.

I used Supabase Row Level Security heavily throughout the project.

The challenge was making sure:

  • riders only see their own ride data
  • non-members cannot access live locations
  • creators and members have different permissions
  • realtime subscriptions stay secure

A lot of the backend work ended up revolving around secure access patterns and realtime-safe database logic.

This was also where MeDo genuinely helped a lot because debugging RLS issues manually can become painful very quickly.

The Biggest Difference While Building With MeDo

The biggest mindset shift was this:

I stopped describing implementations.

And started describing problems.

Instead of saying:

“Create a PostgreSQL trigger.”

I would say:

“Rides should automatically end if everyone disconnects.”

Instead of:

“Implement websocket subscriptions.”

I would say:

“Everyone should see rider movement instantly.”

That workflow changed how I approached development during the hackathon.

It felt less like prompting an AI for snippets and more like collaborating with an engineer during rapid prototyping.

The Project Grew Faster Than Expected

Ion was built in around a week.

The final project included:

  • realtime GPS tracking
  • push-to-talk voice communication
  • SOS alerts
  • shared ride coordination
  • hazard markers
  • ride timelines
  • realtime presence tracking
  • automatic ride cleanup
  • responsive mobile UI
  • browser-first architecture

Without AI-assisted development, this realistically would have taken me months longer.

Especially the realtime and WebRTC parts.

What I Learned

A few things surprised me during this project:

Realtime UX matters more than fancy UI

If updates lag even slightly, the whole experience feels broken.

Browser-based apps are much more capable now

A few years ago, I would never attempt something like this fully in-browser.

WebRTC is powerful but unforgiving

Once it works, it feels magical.
Until then, it feels cursed.

Describing problems works better than micromanaging implementations

This completely changed how I used AI tools during development.

Final Thoughts

Ion started as:

“What if motorcycle groups had a live coordination layer?”

But it ended up becoming one of the most technically interesting projects I’ve built.

The coolest part was not just shipping features quickly.

It was being able to experiment with ambitious realtime ideas without getting stuck for weeks on infrastructure and implementation details.

That changed the pace of development completely.

And honestly, building this was just fun.

Links

Top comments (0)