Andrei Martynenko

Backend Engineer (Go)

Event-Driven Systems | Financial Systems | Distributed Processing

Designing backend systems for data-driven and financial environments. Backend engineer specialising in Go and event-driven architectures, combining software engineering with over 10 years of financial domain experience in regulated banking environments. My work focuses on building reliable backend services where correctness, traceability and predictable behaviour under load are critical.

Projects GitHub LinkedIn Download CV

Profile

SMBC

Deutsche Bank

Alfa-Bank

My background combines financial systems experience with backend engineering.

I have hands-on experience with:

Event-driven processing pipelines
Idempotent transaction handling
Deterministic system outputs
Audit-friendly data modelling
Controlled concurrency and backpressure

Working within regulated banking environments shaped how I approach system design — with a strong focus on correctness, reproducibility, and operational reliability.

These patterns are particularly important in systems processing financial or operational events where reliability and reproducibility matter.

Engineering Approach

I build backend systems in Go with emphasis on:

API-driven backend services
Event-driven processing pipelines
Idempotent request handling
Controlled concurrency and bounded worker pools
Explicit retry and timeout policies
Backpressure and graceful degradation
Reproducible and deterministic processing flows

The focus is building systems where behaviour is explicit, observable, and operationally reliable.

Projects

Proof-of-Signal — Event-Driven Signal Processing Platform

Backend system demonstrating event-driven processing pipelines with deterministic output verification.

GitHub View platform Download presentation

Proof-of-Signal platform architecture screenshot

Problem / Focus

Backend system demonstrating event-driven processing pipelines where a Go API gateway ingests data events and integrates with a Python ML service for signal enrichment. Each generated signal produces a deterministic SHA-256 proof hash allowing outputs to be reproduced and verified across runs. The project focuses on backend architecture patterns rather than trading logic.

Key engineering aspects

Event ingestion and normalization pipelines
Deterministic processing and idempotency
Multi-service architecture (Go gateway + ML service)
Background workers for signal processing
Reproducible outputs using cryptographic hashing

Tech stack

Go PostgreSQL Redis Docker Python (FastAPI)

What it solves

A deterministic event-driven processing pipeline where a Go gateway ingests data events and a Python service enriches them to produce reproducible signals.