Aleksandr BasarginBackend / Software Engineer

Payment systems, digital goods, and the bots on top.

I split systems along domain boundaries, wire the services together over Redis Streams, and own the pipeline that ships them. Python and Go for services, Rust where the hot path or the tooling justifies it.

Get in touch View GitHub profile

Open to contract and full-time work

orders — production

example session

docker compose ps

SERVICE STATUS

orders-api Up

payments-consumer Up

delivery-worker Up

kubectl rollout status deploy/orders-api

deployment "orders-api" successfully rolled out

redis-cli --no-raw XINFO GROUPS orders.events

name consumers pending lag

payments 3 0 0

delivery 2 0 0

01About

I work on the part of the product nobody sees.

Most of my work is backend: payment processing, digital goods delivery, integrations with external providers and marketplaces, and the internal tooling a business runs on. Python and Go day to day — REST APIs, data processing, and automation that removes manual steps. Internal projects where it pays off are written in Rust.

I build services, not a monolith with good intentions. Domains get split along real boundaries, each service deploys on its own behind an explicit API contract, and the ones that need to stay in sync talk over Redis Streams rather than chaining synchronous calls until something times out.

The infrastructure side matters as much to me as the code. Docker and Kubernetes, GitHub Actions pipelines, Prometheus and Grafana so a problem is visible before a customer reports it, and production support when it isn't. I've set up deployment environments from scratch and cleaned up ones that had grown teeth.

I also ship native software — a VPN client for Apple platforms, iOS through tvOS, with the Packet Tunnel and sing-box runtime underneath — and Telegram bots that put the same ordering flows in a chat window. Building both sides taught me to write APIs a client can actually consume.

FocusBackend · integrations · infrastructure

LanguagesPython · Go · Swift · Rust

WorkingRemote · contract & full-time

SpeaksEnglish · Russian

02Work

Products I've built backend for.

Digital goods, payment rails, and the bots that keep them moving.

On the App Store

Digital goods and top-up platform

Microservices · orders · payments · delivery

Backend for storefronts selling game top-ups, subscriptions, and other digital goods. Orders, payment processing, and delivery are separate services behind explicit contracts: an order is accepted, payment is confirmed through an external provider, and fulfilment is handed to a delivery worker that retries on its own. Services stay in sync over Redis Streams instead of chaining synchronous calls, and every purchase ends in a verifiable delivery rather than a support ticket.

Python
Go
Redis Streams
PostgreSQL
MongoDB
Kubernetes
Prometheus
Grafana

Telegram bots and service operations

Bots · automation · uptime

Telegram bots as the customer-facing layer: ordering, top-up, and status flows that talk to the same backend the storefronts use, so a purchase made in chat lands in the same order pipeline. Beyond the bots, the engineering work was keeping the service alive — deployment, monitoring, incident response, and the operational logic that decides what happens when a provider is slow or a payment is stuck.

Python
Go
Telegram Bot API
Docker
Kubernetes
Redis

Native Apple VPN client

iOS · iPadOS · macOS Catalyst · tvOS

A VPN client for every Apple platform. Route import over HTTPS subscription URLs and configuration links, the VPN runtime wired through Packet Tunnel, sing-box/libbox, and Network Extension, and user flows for routes, connection state, diagnostics, and subscriptions. Shipped to the App Store with StoreKit and the platform compliance that comes with it.

Swift
Network Extension
StoreKit
sing-box / libbox
UIKit

Internal automation and tooling

Business operations · data processing

Automation and internal tools across the products: services that connect external providers and marketplaces to internal systems, REST APIs over operational data, and small Rust utilities where a Python script was the wrong tool. Included deployment, troubleshooting, and production support.

Python
Go
Rust
PostgreSQL
REST API
Docker

03How I build

A few rules I don't bend.

Not a methodology deck. Just the decisions that keep a system boring in the good way.

A service owns its data

No shared tables across service boundaries. If two services need the same rows, one of them is wrong about what it owns.

02
Events over synchronous chains
Redis Streams between services that need to stay in sync. A request that fans out into five sequential HTTP calls is a latency budget waiting to be blown.
03
Explicit contracts, versioned
A service is consumed through a documented API, not by reading its database. Contract changes ship before the code that needs them.
04
Rollback exists before the deploy
Containers, declarative deploys, health checks, and a tested way back. If I can't describe the rollback, I'm not ready to release.
05
Measure it or it's a guess
Prometheus metrics and Grafana dashboards for anything that can fail quietly. An incident should show up on a graph before it shows up in an inbox.
06
Boring infrastructure wins
The stack a team can operate at 3am beats the stack that looked good in a comparison post.

04Experience

Where the work happened.

Contract engagements and in-house roles, most recent first.

2025 — present

Contract iOS / Backend Developer

VPN serviceContract

VPN service: Telegram bots as the customer-facing layer and the engineering logic behind running it — deployment, monitoring, and keeping the service reachable. Also the native Apple client for iOS, iPadOS, macOS Catalyst, and tvOS, plus backend and API work.

2025 — 2026

Software Developer

Marketplace integrationsContract

Integrations connecting the digital goods business to the platforms it sells on: external services and marketplaces wired to internal systems, plus backend services and automation tooling for the processes around them. Deployment, troubleshooting, and production support.

2025 — 2026

Contract Software Developer

Payment railsContract

Payment side of the same digital goods business: integrations with external payment, accounting, and operations systems, REST API design, and data-processing logic. PostgreSQL, MongoDB, and Redis across Kubernetes deployment environments, with CI/CD, monitoring, and production support.

2024 — 2025

Head of Software Development

Platform developmentIn-house

Led development of the digital goods platform: product planning, coordination, and implementation across service logic, integrations, and operational tooling, alongside hands-on backend work.

05Stack

What I actually use.

Grouped by where it sits in the system.

Languages

Python · Go · Rust · Swift

Architecture

Microservices · Domain boundaries · API contracts · Redis Streams events

Data

PostgreSQL · MongoDB · Redis

Delivery

Docker · Kubernetes · GitHub Actions · CI/CD

Observability

Prometheus · Grafana · Production support

Hosting

Selectel · Yandex Cloud · OVH · Hetzner · DigitalOcean

Apple

UIKit · StoreKit · Network Extension · Packet Tunnel · sing-box / libbox

Contact

Got a system that's outgrown its shape?

A payment integration that keeps breaking, a bot that needs to survive its own success, or a monolith that should have been four services two years ago — describe it and I'll tell you how I'd take it apart.

Get in touch View GitHub profile Telegram @chydo_dev