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

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:

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

As a Driver (open in a different browser):

1. Select "I'm a Driver" → Sign up with vehicle details
2. Upload documents → Submit
3. See the passenger's ride request appear on your dashboard
4. 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

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:

1. Read my entire codebase automatically — it scanned PassengerHome.tsx and VehicleSelection.tsx before writing a single line
2. Identified a problem I hadn't noticed — fare rates were duplicated across two components
3. Created a shared utility file — centralized the fare logic so both screens use the same calculation
4. 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.