About me

Hello! I'm Saba Burduli, a 17-year-old software engineer from Tbilisi, Georgia. Exploring and building things in tech has always been my biggest source of satisfaction.

I started scripting at eight at Komarovi Math School, where algorithms and competitive programming quickly became something special to me. Python made scripting feel incredible, and from there I went deep into low-level programming with C++. My love for the C family kept growing, and I started building pet projects in both C and C#.

KinoTech

My first full-time job came at 16, at KinoTech, on a streaming platform. I built a custom chunked streaming pipeline that had to stay live 24/7 with minimal latency and delay, all in C# and .NET.

The company's biggest and most critical domain-driven projects were its CRM and its dispatching platform. I was the one who understood how the CRM was configured end to end, so my team lead asked me to take over its maintenance and get it ready for an upcoming launch. I led a team of junior developers (friends of mine): breaking the work into predictable tasks, making the technical decisions, and optimizing the platform and its databases. None of us had carried anything this critical before, and I was honestly worried. Around 10 clients ran their business on that CRM, and a single day of downtime would have cost each of them an estimated half a million.

We optimized the database queries and the way the services talked to each other over HTTP, and we finished the CRM. Roughly 70% of its core business logic came from our team, and we handed the codebase over to other developers for maintenance and smaller features.

Then we moved fully onto the dispatching platform: one dashboard where dispatchers see loads from five to ten of the biggest load providers in a single place. We built the data ingestion ourselves, using Playwright to automate the providers' web apps and capture their data reliably, covered it with unit tests, and kept optimizing it on our own.

What I loved most was the team. KinoTech felt less like an enterprise and more like a startup: constant communication with teammates and managers, and the feeling that the product, the company and its demands were ours. I've since moved on, but it was an incredible journey: developers from different domains and stacks, building custom software and internal and external tools together.

AI engineering and indie building

After KinoTech I moved fully into AI engineering and machine learning and started building as an indie developer, turning my own ideas into real, working software instead of leaving them as notes.

On the ML side I'm learning from the fundamentals up: how transformer models work under the hood (self-attention, encoder and decoder stacks), how text becomes tokens (BPE and WordPiece, including training my own tokenizers), running pretrained LLMs with Hugging Face Transformers, building data pipelines with Datasets, and fine-tuning pretrained models in PyTorch.

On the agent side I care most about the layer below the model. AgentCore, my C17 agent runtime, treats every tool call as untrusted input: strict JSON parsing with yyjson (duplicate-field checks, bounded nesting, a 1 MiB input limit), a tool registry with explicit ownership of every tool and parsed document, an injectable allocator, monotonic execution timing, and structured error results so a failed call never takes the runtime down. It's tested on Linux and macOS with GCC, Clang and AddressSanitizer.

Around that I build the tooling agents need: Peek Codex browses real agent sessions through the supported app-server boundary, CodexAgentMonitor turns a local JSONL event stream into live token, quota and rate-limit telemetry, and TenaBench drops AI agents into real Git repositories to measure whether they can actually debug, refactor, test and recover from failure.

This is the era where a small idea no longer needs one or two years, millions of lines of code and a team of specialists to become a real product. With solid fundamentals and AI as a wingman, one person can ship the website, the mobile app and the infrastructure. I extend agent harnesses (I've published a Pi extension on npm) and tune Codex and Claude to my own workflows with custom skills and agent instructions.

Building my own tools

I'd rather build a tool than rent one. When a product doesn't fit how I work, I make my own: my own ad blocker; an MP3 player that runs on Linux, macOS, Android and iOS and keeps every device in sync; my own Finder replacement on macOS; a riced macOS desktop without AeroSpace or SketchyBar; and an AI-assisted Git TUI, so I don't need lazygit (I still like pushing by hand). Most of these aren't public yet, and I plan to publish all of them.

Native macOS apps

I build most of my macOS apps myself. Petty is a desktop companion pet: a transparent, borderless, always-on-top window built with SwiftUI and AppKit, an IOKit-based activity monitor that tracks mouse and keyboard input and idle time, and a character state machine animated with Rive. It comes with a free in-app store of 10+ characters, each with its own animation assets.

Keytome is a fast, offline shortcut and command reference for macOS, built natively in Swift 6.

Sim racing meets AI

You should also know how much I love cars and driving fast, on the sim rig. So I built ACC Setup Coach, an AI tool for Assetto Corsa Competizione: tell it your car, track, conditions, driving style, experience and input device, and it explains how to adjust your setup (tyres, wheel parameters, whether to attack the kerbs) and coaches your driving style, while you stay in control of every change.

Experience

• Software Engineer · KinoTechJun 2025 – May 2026

  Tbilisi, Georgia · Hybrid · Full-time

  • Developed a streaming platform from scratch using low-level graphics libraries (DirectX) and real-time protocols (RTP, RTMP, HLS); built custom capture software and implemented NVIDIA encoders (AV).
  • Designed RESTful APIs and built in-house libraries for mapping, real-time communication, logging and more.
  • Implemented custom load balancing with consistent hashing, round robin and weighted round robin; designed and deployed microservices in a mixed modular-monolith architecture.
  • Worked on a CRM platform of 8 microservices (Identity, Trading, Payments, Chat, File Storage, Socket, Binance, Gateway): maintained and refactored database queries and the codebase, implemented authentication features, the trading board and payment services for multiple brands, and contributed to the Binance integration.
  • Engineered scalable data extraction for a logistics platform, pulling real-time data from load providers (Carship.io, CentralDispatch) with custom browser automation and HTML parsing of JavaScript-driven pages, including session management.
  • Implemented secure authenticated workflows with session and refresh tokens, in line with platform security guidelines, and designed data pipelines for transformation, validation and backend integration.
• Software Engineer · CentaureaJan 2025 – Jun 2025

  Minsk, Belarus · Remote · Outsourcing · Full-time

  • Designed RESTful APIs with layered caching: Redis, Memcached and in-memory cache.
  • Worked with relational and non-relational databases: PostgreSQL, MSSQL, MongoDB, Cassandra.
  • Real-time communication with WebSockets and SignalR; custom API gateways with Ocelot and YARP for a microservice architecture.
  • Solved background-service user handling with custom algorithms.
  • Integration tests with WebApplicationFactory and Testcontainers; unit tests with xUnit and AutoFixture.
• Co-Founder · CRUD AcademySep 2024 – Present

  Tbilisi, Georgia · Remote · Education

  • Lead a group of students and manage their learning paths and roadmaps.
  • Built a custom education platform with leaderboards based on each student's level.
  • Host online competitive programming tournaments inside the academy.

Education

• Student · Komarovi Math School Sep 2016 – Present

How I work

• Small, working steps. Ship something that runs, then make it better.
• Explainable over magical. If a tool makes a decision, you should be able to see why.
• Write it down. I keep a public engineering log of what I build and learn.
• Direct feedback. I'll push back with reasons — and happily change my mind with better ones.

Skills

Languages

C# · C++ · C · Zig · GLSL · Python · TypeScript

Architecture

Microservices · DDD · CQRS · Event Sourcing · Event-Driven

Data

PostgreSQL · MSSQL · MongoDB · Cassandra · Redis

Infrastructure

Docker · Kubernetes · RabbitMQ · Azure (learning) · Git

Standards, Tools

Git · EF · Dapper · Docker · Kubernetes · Apache · RabbitMQ · Aspire

AI

Agent runtimes · Tool calling · LLM-powered workflows

Graphics & streaming

DirectX · OpenGL · RTP · RTMP · HLS · NVIDIA hardware encoding

Want to get in touch? See the Contact tab.