I Built India's Missing Local Transport App — Then Abandoned It for 5 Months

Drishti Tripathi — Fri, 29 May 2026 10:01:38 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

AutoConnect is India's inclusive local transport app — connecting
passengers with auto rickshaws, e-rickshaws, cycle rickshaws, and
single-engine bikes through a single mobile-first platform.

I originally built AutoConnect in December 2025 as a personal project.
I had a clear vision — a transport app built specifically for India's
local vehicles that bigger apps ignore. I designed the full UI, built
every screen, and made it look like a real app. But it was just screens.
Every button was simulated. The README literally said "No backend
integration." I ran out of time, lost momentum, and abandoned it.

5 months later, this challenge made me finally finish what I started.

AutoConnect now has a real Spring Boot backend, a live database, GPS
location detection, real document upload, and a complete ride flow —
passenger requests a ride, driver sees it in real time, accepts it,
and the passenger gets confirmed. All deployed and live.

This project means something to me personally — India's local transport
ecosystem is fragmented and most apps ignore auto rickshaws and
e-rickshaws completely. AutoConnect is built specifically for that gap,
with an accessibility-first UI designed for users with low digital literacy.

Demo

🔗 Live App: https://auto-connect-mobile-app.vercel.app
🔗 Backend API: https://autoconnect-backend-production.up.railway.app
🔗 Frontend Repo: https://github.com/DrishtiTripathi2230/AutoConnect-Mobile-App
🔗 Backend Repo: https://github.com/DrishtiTripathi2230/AutoConnect-Backend

How to test the full flow:

As a Passenger:

Open the live app → Select "I'm a Passenger"
Sign up with your name and phone number
Enter pickup location (or use GPS) and destination
Click "Find Rides" — this creates a real ride in the database

As a Driver (open in a different browser):

Select "I'm a Driver" → Sign up with vehicle details
Upload documents → Submit
See the passenger's ride request appear on your dashboard
Click Accept — passenger gets confirmed instantly

The Comeback Story

Where it started

In December 2025, I built AutoConnect as a personal project. I had a
clear vision — a transport app built specifically for India's local
vehicles. I spent days designing every screen, every flow, every color.
The UI looked like a real app.

But it was completely hollow.

No backend. No database. No API calls. Every button navigated to a
hardcoded screen. The README admitted it openly:

"Design Focus: UI/UX (No backend integration)"

"This project is a UI/UX prototype intended for design demonstration"

I ran out of momentum and abandoned it for 5 months.

Here's the proof — every commit is from December 23, 2025:

What I changed

When I saw the GitHub Finish-Up-A-Thon challenge, I knew immediately
which project to revive.

Here's everything I built in May 2026:

Backend (built from scratch):

Spring Boot REST API with Driver and Ride endpoints
H2 in-memory database with JPA entities
Driver registration, availability, and ride matching
Ride lifecycle — REQUESTED → ACCEPTED → COMPLETED
Deployed on Railway

Frontend integration:

Connected all UI screens to real backend APIs
Real GPS location detection using browser Geolocation API
Phone number validation (10 digits, numbers only)
Name validation (letters only)
Real file upload for driver documents
Deployed on Vercel

The moment it became real:

When I entered pickup and destination, clicked Find Rides, and saw
"✅ Backend Connected | Ride #3" appear in the corner — that was the
moment 5 months of abandoned work finally felt worth it.

Before vs After

	Before (Dec 2025)	After (May 2026)
Backend	None	Spring Boot + Railway
Database	None	H2 with real data
Interactions	Simulated	Real API calls
Location	Hardcoded	Real GPS
Validation	None	Phone + name + docs
Deployment	None	Vercel + Railway

My Experience with GitHub Copilot

GitHub Copilot was a genuine partner in finishing this project, not
just autocomplete.

How Copilot helped

The most impressive moment was when I asked Copilot to add fare
calculation for all vehicle types. Instead of just writing a function,
Copilot:

Read my entire codebase automatically — it scanned PassengerHome.tsx and VehicleSelection.tsx before writing a single line
Identified a problem I hadn't noticed — fare rates were duplicated across two components
Created a shared utility file — centralized the fare logic so both screens use the same calculation
Updated 3 files simultaneously — +27 lines, clean and consistent

This wasn't just code generation. Copilot understood the architecture
of my project and made a better decision than I would have made alone.

What I learned

Copilot works best when you give it context. Asking it to "add fare
calculation" while having the relevant files open gave it everything
it needed to make smart decisions about where the code should live.

For a project like AutoConnect — with multiple interconnected components
— that architectural awareness saved me significant debugging time.
— AutoConnect isn't perfect — but it's real now. And that's the whole point of finishing things.

DEV Community: Drishti Tripathi