DEV Community: Daniel Sá

Teltonika-Go Update: From Initial Release to Full Codec Support

Daniel Sá — Fri, 29 May 2026 20:17:41 +0000

A few months ago, I published my first article introducing Teltonika-Go:

Introducing Teltonika-Go: A Go Package for Parsing and Communicating with Teltonika Devices

At the time, the goal was simple:

Build an open-source Go library to simplify communication with Teltonika GPS tracking devices.

The project started as a side project inspired by my experience working in vehicle tracking and telemetry systems. I wanted a reusable package that developers could easily integrate into their own fleet management, IoT, and GPS tracking platforms.

Since then, the project has grown significantly.

What Has Changed?

The initial version focused primarily on AVL packet parsing and the most commonly used codecs.

Today, Teltonika-Go supports:

AVL Data Codecs

Codec 08
Codec 8E
Codec 16

Command & Response Codecs

Codec 12
Codec 13
Codec 14
Codec 15

Additional Features

AVL packet decoding
AVL packet encoding
Command packet encoding
Command response decoding
TCP support
UDP support
IMEI handling
CRC validation
Timestamp utilities
Extensive unit testing

Repository:

https://github.com/danieljvsa/teltonika-go

One of the biggest milestones was expanding support beyond AVL data packets and implementing command-related codecs.

This transformed the library from a parser into a more complete communication toolkit for Teltonika devices.

Why This Matters

Many GPS tracking systems eventually need more than just location data.

Real-world deployments often require:

Sending commands to devices
Receiving command responses
Managing remote configurations
Supporting multiple Teltonika device generations
Handling both TCP and UDP communication

Supporting these additional codecs makes it easier to build complete integrations without having to implement protocol handling from scratch.

Lessons Learned

Protocol Specifications Matter

The most challenging aspect of the project was never the Go code itself.

The difficult part was ensuring protocol correctness.

When working with binary protocols, small mistakes can break communication completely.

Issues such as:

Incorrect packet lengths
CRC calculation errors
Wrong byte ordering
Timestamp conversion mistakes

can result in devices rejecting packets without providing much information about what went wrong.

Most development time was spent validating behavior against protocol documentation and testing edge cases.

Testing Became Essential

As support for more codecs was added, the importance of testing increased dramatically.

Adding new functionality without introducing regressions became a priority.

Today, the project includes a growing suite of tests that helps ensure stability when adding features or improving existing implementations.

Open Source Is About Iteration

One thing I enjoy about open source is that projects rarely remain in their original form.

The first release is simply the starting point.

Since publishing the original article, I've received feedback, discovered new use cases, and identified areas where the library could be improved.

Each iteration has made the project more complete and more useful.

Building with Modern AI Tools

This project was also an interesting opportunity to explore modern AI-assisted development.

I used tools such as:

Claude
OpenCode
DeepSeek
Qwen

to accelerate development tasks including:

Boilerplate generation
Test creation
Documentation improvements
Code reviews
Refactoring suggestions

The biggest lesson was that AI works best as an accelerator rather than a replacement for domain knowledge.

Understanding GPS tracking systems, binary protocols, and Teltonika specifications remained essential for validating the generated code and ensuring correct behavior.

What's Next?

There are still several improvements planned for future releases.

Some areas I'd like to focus on include:

More real-world examples
Complete TCP server examples
Improved documentation
Better pkg.go.dev support
Additional protocol utilities

The goal remains the same as when the project started:

Make Teltonika device integration easier for Go developers.

Final Thoughts

Looking back at the original article and comparing it with the current state of the project, it's satisfying to see how much it has evolved.

What started as a simple parser has grown into a much more complete Teltonika communication library supporting multiple codecs, command handling, and packet generation.

If you're working with Teltonika devices, GPS tracking systems, or telemetry platforms, I'd love to hear your feedback.

Feel free to check out the repository, open an issue, or contribute to the project.

Happy coding 🚀

Repository:

https://github.com/danieljvsa/teltonika-go

Building Two Web Apps Using Claude AI + OpenCode

Daniel Sá — Sun, 24 May 2026 12:11:22 +0000

Over the last weeks I decided to experiment with AI-assisted development workflows to see how much faster I could go from idea to working MVP.

Instead of treating AI as a “code generator”, I approached it more like an engineering accelerator:

brainstorming partner
rapid prototyping assistant
UI iteration helper
debugging companion
architecture sounding board

The result was two small projects:

Altivo — a lightweight portfolio tracker
Hopway — a visual route planning app

Both projects are intentionally lightweight, but they helped me explore a modern development workflow using:

Claude AI
OpenCode AI
DeepSeek V4 Flash
Qwen 3.6 Plus

The Projects

Altivo

Altivo is a lightweight and privacy-friendly portfolio tracker focused on simplicity and static deployment.

Live Demo:
https://danieljvsa.github.io/altivo/

GitHub:
https://github.com/danieljvsa/altivo

The idea was to build something lightweight that could:

track ETFs
support crypto
run entirely as a static frontend
avoid unnecessary complexity

I wanted a cleaner and simpler experience than many traditional portfolio platforms.

The project also became an interesting exercise in:

frontend architecture
UI simplification
API integration
local-first persistence

Tech Stack

HTML
CSS
JavaScript
GitHub Pages
Financial Market APIs

Hopway

Hopway is a lightweight route planning and travel exploration tool.

Live Demo:
https://danieljvsa.github.io/hopway/

GitHub:
https://github.com/danieljvsa/hopway

The concept behind Hopway was creating a map-first experience where users can:

create routes
visually explore destinations
share travel plans
experiment with AI-generated route ideas

The app uses CARTO maps and focuses on keeping the UX lightweight and visual.

I wanted it to feel more like an exploration tool than a traditional route planner.

Tech Stack

HTML
CSS
JavaScript
CARTO Maps
GitHub Pages

The AI Workflow

One of the most interesting parts of these projects was experimenting with different AI tools together.

Each model had different strengths.

Claude AI

Claude was the strongest tool for:

architecture discussions
reasoning
debugging
planning features
refining ideas
writing structured prompts

It was especially useful when thinking through:

application structure
user experience
roadmap decisions
feature tradeoffs

OpenCode AI

OpenCode became the main execution layer for applying changes directly inside the repositories.

This made iteration significantly faster because I could:

define tasks
refine prompts
generate implementations
review results quickly

The workflow started feeling much closer to collaborating with a junior developer that could iterate extremely fast.

DeepSeek V4 Flash

DeepSeek V4 Flash was surprisingly useful for:

quick fixes
smaller implementations
fast iterations
UI experimentation
alternative code suggestions

Because it was fast and free, it became useful for high-frequency iteration loops.

Qwen 3.6 Plus

Qwen 3.6 Plus was particularly good for:

generating alternative approaches
refining frontend ideas
brainstorming UX improvements
comparing implementation styles

Sometimes asking multiple models the same question produced surprisingly useful contrasts.

What AI Was Actually Good At

The biggest productivity gain was not “AI writing code”.

It was reducing friction.

AI was extremely useful for:

generating boilerplate
accelerating iteration
refining UI ideas
debugging faster
exploring alternatives
reducing context-switching

For small MVPs, that becomes incredibly powerful.

What Still Required Human Control

The important engineering decisions still required human oversight.

Things that still needed strong manual control:

architecture decisions
consistency
product direction
deployment
performance considerations
long-term maintainability

AI accelerated execution, but it did not replace engineering judgment.

Lessons Learned

A few things became very clear during these projects:

Smaller focused prompts worked better than giant prompts
AI performs best when architecture is already defined
Iteration speed becomes one of the biggest advantages
Reviewing generated code remains critical
Combining multiple models produced better results than relying on a single one
AI is especially powerful for reducing setup and boilerplate friction

One of the most interesting outcomes was how quickly experimentation became possible.

Normally many side projects die during the setup phase:

too much boilerplate
too much context switching
too much repetitive work

AI dramatically reduced that friction.

That allowed me to spend more time on:

product thinking
UX refinement
architecture
experimentation

Instead of repetitive setup work.

Final Thoughts

These projects are small, but they represent something bigger:
a shift in how rapid MVP development is evolving.

AI-assisted workflows are becoming extremely valuable for:

side projects
prototypes
internal tools
experimentation
product validation

AI did not replace development.

But it significantly reduced the time between:
idea → prototype → working application.

As a backend developer, these projects also helped me improve:

frontend awareness
UX thinking
rapid delivery skills
product-focused development

And honestly, the workflow was fun.

If you're experimenting with AI-assisted development workflows too, I'd love to hear how you're using them.

Introducing teltonika-go: A Go Package for Parsing and Communicating with Teltonika Devices

Daniel Sá — Thu, 12 Jun 2025 13:40:53 +0000

