How I Built a High-Performance OSS Vehicle Tracking Ecosystem

YUS (Yelloh Bus) is a real time vehicle tracking ecosystem designed for institutional transportation systems such as college bus networks. The system is built as a multi-client architecture where multiple applications communicate with a centralized backend server to handle route management, driver location streaming, and passenger tracking.

The ecosystem contains several components including,

YUS Route
Used by administrators to create bus routes using real world GPS coordinates. Instead of defining routes manually, the admin travels along the route and marks stops using the device location so the route reflects the actual road path.

YUS Driver
A driver application responsible for continuously streaming GPS coordinates from the driver’s smartphone to the backend server while the bus is operating.

Yelloh Bus
A passenger application that allows users to search buses by number or by source and destination and track the live movement of the bus on a YUS map.

YUS Admin
A web portal used to manage drivers, buses, route schedules, and daily assignments. Administrators can dynamically assign drivers to buses and change schedules when required.

Backend Server
A centralized backend written in Go that manages authentication, route ingestion, real time WebSocket communication, schedule management, and ETA computation.

The system does not depend on dedicated GPS hardware inside buses. Instead, the driver’s smartphone GPS acts as the primary source of location data. When the driver starts a trip, the application establishes a WebSocket connection with the backend server and begins sending location updates at fixed intervals.

Passenger applications create their own WebSocket connections when they start tracking a bus. Each passenger connection is handled independently in the backend using Go routines. When a driver streams a location update, the backend identifies the bus and forwards that location only to passengers who are currently tracking that vehicle.

Routes are created using the YUS Route application where administrators physically travel along the bus path and capture stop coordinates using device GPS. The route data is validated and stored in PostgreSQL along with the stop sequence.

The backend architecture uses PostgreSQL as the primary database for storing routes, stops, buses, drivers, and schedules. Redis is used for session storage and caching frequently accessed data to reduce database load.

In this session, I will explain the architecture of the YUS ecosystem, the internal data flow between drivers and passengers, how WebSocket connections are managed using Go routines, and how the backend is designed to handle multiple driver streams and passenger tracking sessions simultaneously.

1. Why I built YUS and the transportation problems it solves in college bus systems

2. Designing a multi-client architecture for route management, driver apps, passenger apps, and admin systems

3. Creating routes using real world GPS coordinates instead of relying on external routing APIs

4. Streaming live bus locations from the driver’s smartphone using WebSocket connections

5. Managing persistent WebSocket connections between drivers and passengers

6. Using Go goroutines to isolate and handle each passenger connection independently

7. Delivering location updates only to passengers who are tracking that specific bus

8. Implementing dynamic ETA calculation based on real time bus movement

9. Structuring backend services in Go to handle multiple concurrent driver streams

10. Designing the PostgreSQL schema for routes, stops, buses, drivers, and schedules

11. Using Redis for session management and caching frequently accessed data

12. Practical challenges in building and operating a real time vehicle tracking backend system.