Lap time tells you what happened.
It doesn't tell you why.
A telemetry tool for track-day drivers - your phone, your GoPro, your data. Compare laps, inspect speed traces, racing lines and sector deltas, without a professional race-engineering setup.
A developer and motorsport enthusiast.
I'm Paweł, software developer, based in Poland. Like a lot of people in motorsport, I was the kid who drew cars in his notebooks and pulled the motorbike magazines off the kitchen table. That obsession never quite left.
Some around 2014, I took part in my first competition, driving a Nissan Micra K11 1.3, in the competition "KJS" (Polish version of autocross, the cheapest way to be on a stopwatch). Then I took part in several competitions amateur gravel rallies. That was over twelve years ago, and I've been chasing the next track in some form ever since.
Then a Logitech wheel, and I was gone.
Work, money, life, the rally car had to go. For about five years I drove almost exclusively on simulators. It started with the cheapest Logitech wheel I could find and grew into a serious setup.
Along the way I started a sim racing blog (in Polish). I won a 12-hour endurance at Le Mans in the GTE class with the Simracing Poland team, and went to SimExpo in Germany twice. The community I met there took motorsport seriously enough to talk about apex speed and brake bias on a Wednesday evening.
That's where I learned more about cornering technique and reading data than I ever had behind a real wheel. It's also where I started wanting that same data on a real circuit.
Then I bought the Clio.
The sim hours pulled me back to tarmac. In 2020 I picked up a Renault Clio 3 RS and spent over a year prepping it for the track - cage, seats, suspension etc.
Since 2021 I've been racing in the "Track Masters" Central European Time Attack Cup. Roughly twenty circuits so far, like Red Bull Ring, Hungaroring, Nürburgring, Lausitzring, Slovakia Ring, Brno, and my favourite, Most.
I also had the opportunity to take part in a 4-hour endurance race. The Sundays got a lot less Sunday.
I was missing a tool. So I built one.
Once I started thinking about technique on real circuits the way sim racers do - apex by apex, brake point by brake point - I went looking for the data tools. Phone apps. Pro loggers. Each one had something missing: clunky sync, file conversions, desktop software bound to a specific laptop, or analysis screens that assumed you had a race engineer next to you.
So I started building one for myself. Evenings, after work. What began as side-project tinkering turned into a four-year habit. Eventually I hired some developers to help bring the project to life. The thing got serious.
Vetkuro is now in public beta. I'd really like your honest opinion on it - that's part of why I'm sharing it here.
What came out of it
Three pieces, one workflow.
Vetkuro records telemetry and allows you to analyze data that lap time can't: was I braking later, carrying more speed through the apex, taking a different line, or losing time on corner exit.
Mobile app
Records every track session from your phone. Detects laps and sectors, ties in OBD-II, BLE GPS, GoPro and heart-rate sensors. Works on iOS and Android.
Web analyzer
Where you actually see why one lap was faster - speed traces, racing lines, sector deltas, channel overlays. Everything aligned by distance, not just by time.
Vetkuro hardware
An ESP32-based telemetry collection device with high-rate GPS and OBD-II support.
Early prototype - not yet shipping.
See it on a real session
An on-track test of Vetkuro at Silesia Ring.
What you can do with it
The questions Vetkuro answers after every session.
- Where did I lose time compared to my best lap?
- Did I brake earlier or later this time?
- Was my corner exit faster?
- Did I take a different line through the apex?
- Which sector actually cost me the lap?
- How did engine RPM, throttle and brake input change between laps?
It does this from your phone, optionally connecting to higher-rate BLE GPS, OBD-II adapters, GoPro footage and BLE heart-rate sensors. Sessions sync to the cloud and live in the web analyzer for as long as you want.
How a session moves through the system
From your phone in the vehicle to a lap comparison on your laptop.
Mobile app captures GPS, IMU and sensor data during the session.
Raw session files upload when connectivity allows.
Backend detects laps and sectors, normalises telemetry channels.
Mobile and web apps compare laps by distance, speed, sector and racing line.
Engineering
Engineering notes
The hard part isn't drawing a lap on a map. The hard part is making noisy, multi-rate, imperfect telemetry useful enough to change how you drive on the next outing. Below are the problems we ran into - and what each one enables in the product.
Lap detection from noisy GPS
A track isn't a polyline on a map. To split a session into laps Vetkuro needs start/finish lines, sector gates, lap direction, and layout variants - closed circuit, point-to-point, hill climb. Then it has to detect when a noisy phone GPS trace actually crossed those lines, without producing false laps from a single bad sample.
Our lap time calculation algorithm was compared with official radio measurements on the tracks.
Distance-based lap comparison
Two laps almost never share timestamps. To compare braking points, apex speed or corner exit, every channel has to be aligned along distance around the track instead of time. That's what makes it possible to ask "at the same point on track, which lap was faster, and where did I lose time?" and read the answer directly off the trace.
Regardless of the travel time, a comparison over distance usually gives a better overview of the situation.
OBD-II beyond a Bluetooth pairing
ELM327 isn't a real BLE protocol - it's serial-over-BLE with AT commands. Supporting OBD-II properly meant scanning each ECU for the PIDs it actually answers, handling multi-frame responses, and filtering the result down to channels worth showing on a lap. The hard part wasn't the Bluetooth pairing - it was everything after.
Live engine data on every lap with most off-the-shelf adapters, no per-car configuration.
Multi-rate telemetry
A session can contain 25 Hz GPS, irregular OBD-II values, phone IMU, BLE heart-rate and GoPro frames - each with its own frequency, latency and accuracy. The hard part isn't storing samples. It's getting them to line up on the same lap, the same distance axis and the same chart, so a driver can read them in one place.
Adding a new sensor type doesn't mean a new chart screen in the analyzer.
One schema, firmware to web
The same telemetry data has to travel from firmware on the dedicated logger, through the mobile recorder, into the Go backend, and out to the web analyzer. Instead of four hand-written copies that drift apart, we use Protobuf as the single source of truth and generate TypeScript and Go types from it.
Add a channel once, it shows up in firmware, mobile, backend and the web analyzer.
Processing pipeline
Sessions arrive as raw uploads from mobile, get processed by Go workers into laps, sectors and normalised channels, and land in a channel-based time-series schema where any source-channel pair is queryable for overlays. Video footage runs through its own pipeline so a session can replay synced video alongside its data in the analyzer.
Old sessions can be re-processed when the algorithms improve.
Hardware · early prototype
A logger for vehicles where the phone isn't enough
Phone GPS and Bluetooth dongles cover most amateur use cases. They don't cover all of them - fast tracks, long stints, older vehicles with non-standard diagnostics.
- ESP32, 25–30 Hz GPS
- BLE link to the phone - same app, no extra setup
- Direct CAN / OBD pickup, including older protocols dongles often skip
- Lives in the vehicle between sessions
Most consumer GPS loggers ignore CAN. Most CAN tools ignore consumer drivers. This is the gap.
Roadmap
What's next
None of this is on the page yet - that's deliberate.
Deeper analysis & video overlays
Corner-by-corner analysis (braking points, apex speed, exit traction), predictive lap and advanced sector overlays, and a more open data story: possibility to generate video overviews of the best laps.
Hardware out of prototype
Shipping Vetkuro device out of the prototype run, broader OBD-II coverage, and more reliable BLE connectivity. The goal is to have the hardware available for purchase, but the timeline depends on how the next round of testing goes.
Where we honestly are
Public beta, started April 2026. Here's the unvarnished snapshot.
What works today
Mobile recorder on iOS and Android, sessions syncing to the cloud,
and a web analyzer that's where drivers actually compare laps.
External devices integrate over BLE - high-rate GPS, OBD-II, GoPro,
heart-rate monitors.
We have around 150 users, over 100 recorded sessions on real tracks, growing backlog of feedback and feature requests.
What it isn't (yet)
Our analysis shows the data, but it doesn't yet pinpoint where the driver is losing time. That's something we want to improve - it would make telemetry easier for everyone. Simple video overlay generation is also high on the list for a large group of drivers.
Built for drivers
Track-day drivers, amateur racers, karters, motorcycle riders, driving instructors, and curious builders interested in GPS and sensor fusion. Race engineers and teams looking for a lighter setup are welcome too.
If you read this far - I'd really like your feedback
The workflow, the edge cases on tracks I haven't tested, which channels are actually useful, what device support you wish worked, whether the demo even made sense - everything is on the table. The harsh feedback especially. That's how this gets better.
Or just grab the app: