Inside DroveOn: Architecture Overview

In late November 2025, my friend Asrith Tanniru and I started working on DroveOn. As a freelance founding engineer, I was responsible for designing and developing the platform from scratch.

DroveOn is a ride-hailing platform with passenger and driver mobile applications, an admin dashboard, real-time location tracking, route planning, wallet top-ups, digital payments, and document verification. The goal was to build a working system, get it into the hands of the leadership, and iterate quickly.

When you're building an early-stage startup, every technical decision comes with a tradeoff. More infrastructure usually means higher costs, more operational overhead, more deployment complexity. At the same time, cutting too many corners can make future development painful. The challenge was finding a balance between keeping costs under control, moving quickly, and building something reliable enough for production use.

Table of contents

The High-Level Architecture

The following diagram shows the overall architecture of the platform.

High-level DroveOn architecture showing passenger, driver, and admin applications connected to a Go backend through Traefik. PostgreSQL stores business data, Redis handles real-time operations, Cloudflare R2 stores uploaded files, Google Maps provides mapping services, and PhonePe handles wallet top-ups and payments.
High-level architecture of DroveOn showing the interaction between client applications, backend services, mapping providers, object storage, and payment infrastructure.

At a high level, the system consists of three client applications, a back-end service written in Go, PostgreSQL for persistent storage, Redis for real-time operations (more about Redis usage here), Cloudflare R2 for object storage, Google Maps for mapping services, and PhonePe for payment processing.

Why Two Mapping Providers?

One question you might have after looking at the architecture diagram is why DroveOn uses both Google Maps Platform and OpenStreetMap instead of relying on a single mapping provider, the answer comes down to using the right tool for the right job while keeping costs under control.

For the passenger and driver applications, route accuracy is extremely important. ETA calculations, route generation, traffic conditions, and turn-by-turn navigation directly affect the user experience. For these use cases, we rely on Google Maps Platform because of its high-quality routing data, traffic information, and reliable ETA estimates.

The admin dashboard, however, has very different requirements. Administrators are usually reviewing completed rides, investigating issues, or looking at historical trip information. In these scenarios, we do not need live traffic information or fresh route calculations every time a page is opened.

When a ride estimate is generated, the backend stores the route polyline returned by Google Maps. Later, when an administrator opens the trip details page, we simply render the stored polyline on top of an OpenStreetMap map instead of requesting the route again from Google Maps.

This approach gives administrators a visual representation of the trip while avoiding additional routing API calls. Since trip reviews happen far less frequently than ride requests, the savings are not massive, but they are essentially free because the route data already exists. More importantly, it allowed us to keep the admin dashboard functional without increasing our mapping bill unnecessarily.

DroveOn admin dashboard displaying passenger details, assigned driver information, trip distance and duration, and a route preview rendered on an OpenStreetMap map using a stored route polyline from a previous ride estimation.
Route preview in the DroveOn admin dashboard. The route is rendered using a previously stored Google Maps polyline on top of OpenStreetMap, avoiding additional routing API calls.

Direct-to-R2 Uploads

DroveOn requires drivers to upload a significant amount of verification data before they can start accepting rides. This includes profile photos, driver's licenses, vehicle registration documents, insurance documents, and multiple photographs of the vehicle from different angles. Since these files are required for onboarding and verification, the platform ends up handling a large number of uploads.

A common approach is to upload files to the backend first and then have the backend upload them to object storage. While this works, it means every file has to pass through the application server.

For DroveOn, this felt unnecessary. The backend does not need to inspect the contents of the file while it is being uploaded. Its only responsibility is deciding whether the user is allowed to upload a file and where that file should be stored.

Instead, the backend generates a presigned upload URL and returns it to the client. The client then uploads the file directly to Cloudflare R2.

Why Traefik

Since DroveOn's infrastructure runs on a VPS, we needed a way to expose services to the internet, manage HTTPS certificates, and route requests to the appropriate applications. Before adopting Traefik, we were using Nginx as the reverse proxy. While Nginx handled request routing perfectly well, it does not provide automatic TLS certificate management out of the box. To obtain and renew Let's Encrypt certificates, we had to rely on Certbot and periodically manage certificate-related configuration and renewals.

As the platform grew, this started to feel like unnecessary operational overhead. We wanted a solution that could handle routing and TLS management in a single place, which led us to Traefik.

The VPS hosts multiple services, including the backend API, a PostgreSQL database, a Redis instance, the admin dashboard, and other supporting infrastructure. Instead of exposing individual ports or manually managing SSL certificates for each service, Traefik sits at the edge of the system and acts as a reverse proxy. Incoming requests are routed to the appropriate service based on the domain or subdomain being accessed, while internal services remain accessible only within the server's private network.

One of the biggest advantages of Traefik is automatic TLS certificate management through Let's Encrypt. Certificates are issued and renewed automatically, eliminating an entire class of operational tasks that would otherwise need manual attention. For a small team moving quickly, removing routine maintenance work is often more valuable than adding new technology.

Traefik also integrates nicely with Docker. New services can be exposed simply by adding a few labels to a container, without touching reverse proxy configuration files. As the platform evolved and new components were added, this made deployments significantly easier.

Further Reading