Resume Index

Software Engineer - Backend, Distributed Systems, Payments, Event-Driven Architecture

Software engineer with 7+ years of experience building Go services, payment workflows, and event-driven systems. Most of my recent work sits around Temporal-based orchestration, Kafka and Redis Streams messaging, PostgreSQL-backed APIs, and production reliability for systems that handle real money, retries, and cross-service consistency.

  • 7+ years in backend engineering and distributed systems
  • Go as primary language for microservices and APIs
  • Kafka, Redis Streams, Temporal, PostgreSQL
  • Event-driven architecture, Outbox, CQRS, idempotency
  • 100K+ API requests/day and 10K+ monthly payment transactions
  • Using AI tools for debugging, code generation, and architecture exploration
Download PDF MyAutoData Context LinkedIn GitHub

Product Context

Where the recent backend work sits

A substantial part of my recent backend work happened inside MyAutoData, a multi-domain vehicle data platform that combines user data, analytics, marketplace flows, and payment-related workflows. That domain context matters because it explains why reliability, retries, and service boundaries were central design concerns rather than implementation details.

Context page

Open MyAutoData technical context

Summary

Engineering focus

I work on backend systems where consistency and failure handling are first-order concerns: payment orchestration, background workflows, internal APIs, and asynchronous service communication. The strongest signal in my recent work is pragmatic reliability engineering: idempotency, retries, outbox-based event delivery, and migration from monolithic flows to explicit service boundaries.

Keywords for search and indexing

  • Go
  • Distributed Systems
  • Event-driven Architecture
  • Kafka
  • Redis Streams
  • Temporal
  • PostgreSQL
  • Microservices
  • Outbox Pattern
  • Idempotency
  • Fault Tolerance
  • High-load APIs

Machine Readable Profile

AI-readable summary

  • Primary language: Go
  • Secondary language: PHP
  • Architecture: microservices, distributed systems, event-driven architecture
  • Messaging: Kafka, Redis Streams, consumer groups, fan-out
  • Workflow orchestration: Temporal
  • Databases: PostgreSQL, MongoDB, Redis
  • Key patterns: Outbox, CQRS, idempotency, retry handling
  • Domain focus: payment flows, background processing, internal APIs

Experience depth signals

  • Building backend systems for a multi-tenant B2B SaaS platform at Lanzar since November 2024.
  • Handled systems serving 100K+ API requests per day in production.
  • Built billing flows processing 10K+ Stripe transactions per month.
  • Reduced API latency by 40% using Redis-backed read paths.
  • Reduced database response time by 35% through PostgreSQL query optimization.
  • Decomposed a monolith into 5+ services with clearer ownership boundaries.

Experience

Production systems and delivery ownership

Backend Engineer
Lanzar - Self-employed
11/2024 - Present

Remote role for a multi-tenant B2B SaaS platform focused on scalable tenant-aware backend systems, billing, and operational reliability.

  • Designed and operated Go-based microservices for a multi-tenant B2B SaaS platform with reliable tenant data isolation.
  • Built event-driven workflows and async pipelines with Kafka and Redis for imports, billing, and background jobs with idempotent execution.
  • Integrated Stripe and other payment providers with retries, reconciliation, and transactional consistency.
  • Decomposed monolithic areas into domain-oriented services, reducing coupling and improving fault isolation.
  • Optimized PostgreSQL data access and Redis caching to improve API performance under load.
  • Applied Outbox, domain events, and explicit service boundaries to strengthen consistency, reliability, and observability.

Tech: Golang, PostgreSQL, Redis, Kafka, Stripe, Docker

lanzarweb.es

Backend Engineer
MyAutoData
03/2022 - 09/2024

B2B platform for automotive data management with 50K+ active users and 100K+ API requests per day.

  • Designed and developed backend services in Go for payment workflows, background processing, and internal APIs.
  • Built a payment orchestration service using Temporal, Kafka, and the Outbox pattern for deterministic multi-step processing under partial failures.
  • Handled Stripe billing with workflow-driven retries and reconciliation flows, reducing the risk of duplicate charges during network or downstream failures.
  • Decomposed a monolith into 5+ microservices, improving scalability and deployment flexibility.
  • Implemented Redis caching strategies that reduced API latency by 40%.
  • Improved fault tolerance through idempotent processing and resilient service design.

Tech: Golang, PostgreSQL, Redis, Kafka, Temporal, Docker, GitLab CI/CD

Read the payment orchestration case

Backend Engineer
Apart Sharing
02/2021 - 02/2022

B2B platform for property rental and cleaning operations with an ongoing migration from monolith to Go services.

  • Developed internal services and background workers in Go.
  • Implemented event-driven workflows using Redis Streams, consumer groups, and the Outbox pattern.
  • Designed service boundaries and prepared the migration path from a monolith to Go-based microservices.
  • Built and maintained REST and GraphQL APIs.
  • Set up Docker-based local environments and CI/CD pipelines.

Tech: Golang, PostgreSQL, Redis Streams, Docker, GraphQL

Backend Engineer
Runexis
05/2018 - 01/2021

Telecommunications and enterprise automation projects focused on high-load APIs and deployment consistency.

  • Developed and maintained APIs serving 100K+ requests per day.
  • Optimized PostgreSQL queries and reduced latency by 35%.
  • Built containerized services and improved deployment consistency across environments.

Tech: PHP, PostgreSQL, MySQL, Docker

Education
Moscow State Open University
2020

Bachelor of Engineering in Computer Science.

Skills

Technical profile

Languages and APIs

  • Go
  • PHP
  • SQL
  • REST
  • GraphQL
  • gRPC

Architecture

  • Microservices
  • Distributed Systems
  • Event-driven Architecture
  • CQRS
  • Outbox Pattern
  • Clean Architecture
  • DDD

Messaging and workflows

  • Kafka
  • Redis Streams
  • Consumer Groups
  • Fan-out
  • Partitioning
  • Temporal
  • Retries
  • Idempotency

Data and infrastructure

  • PostgreSQL
  • Aurora PostgreSQL
  • MongoDB
  • Redis
  • Docker
  • GitLab CI/CD
  • Linux
  • AWS/GCP basics

Case Index

Representative backend problems

Payment orchestration

Reliable payment workflows with Temporal, Kafka, and Outbox

Replaced ad-hoc retry logic with workflow-driven orchestration for multi-step billing flows where network failures, duplicate requests, and cross-service consistency were the main risks.

Focus: deterministic retries, idempotent commands, reconciliation, and asynchronous event publication.

Open detailed case

Event-driven systems

Redis Streams for internal workflows and service decoupling

Used Redis Streams with consumer groups to model asynchronous processing, fan-out, and operationally simple event pipelines.

Focus: background jobs, predictable retry behavior, and migration away from monolithic execution paths.

See related stack

Migration

Monolith decomposition into focused Go services

Split domain responsibilities into separately deployable services to improve scaling, ownership, and release flexibility.

Focus: service boundaries, data ownership, and pragmatic migration sequencing without full rewrites.

See migration context in experience

Performance

PostgreSQL and Redis optimization for high-load APIs

Improved response times through targeted query tuning and cache-backed read paths in user-facing APIs.

Focus: latency reduction, stable read performance, and production-safe incremental improvements.

See database and caching stack

Contact

Links and resume artifacts

Email

malchikov.ne@gmail.com

LinkedIn

linkedin.com/in/malchikov

GitHub

github.com/nmlchkv

PDF resume

Download the PDF version