Forem: greeny bignose

Fleet Analytics Agent

greeny bignose — Wed, 31 Dec 2025 09:20:55 +0000

This is a submission for the DEV's Worldwide Show and Tell Challenge Presented by Mux

🚗 What I Built

Mobile Ads Car Analytics is a fleet analytics platform designed to monitor, simulate, and analyze vehicles in real time.

Originally built for mobile billboard cars, the system is fleet-agnostic by design and can be easily adapted to any operation that relies on vehicles — including delivery fleets, food trucks, service vehicles, and logistics operations.

The platform tracks vehicle movement on maps, verifies activity or media playback per vehicle, simulates realistic driving routes, and performs cost, trip, and performance analytics using an LLM-powered backend.

The goal is simple, turn vehicle movement into measurable, auditable, and optimizable business intelligence — replacing blind spending, guesswork, and delayed reporting with real-time operational insight.

🎥 My Pitch Video

https://player.mux.com/P5do8601g8OqhFDZTrWWCeTBw93Xwtbk5PXd3hcOyWBA

🧪 Demo

📖 The Story Behind It

Years ago, while stuck in traffic, I noticed mobile billboard cars trapped in congestion.

That’s when the problem became obvious:

Ads don’t reach planned locations on time

Traffic jams and broken roads kill campaign efficiency

Video playback issues go unnoticed

Costs keep rising without clear ROI

Traditional outdoor ads have dashboards.
Mobile ads cars don’t.

This project exists to close that gap.

🧩 What It Does

Core Features

🚘 Car Monitoring

Real-time car movement visualized on a map

Location data streamed from Firestore

Each car tracked independently

🎥 Video Monitoring

Live video frame per car

Label overlay shows which car is being monitored

Videos served from backend as files

➕ Add / Remove Cars

Car label can be auto generated or user inputted

Backend persistence only triggered when:

Cars are added

Places are added

Videos are assigned

Safe removal logic

Backend cleanup if data already stored

🧭 Route Simulation

Uses Google Directions API

Converts user-defined places into real driving paths

Simulated mobile car:

Runs on desktop web or mobile web (portrait & landscape)

Sends live coordinates back to backend

Stored in Tidb for analytics and firebased for realtime monitoring dashboard

📊 Analytics & Intelligence (ADK + Gradio)

Supported Analytics

Total cost per trip (fuel, driver, maintenance — configurable)

Cost per leg

Driver time on the road (per trip & comparison)

Number of trips per car

Cross-car cost comparison

Tabular reports (copy-ready)

Charts for trend & anomaly analysis

Example Prompts You Can Run

Driver cost comparison between cars with different pricing models

Fuel cost per leg with tables or graphs

Trip count per car

Time-on-road comparison between cars

Anomaly detection using non-cumulative cost graphs

This is not hard-coded analytics — it’s LLM-driven analysis over real route data.

🏗️ How We Built It

Tech Stack

Frontend

React

Vite

Google Maps API

Backend

Node.js (Express)

FastAPI (Python)

SQLite (operational data)

Analytics

Google ADK (agent-based reasoning)

Gradio (interactive analytics UI)

Gemini models

Data & Infra

Firestore (real-time tracking)

Google Directions & Geolocation APIs

Docker (everything containerized)

Cloud Run

Artifact Registry

Workload Identity

Everything runs in containers

⚙️ Challenges We Ran Into

ADK agent behavior

LLM responses can be inconsistent

Sometimes partial, sometimes lazy

Required careful agent architecture design

Agent I/O with Gradio

Avoiding swallowed inputs

Ensuring structured outputs for tables & charts

Google Maps Reality Check

Same places ≠ same route

Directions API ≠ Geolocation API

Path variability impacts analytics accuracy

This was mostly trial-and-error — documentation is still thin.

🏆 Accomplishments We’re Proud Of

Generating real analytical reports (tables & charts) from ADK

End-to-end pipeline:

Route simulation → Firestore → LLM analysis → visual report

Turning a “cool demo” into something that actually has business value

This goes beyond hackathon eye-candy.

🎓 What We Learned

When to stop polishing and switch approaches

How LLM behavior directly affects system design

Real-world mapping data is messy and non-deterministic

Making analytics usable matters more than making them clever

🚀 What’s Next

Upgrade into a Mobile Ads Optimizer Platform, not just analytics:

Campaign optimization recommendations

Traffic-aware route planning

Cost vs exposure modeling

Automated anomaly alerts

ROI-driven scheduling

From tracking ads → optimizing ads.

Migrating Tenant Management System From Mongodb To Redis Backend

greeny bignose — Fri, 08 Aug 2025 21:23:06 +0000

This is a submission for the Redis AI Challenge: Beyond the Cache.

cover_image:

What I Built

I built a Tenant Management System, a small but practical intranet application used to keep track of tenants in an apartment complex. It allows the community head to search for tenants and check their status quickly.

This is a live app already being used by real users. For this challenge, I refactored the backend, originally based on MongoDB, and migrated it to Redis Cloud as the primary database.

I also updated some of the application code to better take advantage of Redis’ capabilities.

Application flow

First admin need to login first using his own account on sign in page, and generate token to add operator guy who will be fill, update and search for tenant data in apartment complex. This token will be use by operator to sign up on sign up page and login inside the apps.

Next time operator wants to do their job, just sign in using his/her name and password. Operator can add tenant data, update, search based on name or tower+unit and delete it too. Admin cannot do this directly.

Every time they want to logout just refresh the browser to back to sign in page.

Demo

🔗 Live App: Tenant Management System live on vercel
💻 Frontend GitHub Repo: Frontend github source code
⚙️ Backend GitHub Repo: Backend github source code
▶️ Demo Video: Tutorial how to use demo apps on youtube
📊 Grafana Dashboard: Grafana dashboard depicting Redis Timeseries log data

Default password for admin is admin with password 123456

There are one operator for test with username aa and password 123456

Test Data Used

For this project, I leveraged several real-world and simulated datasets hosted on GitHub to demonstrate and test Redis functionalities effectively:

Operator Name List:
https://github.com/hendram/appsrwbackredis/blob/master/operator-name-list.txt
Contains a list of operator names for testing Redis queries related to operators.

Resident Name List:
https://github.com/hendram/appsrwbackredis/blob/master/residents-name-list.txt
Provides resident names to simulate tenant-related Redis queries.

Timeseries Log for Name Search:
https://github.com/hendram/appsrwbackredis/blob/master/timeseries-log-namesearch.txt
A fake dataset used to demo RedisTimeSeries search queries based on tenant names.

Timeseries Log for Tower & Unit Search:
https://github.com/hendram/appsrwbackredis/blob/master/timeseries-log-towerunitsearch.txt
Demo dataset used to showcase timeseries search queries filtered by tower and unit attributes.

Why Redis Cloud

True Distributed RediSearch
Fully supports distributed full-text search and secondary indexing across all cluster nodes, enabling seamless search on large, sharded datasets.

Automated High Availability and Failover
Built-in automatic failover with multi-availability zone support ensures minimal downtime without manual intervention.

Automatic Horizontal Scaling
Scales elastically with automatic sharding and re-sharding to handle growing workloads smoothly.

Managed Persistence and Backups
Provides automated backups and point-in-time recovery, protecting data with minimal effort.

Enterprise-Grade Security
Features encryption at rest and in transit, role-based access control, and secure network connectivity options.

Comprehensive Monitoring and Alerting
Integrated dashboards and alerts give real-time insight into performance and system health.

How I Used Redis Cloud

In this project, I used Redis Cloud as my primary database, not just for caching, but for real-time data storage, querying, and monitoring.

Redis Features Used:

🧠 RedisJSON: Used to store structured data about each tenant — including fields like nama, tower, unit, and status.
🔍 RediSearch: Enabled fast, full-text search capabilities for fields like tenant name (nama) and apartment unit (towerunit). This allows operators to search quickly even as the dataset grows.
📊 RedisTimeSeries:

I use this module to log how many records are returned by each search query (e.g., on nama or towerunit).

Each operator’s search count result is pushed to a time series key so we can monitor activity over time.

This gives visibility into tenant search behavior — not for performance metrics, but for tracking usage patterns.
📈 Grafana Cloud Integration:

I integrated Redis Cloud with Grafana Cloud using the Redis Data Source Plugin. This allowed me to build a live dashboard that queries RedisTimeSeries directly to show:
- Search query volumes over time
- Which operators are most active
- What kind of search patterns are emerging
☁️ Redis Cloud: As a managed platform, Redis Cloud made it easy to deploy without worrying about infrastructure. It includes Redis modules like RedisJSON and RediSearch out of the box, which helped me replace my previous MongoDB backend completely.

This setup proves Redis Cloud can be used as a complete real-time application backend, not just a cache — and even supports advanced observability when combined with tools like Grafana.