If you've ever worked with Teltonika GPS tracking devices, you know that parsing their proprietary protocol can be a bit of a challenge. Whether you're building a fleet management system, a custom IoT platform, or just tinkering with real-time vehicle telemetry, understanding and communicating with these devices is critical.

That's why I created teltonika-go — an open-source Go package that simplifies parsing Teltonika messages and enables communication with their devices over TCP.

📦 What is teltonika-go?

teltonika-go is a lightweight, idiomatic Go library designed to help developers decode, parse, and interpret the binary protocol used by Teltonika GPS trackers like the FMB series. It provides building blocks for server-side communication with these devices, which typically send AVL (Automatic Vehicle Location) data over TCP.

With teltonika-go, you can:

Read and parse AVL packets sent by devices
Understand GPS, IO, and timestamp data
Handle device handshakes and codec types (including Codec8, Codec8 Extended and Codec16)

Build your own custom server or integrate Teltonika device communication into an existing Go application

✅ Why Use It?

Teltonika devices are widely used in the GPS tracking industry, but documentation is limited and most of it is not tailored to developers. If you're a Go developer, teltonika-go provides:

A clean and idiomatic API
No external dependencies (other than the Go standard library)
Open-source flexibility (MIT License)

🔧 Getting Started

Install the package:

go get github.com/danieljvsa/teltonika-go

Example: Parse a TCP packet from a Teltonika FMB device.

package main

import (
    "fmt"
    pkg "github.com/danieljvsa/teltonika-go/pkg" //for general functions
    tools "github.com/danieljvsa/teltonika-go/tools" //for functions that used in package to help in case only want to decode specific tram code
)

func main() {
    // example binary data from a Teltonika device
    rawLogin := []byte{ /* login packet */ }
    rawTram := []byte{ /* AVL packet */ }

    // Decode login packet
    login := pkg.LoginDecoder(rawLogin)
    if login.Error != nil {
        fmt.Println("Login decode error:", login.Error)
    } else {
        fmt.Printf("Login decoded: %+v\n", login.Response)
    }

    // Decode AVL/tram packet
    tram := pkg.TramDecoder(rawTram)
    if tram.Error != nil {
        fmt.Println("Tram decode error:", tram.Error)
    } else {
        fmt.Printf("Tram decoded: %+v\n", tram.Response)
    }
}

🧱 Project Structure

The project is still in its early stages, but currently supports:

Decode login packets
Parse AVL records using Codecs 08, 8E and 16
Validate and interpret Teltonika TCP/UDP headers

Feel free to check out the repo: https://github.com/danieljvsa/teltonika-go

🚧 Roadmap

The project is under active development, and here are some features on the horizon:

Full support for Codec 12 and Codec 14
Full support for encoding for commands with codecs 12, 13, 14, 15.
Tools to send commands to devices (e.g., engine cut-off, configuration updates)
Improved error handling and documentation

If you're working with Teltonika devices and using Go, I'd love your feedback and contributions!

🤝 Contributing

Contributions are welcome! If you find a bug, have a feature request, or just want to improve the code, feel free to open an issue or a pull request.

🙌 Final Thoughts

Parsing Teltonika’s binary protocol doesn’t need to be a pain. With teltonika-go, you can start building robust applications that speak Teltonika's language — all in idiomatic Go.

👉 Check out the project on GitHub: danieljvsa/teltonika-go

⭐ Star it if you find it useful, and let's make working with Teltonika devices easier together!

Source code: https://github.com/danieljvsa/teltonika-go

DEV Community: Daniel Sá

Teltonika-Go Update: From Initial Release to Full Codec Support

What Has Changed?

AVL Data Codecs

Command & Response Codecs

Additional Features

Why This Matters

Lessons Learned

Protocol Specifications Matter

Testing Became Essential

Open Source Is About Iteration

Building with Modern AI Tools

What's Next?

Final Thoughts

Building Two Web Apps Using Claude AI + OpenCode

The Projects

Altivo

Tech Stack

Hopway

Tech Stack

The AI Workflow

Claude AI

OpenCode AI

DeepSeek V4 Flash

Qwen 3.6 Plus

What AI Was Actually Good At

What Still Required Human Control

Lessons Learned

Final Thoughts

Links

Altivo

Hopway

About Me

Introducing teltonika-go: A Go Package for Parsing and Communicating with Teltonika Devices

📦 What is teltonika-go?

✅ Why Use It?

🔧 Getting Started

🧱 Project Structure

🚧 Roadmap

🤝 Contributing

🙌 Final Thoughts

👉 Check out the project on GitHub: danieljvsa/teltonika-go