Career
- Platform maintainer and release owner for cellular GNSS tracker firmware: about 140 release tickets driven (firmware and app), base updates across about 15 customer branches. alporak.com/work/the-job
how: When it was not the firmware
This is the work around the code at Teltonika since 2022. In that time I’ve made 903 commits, implemented about 567 tickets, investigated about 313 more, and driven about 140 release tickets.
Tickets by my role, 2022–2026 On the platform maintainer rotation, I answer the questions that QA and support bring to the firmware team. Plenty of those end with “the firmware is fine”. That answer only counts if there’s data behind it.
Releases
I own releases on the tracker platform: five base lines, about 15 customer branches, experimental builds and mobile app builds. Each release comes with notes telling QA what to test. I carry base updates and cherry-picks across the customer branches, and I cancel and redo a release when QA results call for it. One base release carried 53 tickets. I also added a CI check that blocks a customer release if its firmware entry is missing.
Support
I’ve answered about 150 support cases with a root cause found in device logs.
In one case an ACK went missing. I rebuilt the test traffic against my own TCP server. The device sent two messages, and the server received them as one 1,388 B block. The server’s parser was the problem, and I suggested splitting messages by their length field.
In another, a reported 1.5–2 minute clock error wouldn’t reproduce on two modem types and many SIMs. The evidence pointed to the operator’s network time.
Networks and vendors
A carrier NAT that forgets devices after 15 quiet seconds became half of another write-up. One escalation covered thousands of devices on one network, and forcing 4G with manual band selection solved it.
When a problem might be inside the modem, I build the case. I captured the modem’s internal logs on the bench and sent them to the vendor. One case took months of back and forth, and the fix reached the customer in a base update. I also turn vendor advice into firmware work, like a work item for faster switching between 2G and 4G.
Estimates
I’ve written at least 25 research documents with effort estimates, from 30 h to 332 h. The dual APN estimate came to 116 h. It showed that only one TLS session fits in RAM, and the customer accepted a design built around that.
Conclusion
About 150 support cases with a root cause, about 140 release tickets, at least 25 estimates, and about 567 tickets implemented.
“Not our bug” is a finding too, and it needs the same proof as a fix: a rebuilt test, a trace, a modem log.
- Redesigned modem recovery and the RTOS task watchdog as one staged recovery, tested on five modem types. alporak.com/work/modem-recovery
how: Hung modems that recover on their own
Trackers in the field lost data whenever their modem stopped working. Nobody is around to power-cycle a tracker in a vehicle, so the firmware has to notice and fix it by itself.
Restarting a modem is the easy part. The hard part is knowing when to do it, how hard to push, and making sure there’s no path where the tracker just gives up.
Escalating step by step
Recovery is driven by how long the tracker has sent no data. At 10 minutes it restarts the modem radio with
CFUN. At 20 it resets the modem through its hardware pin. At 30 it resets the whole device. Cheapest step first. I tested it on five modem types.One watchdog instead of two
I wrote the user story to merge this recovery into the old watchdog and remove the duplicate code: 137 lines added, 183 removed. The watchdog period now grows with the configuration, so a tracker that sends rarely isn’t mistaken for a hung one. Only one recovery can fire per 10 minutes. I documented it with flowcharts and a table for every counter.
What the merge broke
The merge led to about 12 follow-up bugs, and I fixed them. The watchdog counted per server, even though all servers share one modem, so I made it one counter. A
CFUNrestart was clearing the no-GPRS counter. A record period longer than the watchdog period caused pointless modem restarts. And one modem type has no pin reset, so that step only runs where it’s supported.Short drops and deep sleep
A short network drop went unnoticed, so the tracker waited out a long timeout and took 1 min 10 s to react. I added a “suspicious” state: after a short drop, the next communication error starts a full recovery right away.
For LTE-M I built a step-by-step sequence: check registration with
CEREG?, check and reactivate the data context, then restart the radio. I made these work in deep sleep too, where records had been arriving 6–7 minutes late instead of 2.A scan that could strand a tracker
The operator scan ignored errors, so an empty result left the tracker stuck for good. On top of that, a dropped data context banned the operator, started no new search, and reset the recovery counter.
Now the scan result is checked, and retries happen at 30, 60 and 120 s instead of every 5 minutes. After 3 failures the modem network restarts, a dropped context starts a search right away, and a ban no longer resets the counter.
First retry after a failed operator search Conclusion
The client confirmed the LTE-M sequence works. QA could no longer reproduce the deep-sleep delay. The operator-search fix passed a test with a roaming SIM that had data suspended.
Most of the work came after the first version. Recovery code only runs when things go wrong, so its bugs show up late, one field case at a time.
- Cut MQTT record latency p90 from 4.06 s to 0.12 s for a large fleet. alporak.com/work/mqtt-latency
how: Why did locking a car take 10 seconds?
A fleet customer locks and unlocks cars over MQTT. The server sends a command, the tracker does it and replies. Over time, the p90 for a lock crept past 10 seconds. That’s a long time to stand next to a car, waiting for the door.
Measuring first
I wrote a script that pulls the round-trip time of every publish out of the device logs, and added latency probes at each stage. Then I changed one thing at a time, each behind its own flag, and measured again.
One task doing everything
There was no single bug. It was a traffic jam. Commands, record publishing and the protocol engine all ran in one task. That task waited up to 60 s for a socket send, and with no limit at all for an MQTT ACK. One slow write and everything behind it stalled, including a lock command stuck behind a queue of records. On top of that, every record was built twice.
Splitting it up
I split MQTT into three tasks: commands, publishing and the protocol engine. Now a task waiting on the network doesn’t hold up the others.
They still share one TLS session, so writes have to be serialized somewhere. I first tried the shared network layer. It deadlocked. It works in the layer that owns the TLS session.
Both waits now have a cap. The transport answers
ok,busyorfatal, so a busy modem no longer kills the TLS session. The duplicate record build is gone. I also fixed a record-storage mode that an earlier update had broken.Conclusion
Record send p90 went from 4.06 s to 0.12 s, and the median from 1.03 s to 0.05 s. The time one reply held the connection layer went from 495–1,144 ms to 32–240 ms. A calibration command went from 1,664 ms to 4 ms.
Record send time, p90 One caveat: lock replies use the same publish path, so record send time is what I measured. I don’t have the end-to-end lock time after the fix. The delay still visible in the customer’s logs came from sockets dropping while roaming.
Nothing here was slow on its own. The problem was waiting without limits, and it only showed up once each stage was measured.
- Designed signed device unlock, salted password hashes and downgrade protection. Moved TLS to TLS 1.3, and built the EU CRA SBOM pipeline. alporak.com/work/security
how: 3,505 files compiled, 597 shipped
Tracker firmware needed stronger device security, a modern TLS stack and a software bill of materials (SBOM) for the EU Cyber Resilience Act. This page covers the design only. The details stay private.
Which files actually ship?
Standard SBOM tools can’t read this kind of RTOS firmware image, so I worked from the linked ELF instead. Most of what the compiler sees never ends up in the image, and listing all of it would make the SBOM longer and less accurate.
Files in the build I compared four ways of counting the same build. The compiler saw 3,505 files. The linker’s “unused” list was misleading. File symbols in the ELF over-count by about 2x. Counting only files that own a sized symbol in a loaded section gives 597, and that’s what the SBOM lists. The CI pipeline handles the scanner’s rate limit and uploads to Dependency-Track with CPE identifiers.
Unlock and passwords
Unlocking is challenge-response, and the device verifies a signature. Passwords are stored only as salted PBKDF2 hashes and compared in constant time. Attempt counters survive a power cut. If the lock’s record gets damaged, the lock stays closed.
Updates and TLS
Firmware updates got downgrade and tamper protection, designed together with five new unit-test suites. I shipped it as release owner.
I moved TLS to the library’s current long-term-support line, with TLS 1.3. MD5, SHA-1, DES, renegotiation and DTLS are off. Only AEAD and ECDHE cipher suites are left.
Conclusion
Fail-first unit tests, with fakes for crypto and storage, caught 12 of 12 deliberate mutations. I also ran bench loops with reboots and power cuts.
For security code, a test suite that has never failed doesn’t prove much.
- Built dual-APN networking and LTE-M recovery sequences together with modem vendors. alporak.com/work/ram-budget
how: Three features against one RAM budget
Tracker firmware runs on a fixed amount of RAM, and most of it is already taken. Three requests each needed more of it. A client wanted 400 geofences, each a 15-point polygon. Another project needed the driver ID list to hold 10,000 entries. A customer needed two data connections on different APNs, open at the same time.
I wrote an estimate for each before writing any code: 154 h of firmware work plus 40 h for the configuration tool, 60 h, and 116 h. Each one hit a different wall: free RAM, boot time, and room for only one TLS session.
Geofences: measure, then cut
Every polygon point lives in RAM. With 400 zones, I measured 42 kB of free RAM at 10 points per polygon, and 24 kB at 15. That was an early measurement, and it was dangerously low.
Free RAM with 400 zones, preliminary measurement Coordinates come with six decimal places, about 10 cm, and were stored as doubles. I pushed for 32-bit floats instead: half the bytes per coordinate, and a little less precision. I also pushed back on per-zone names as scope creep. It still didn’t fit, so I removed reserved features the build never used, and shortened a rarely used list to free 2.4 kB.
What the cuts broke
Trimming had removed some base parameters by mistake, so the immobilizer re-locked after unlock. I restored them. The
#ifndefblocks I added to save RAM overlapped and changed an IO default, so an alarm event was always on. I patched that. And the configuration tool still treated coordinates as doubles, so every config showed unsaved changes. I updated it to float.10,000 driver IDs: boot was the problem
A driver touches an ID key to the 1-Wire reader, and the firmware checks it against the list for the immobilizer. With 10,000 entries the feature worked, but boot took about 100 s, against a 30 s limit. I made the list load faster at boot, and cut RAM and BSS use so the list fit.
Two connections, one TLS session
The firmware assumed there was only ever one data connection. The estimate is where the real limit showed up: there was RAM for one TLS session, not two. So I reworked the core network API to handle two PDP contexts. Both connections stay up, and secure traffic goes to one server at a time, so one TLS session is enough.
In testing, the backup connection was torn down and rebuilt on every send. The network rejected that, and the modem got stuck in a restart loop. I fixed the backup handling in several places and removed the settings-refresh loop.
Conclusion
Geofences: QA confirmed “400 zones configurable and polygons working”, and the build fits in RAM. Driver IDs: boot went from about 100 s to under 30 s, on two tracker models. Two connections: the customer accepted the design, which touches about 30 files across the network API and two modem drivers.
On a device this full, every feature costs something else. Here it was precision, unused features and a second TLS session. And cutting RAM breaks things too, so cuts need testing like any new feature.
- Traced 700 trackers sending zero coordinates to a fix flag that moved before NMEA was stable. alporak.com/work/zero-coords
how: 700 trackers on Null Island
In 2024, after a firmware update, 700 trackers in the field started sending records with zero coordinates. The records said they had a GPS fix.
0, 0 is a spot in the Gulf of Guinea, known as Null Island. A record without a fix is just a gap. A record with a “fix” at 0, 0 is worse, because the server puts it on the map.
The flag moved too early
I reproduced it. The GPS fix signal switched to “fix” before NMEA stabilization had finished. Any record created in that window had a fix but no real position.
So I made the fix signal wait until NMEA is stable. In factory test mode the wait is skipped, so production tests stay fast.
A flag that never reset
While wiring that in, I found that the unstable-fix flag was never reset on sleep or on GPS loss, so it carried over into the next fix. I reworked it. The unstable-fix flag now only starts NMEA stabilization, and a separate “NMEA stable” flag feeds the fix filter, the same way the speed and altitude filters do.
What the wait exposed
The new delay uncovered an ordering bug. “Update good coordinates” ran before “update GPS fix state”, so coordinates changed while the status still said no fix, and went stale after ultra-deep sleep. I swapped the order, so coordinates only update on a stable fix, and the fix status now resets on sleep.
I also added GNSS status 4, “filter active”, so testers can see why coordinates are being held.
Conclusion
Test drives on 3 device families produced no zero-coordinate records. All three fixes touch the same state, so I put them in one test firmware, and QA verified them together.
Adding a delay changes the order things happen in, and that brings hidden ordering bugs to the surface. The first fix was small. Most of the work was in what it uncovered.
- Found a GNSS race that left the receiver off for 5.5 h. GNSS commands went from 45 s to 3 s. alporak.com/work/gnss-honesty
how: GNSS off for 5.5 hours, and a cold start that lied
A tracker drove out of an underground car park and didn’t get a fix for 5.5 hours. The logs showed the GNSS module had never been powered on, even though the firmware said it was.
Separately, the firmware’s fix-time test was reporting cold starts of 1–3 s. That’s far too good to be true.
Two different bugs, same problem: the firmware was reporting something about the GNSS that wasn’t real.
Reproducing the race
I suspected a race in the restart sequence. I added a test hook that floods the GNSS request path, and that reproduced it on the bench: the firmware says GNSS is on, the module stays off.
How a request got lost
A restart sends “off”, then “on” 2 s later. Requests were de-duplicated against the module’s current state. When “on” arrived, “off” hadn’t been applied yet, so the module still looked on, and “on” was dropped as a duplicate. Then “off” completed, and nothing turned it back on.
The fix
I added a pending-request counter and a FIFO, so requests can’t be lost or reordered while an earlier one is still being applied. As a backup, a check runs every second and resends the request if the wanted and actual states differ for 30 s.
Switching GNSS on or off by command went from 45 s to 3 s, with no reboot. In QA, two trackers got their fix back quickly in driving and long-term tests.
Time to switch GNSS on or off by command The test that passed too fast
With tick logging, the test “passed” after about 215 ticks. The raw NMEA showed why. A valid
$GNGGAline from before the reset arrives after the reset command but before the module’s start message, and the firmware took it as a fresh fix.I added a 300-tick guard window, about 1.3 s, that ignores GNSS status right after a reset. A fix-holdout feature was also keeping the old status alive, so I cleared it in the two places where the test forces a fix loss. I also tried clearing the assistance data. That made no difference.
Conclusion
GNSS now switches in 3 s instead of 45, and requests no longer get dropped. The test reports real numbers: cold start 30–65 s, warm about 3–5 s with assistance data, hot 3–4 s.
A result that looks too good deserves the same suspicion as one that looks bad. The cold-start number was off by more than ten times, and nothing about it looked broken.
- Bisected offline record loss on the device to a merge commit, and fixed an older delete edge case. Delivery went from 1 of 11 packets to 11 of 11. alporak.com/work/offline-loss
how: 1 packet out of 11 survived the outage
In RS232/RS485 buffered mode, the tracker stores data from a serial sensor and sends it when the server is reachable again. But after an outage, only the last packet was left.
Finding the change
Buffered mode had worked before, so something had broken it. The record database stores records by sequence number in a nested folder tree. I bisected on the device across releases and merges, and landed on a merge from an unrelated feature: a rewrite of the FIFO record database.
The flag nobody read
The multi-save call still took a sequence flag, but the rewritten code never read it. So every packet was written as sequence 0. The database then decided the file was corrupted and erased it, leaving only the newest packet.
Two more problems on the same path
Buffered mode always used the TCP path, because only the non-buffered path checked the server type. So a device set up for MQTT never sent its buffered data at all. And in the JSON codec for the cloud, serial data over 18 B was dropped and 0x0A/0x0D bytes were changed. There was also an old edge case in delete-all.
The fixes: each buffered packet gets its own storage slot, which also fixed delete-all. Buffered mode now uses the same server-type check as the rest, so it works over TCP and MQTT, ASCII and binary. The JSON codec sends the full serial data as a hex string.
Conclusion
After an offline period, 11 of 11 packets now arrive, instead of 1 of 11.
Serial packets delivered after an offline period Nothing caught the original break because the record database had no unit tests. I wrote the first ones, with an in-memory fake file system, a 269-line fake record-manager harness and a 5-step test plan.
The symptom was in one feature and the cause was in another. Bisecting is what connected them.
- Fitted 400 polygon geofences and a 10,000-entry driver ID list into trackers short of RAM. With the full list, boot went from about 100 s to under 30 s.
- Co-developed a React Native BLE sensor app with 14 store releases. alporak.com/work/cold-chain
how: 30,000 records over BLE in 5–6 minutes
BLE sends data in small packets. Both sides agree on a maximum size, the MTU, and anything bigger doesn’t get through.
I ran into this limit from two sides: a phone app that downloads logs from a cold-chain temperature recorder, and tracker firmware that iPhones couldn’t talk to.
The app: every record has to arrive
I co-developed the React Native app for a family of BLE sensors, on iOS and Android: about 140 commits, about 85 tickets and 14 releases to Google Play and TestFlight.
For the recorder’s cold-chain certification, every record has to arrive, and you have to be able to show it did. I added a CRC check on every chunk, so each row in the export says whether its chunk arrived intact. I also fixed a page-header shift, where the header sometimes arrived one slot late and the app read a record chunk as the header. Then I raised the MTU to 247 and the chunk size from 15 to 60 records.
To test full-size downloads, I added a fake-record generator to the app. 30,000 records now download in 5–6 minutes.
The firmware: iPhones and 512-byte chunks
An iPhone can only reach the tracker over BLE. The tracker isn’t MFi certified, so iOS can’t use its Bluetooth Classic serial link. And our firmware sent BLE data in fixed 512 B chunks, which iOS can’t take.
In 2024 I wrote up how MTU negotiation really worked on the platform. The chip vendor’s Bluetooth layer negotiated the MTU, and our code sent fixed 512 B chunks on top of it. I set the chunk payload to 182 B, tested on iOS and Android, and released it as an experimental iOS-compatible firmware. That fixed the iPhone link.
When the vendor said no
The vendor SDK had no MTU negotiation in its GATT server layer. In 2025 I opened a support case, and they declined to add it. So I built the MTU exchange in the GATT client layer myself, for links where the tracker is the client. I tested it in the cold-chain firmware, where the tracker reads temperature recorders as a client, and updated the BLE MTU docs.
Conclusion
In the app, 30,000 records download in 5–6 minutes, and every chunk is CRC-checked. In the firmware, QA verified 182 B chunks on two tracker models.
On the firmware side, the write-up mattered more than the code. Once it was clear who negotiated the MTU and what our code did with it, the iPhone fix was small.
- Built and own the device inventory app for R&D and QA test hardware, used company-wide since June 2026. alporak.com/work/inventory-app
how: The inventory app that outgrew 50k reads
R&D and QA have a lot of test hardware, and every device is identified by its IMEI. I built and run the inventory for it: Expo / React Native for Android, iOS and web, an Express API, MongoDB, a C++ scanner service, Docker and GitLab CI. So far that’s at least 33 tickets and about 356 commits.
It started as a small tool and grew into a company-wide service.
Outgrowing Firebase
The first version went live on GitLab Pages the same day it was asked for. Then it moved to Firebase. When it hit Firebase’s 50k read limit, it needed a new home.
Before rebuilding, I priced the alternative. Moving to an off-the-shelf open-source asset manager came to 64 hours. Moving my app to its own backend came to 40. So I moved it to MongoDB behind my own Express API.
Scanning etched codes
The app reads QR and DataMatrix codes with zxing-cpp in three places: a Kotlin module on Android, WASM in the browser, and the scanner service on the server. Laser-etched codes are hard to read, so the decoders try several scales and inverted images.
I also added a server-side photo decoder (OpenCV, Tesseract OCR, zxing). It reads every code on a PCB from one photo, and does it better than the live scan.
Everyday use
Search supports AND/OR, exact (
=) and partial (~) matching, suggestions and shareable filter links. Excel import and export puts each location on its own sheet. Device details fill in automatically, duplicate IMEIs are rejected, and devices can be reserved and released. There’s a daily backup, and admin mode has a git-like change history with revert.An API for CI
The firmware CI pipeline needed the device list, but the app only had interactive single sign-on. So I built a separate machine API for CI, with its own credentials. CI firmware builds now use it to fetch their device list.
Webhooks are signed with HMAC, responses carry ETags for 304s, and a test catches the OpenAPI docs falling behind the routes.
Conclusion
Sorting 2,640 devices went from 487 ms to 92 ms. The app has 352 Jest tests and 1,371 screenshot comparisons. In June 2026 it launched company-wide, with company single sign-on.
List sort, 2,640 devices Pricing the off-the-shelf option was worth it, even though I didn’t take it. 40 hours against 64 made it a decision, not a preference.
- Smartwatch (C++): motion-tolerant heart rate, an event-log platform and an on-device test harness.
- Firmware for a heavy-vehicle tracker line, and tracker firmware that reads EN 12830 cold-chain recorders for their certification.
- About 567 tickets implemented, about 313 investigated and at least 25 research estimates. Vendor cases with modem and chip makers. Regularly stood in as team lead.
- Ultra-low-power temperature monitor on ESP8266 that runs a year on one battery, using tuned deep sleep and I2C sensors.
- NB-IoT vibration analysis on LPC1517 with on-device FFT, for predictive maintenance.
- Modular low-level drivers and sensor integration for LPC1769, and a move of the legacy communication stack to Mbed OS with multithreaded Ethernet and a cloud link.
- Took part in CE certification, and designed the enclosure and a breakout board for its safety and EMI requirements.
- Firmware updates over the air and over USB. alporak.com/work/dvm
how: Three years of building whole devices
From 2019 to 2022 I was an electronics engineer at DvM IoT Solutions. We built IoT devices, and I worked on every layer: drivers, firmware, updates and the enclosure.
When you build the whole device, everything is connected. Battery life depends on what the firmware does between readings. The enclosure decides whether the product passes CE.
A freezer monitor that lasts a year
I designed an ultra-low-power temperature monitor for freezers, on a Wi-Fi MCU. It reads its sensors over I2C and spends the rest of the time in deep sleep. I tuned that sleep until one battery lasted a year.
A vibration monitor that does its own FFT
For predictive maintenance, I built a vibration and temperature monitor on a Cortex-M MCU with NB-IoT. It runs an FFT on its own vibration data, checks the result against thresholds, and sends an alert over NB-IoT when one is crossed.
Drivers and an RTOS
On another Cortex-M MCU, I wrote modular low-level drivers and integrated analog and digital sensors for industrial automation. I moved the old communication stack onto an embedded RTOS, which made the Ethernet communication multithreaded and connected it to the cloud.
Updates and CE
The devices can take new firmware two ways: over the air, or over USB with the device in USB client mode.
I took part in CE certification, and designed the enclosure and a breakout board to meet the safety and EMI requirements.
Conclusion
A freezer monitor that runs a year on one battery, a vibration monitor that analyzes its own data, an old stack moved onto an RTOS, and an enclosure designed for CE.
Those years taught me to start from the hardware. Power, buses and radio set the limits the code has to live within.
- Thesis, in a team of four: a ground station that detects drones in no-fly zones with YOLOv3, and a drone that catches them. It won 1st place at the university project fair. alporak.com/work/thesis
how: A drone that hunts drones
Cheap drones are a risk near sensitive places like government buildings and crowds. For our B.Sc. graduation project, as a team of four, we set out to take control of a drone that flies into a restricted area.
It had to be fast and autonomous, and leave the drone undamaged. That broke down into four steps: detect it, confirm it, share its position, and catch it.
Detecting and confirming
The ground station picks up the radio signals the drone sends. A camera running YOLOv3, an object detector that looks at a whole image in one pass, then confirms that it’s a drone.
Sharing and catching
A PyQt program shares the results between the ground computers over UDP broadcast. The ground control station sends the drone’s GPS position to our own predator drone, which we designed and built. A guidance algorithm steers it to track and catch the target. I wrote the system in C and Python.
Conclusion
The project won 1st place at the university project fair. The full report is on ResearchGate.
I finished my B.Sc. in Electrical and Electronics Engineering at Eskişehir Technical University in 2019, after spending 2017–18 on Erasmus+ at VSB Technical University of Ostrava. The same year, I started as an electronics engineer at DvM.
- Erasmus+ exchange at VSB Technical University of Ostrava, 2017–18.
Daily
- C
- C++17/20
- Python
- RTOS: Nucleus, Zephyr, Keil RTX
- Cellular modems, AT, PDP, FOTA
- GNSS, NMEA
- BLE
- MQTT, TLS
- J-Link, GitLab CI
Regular
- CAN, OBD-II, tachograph
- RS232/485, Modbus, 1-Wire
- I2C, SPI, UART, ADC
- mbedTLS, TLS 1.3
- CppUTest, Ceedling, pytest
- Ghidra, Wireshark, sniffers
- Docker
Used on projects
- TypeScript, React Native
- Kotlin, C#/.NET
- FastAPI, Node.js
- Mbed OS, FreeRTOS
- Altium, KiCad
- Fusion 360
more: all 24 write-ups, tools I built
Selected work
- 21 to 0 One reset, two bugs, one of them in a closed library alporak.com/work/bt-leak
- 5.5 h GNSS off for 5.5 hours, and a cold start that lied alporak.com/work/gnss-honesty
- 4.06 s to 0.12 s Why did locking a car take 10 seconds? alporak.com/work/mqtt-latency
- 7.8 h to 100 s The 100-second timeout that became 7.8 hours alporak.com/work/one-constant
- 8.2 to 5.5 bpm Heart rate that fell apart when you walked alporak.com/work/heart-rate
- 108,755 Writing my own trace decoder alporak.com/work/trace-decoder
All 24 write-ups: alporak.com/#work