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.
Top comments (0)