How Did I Start the Project?

Website Link

At first, my goal was simply to explore new technologies. I initially aimed to build a small tool that could record and replay VDA messages. I planned to make a web-based application, and that’s how the journey began. The idea was simple: one backend and one frontend app, saving data with timestamps into a database.

During July–August 2024, I started experimenting with different databases. After reviewing many options, I found that the best solution (for now) for storing JSON data was TimescaleDB. At first, it seemed a bit slow, but once I started using features like hypertables, I saw a significant performance boost.

I also tried various ways to write data into the database, such as Telegraf. But then I switched to a more DIY mindset and developed a backend application in Rust. This app connects to an MQTT broker using provided configurations, records incoming data, and simultaneously sends it to the frontend via websocket. Everything went as planned. I even recorded a video and shared it on LinkedIn. You can watch the video here.

How Did It Evolve Into a Platform?

After building the app in about two months, new ideas started popping up. Since we’re already storing the data, why not analyze it too? We have tons of raw data — are we just going to replay it?

From the beginning, my goal was not to monetize this project (still isn’t — it will be entirely free-to-use). So I decided to expand it.

Over time, the idea turned into a platform: a place where you can monitor your vehicles, orders, and related analyses/statistics. The goal is to detect any issues in your fleet early and optimize accordingly. Also, since the system isn’t tied to any specific fleet manager, you gain more control over your data privacy.

For this reason, I moved away from a purely local frontend and added a membership system. But all data is still stored locally — just like how we save VDA messages into TimescaleDB.

Setup is simple: you create an account through AdvTool, then launch the project using a docker-compose file. Two separate applications running inside Docker collect and analyze the data and write results to your own database.

Initially, I considered running Supabase locally, but later discovered PostgREST. PostgREST is a great tool that provides an automatic RESTful API when connected to your PostgreSQL database. It also supports the OpenAPI standard, which makes frontend work a lot easier. You can use the OpenAPI file to auto-generate frontend client code.

In the early stages, I accessed the database directly from Rust using tokio without any ORM. But when I faced challenges around managing updates, I decided to switch to Diesel in January 2025. The system now runs stably with Diesel.

I wanted to filter data by time intervals — for example, calculating average values within a given time range to extract meaningful insights. I used PostgreSQL functions for that, which significantly improved performance.

To distribute the Rust apps, I wanted an easy approach. Since Rust is a compiled language, the source code isn’t directly exposed. I created a Dockerfile for each application and pushed the images to Docker Hub. That way, you can set everything up easily using docker-compose.

Frontend

I chose Vue 3 for the frontend. For the landing page and documentation, I wanted to try something new. After a short search, I went with Next.js and found a theme supported by ShadCN. I integrated a separate design for the landing page, which I believe gave it a professional look. Using the same theme in the dashboard reinforced the feeling of a unified product.

The dashboard part required serious effort. Even with libraries, a lot of the work still falls on you. I looked into whether Supabase provides OpenAPI — couldn’t get a clear answer. Luckily, PostgREST does, and you can easily use all APIs with type definitions on the frontend.

After trying a few charting libraries, I found the best solution. First, I tried the one provided by ShadCN-Vue, but it didn’t perform well with large datasets. Then I moved to ApexCharts — I liked the features but faced issues with update methods. Finally, I discovered Chart.js. It provided the best balance of performance and ease of use, plus it’s highly flexible thanks to its plugin support.

About ShadCN

I want to mention ShadCN specifically. Traditional UI libraries ship all components in one minified bundle, which makes customization difficult — and you include components you never use. ShadCN changes that completely: you only include the components you need via CLI. While originally built for React, the Vue version is also very solid. I’m quite happy using it both visually and structurally in the project.

AI Support

I didn’t use any AI (except Copilot) in the beginning. Later, I started using Cursor, which drastically sped things up. But like any tool, AI should be used in moderation. Relying entirely on AI to write code can disconnect you from your own project. For example, I developed a page with Cursor, but it took me forever to tweak a small thing later — because I didn’t fully understand the code.

So I now use AI in small, controlled steps: I clearly define what I want to do, use Cursor to implement it piece by piece, and manually review each line. If Cursor adds 500 lines of code at once, that’s a red flag — time to pause and rethink.

What’s Still Missing?

There are still many improvements I’d like to make:

• We can analyze data per vehicle and order, but fleet-wide analytics are still lacking.
• On the security side, PostgREST currently only works over HTTP — HTTPS is essential.
• When TimescaleDB reached around 150GB, I experienced some data loss. Not sure if it was due to the database or the data stream. I’m trying to reproduce the issue.

How Do I Test?

At home, I turned an old computer into a local server. A small script continuously generates VDA5050 orders and simulates them. Having a virtual fleet was super exciting at first. I monitor all the results through AdvTool.

What’s Next?

My plan is to provide a form where individuals or companies can request an account. Since all data will be stored locally, users will be fully responsible for their data. This project will remain non-commercial, and I’d love to continue improving it based on user feedback. But I definitely need more time to reach that point.

Technologies I Use

• Supabase
• InfluxDB (deprecated)
• Telegraf (deprecated)
• PostgREST
• TimescaleDB (PostgreSQL)
• Diesel
• Rust
• Docker Hub
• ShadCN
• Chart.js
• ApexCharts (deprecated)

You can go to the site from this link: advtool.one