Nikolai Vasilev

Software Engineer

Berlin, Germany7 yrs 1 mo experience

AI ML PractitionerAI Enabled

Key Highlights

Decomposed monoliths with zero-downtime migration.
Scaled systems handling millions of ad impressions and messages.
Reduced infrastructure costs and boosted conversion rates.

Stackforce AI infers this person is a Backend Developer specializing in Fintech and Advertising Technology with expertise in high-load systems.

Contact

Skills

Core Skills

GolangPayment ProcessingAdvertising TechnologySoftware ArchitectureDatabase OptimizationChatbot Technology

Other Skills

PostgreSQLRedisKafkagRPCRESTDockerKubernetesAWSPrometheusGrafanaDatadogKYC/KYBWebhook SystemsEvent-drivenJava

About

WhatsApp: https://wa.me/447412800762 Senior Go Developer with 7+ years of experience building high-load backend systems: ad platforms, chatbots, billing, real-time communications, and fintech payments. Decompose monoliths into microservices, design event-driven architectures on Kafka (DLQ, retry, idempotency), and establish full observability stacks from scratch. Key highlights: → Decomposed two production monoliths (Java → Go, Kotlin → Go) using Strangler Fig pattern with zero-downtime migration → Scaled systems handling millions of ad impressions/day and 50,000+ messages/day (p99 < 100ms) → Reduced infrastructure costs by 35%, cut p95 latency by 40%, and boosted paid conversion by 25% Tech stack: Go, PostgreSQL, YDB, Kafka, Redis, gRPC, GraphQL, MongoDB, ScyllaDB, ClickHouse, Docker, Kubernetes, Prometheus, Grafana, Jaeger, ELK. English C1 — fluent in international team communication.

Experience

7 yrs 1 mo

Total Experience

2 yrs 6 mos

Average Tenure

2 yrs 1 mo

Current Experience

Rainforest

Golang Developer

Apr 2024 – Present · 2 yrs 1 mo · United States · Remote

Own core payment processing services for an embedded payments platform purpose-built for vertical SaaS — processing billions in annual volume across card, ACH, Apple Pay, and alternative payment methods. Design and implement Go microservices for merchant onboarding, transaction orchestration, and real-time settlement, ensuring PCI DSS compliance at every layer. Drive webhook-based event architecture for payment lifecycle notifications and integrate third-party acquiring and risk providers.
Stack: Go, PostgreSQL, Redis, Kafka, gRPC, REST, Docker, Kubernetes, AWS, Prometheus, Grafana, Datadog
Key results:
→ Designed merchant onboarding service handling KYC/KYB verification flows with automated risk scoring — reduced merchant approval time from 48 hours to under 15 minutes for 80% of applications
→ Built multi-acquirer transaction routing engine in Go with configurable fallback logic and real-time BIN lookup — improved authorization rates by 12% and reduced processing failures by 30%
→ Implemented webhook delivery system with at-least-once guarantees, retry with exponential backoff, and dead letter queue — serving 2M+ webhook events/day at p99 under 200ms
→ Reduced settlement reconciliation errors by 70% by building an event-sourced ledger service with penny-perfect reporting and automated daily deposit calculations
→ Integrated PayPal/Venmo as alternative payment methods via single unified API, enabling platforms to accept 5 payment types through one checkout flow with zero additional onboarding

GolangPostgreSQLRedisKafkagRPCREST+7

Yandex

Software Engineer - Yandex Ads

May 2022 – Apr 2024 · 1 yr 11 mos · Remote

Own core services for an advertising platform serving millions of ad impressions per day: partner program management, recommendation engines, and ad format processing. Design and implement Go microservices from scratch, decompose legacy Java monolith modules, and integrate third-party systems via gRPC. Establish end-to-end observability (Prometheus, Jaeger, ELK, Grafana) and mentor junior engineers.
Stack: Go, Java, PostgreSQL, YDB, Redis, Kafka, gRPC, Docker, Kubernetes, Prometheus, Grafana, ELK, Jaeger
Key results:
→ Decomposed a Java monolith into Go microservices using Strangler Fig pattern — migrated 4 core modules over 8 months with zero-downtime traffic switching
→ Increased cross-sell conversion by 18% by extending the recommendation microservice with personalized up-sell logic, integrating 3 third-party systems via gRPC
→ Reduced p95 latency by 40% on critical endpoints through composite index optimization in PostgreSQL and YDB (EXPLAIN ANALYZE, degradation monitoring)
→ Cut PostgreSQL load by 50% by implementing hot data caching in Redis with Kafka event-driven invalidation
→ Built an ad format management service with creative adaptation (ImageMagick/FFmpeg), supporting 12+ formats with automated validation and Kafka-based processing queue
→ Designed partner program service from scratch: referral link generation, click/conversion tracking, and analytics dashboards for 500+ partners
→ Mentored 4 interns and junior developers, conducted code reviews, and participated in technical onboarding

GolangJavaPostgreSQLYDBRedisKafka+8

Chatfuel

Golang Developer

Apr 2019 – May 2022 · 3 yrs 1 mo · United Kingdom · Remote

Own the core backend of a global chatbot platform with millions of users: bot processing engine, billing system, real-time live chat, and mass broadcasting. Drive the large-scale migration from a Kotlin monolith to Go microservices. Design event-driven pipelines on Kafka, build payment integrations (Stripe), and implement real-time communication over WebSocket/gRPC.
Stack: Go, GraphQL, gRPC, Kafka, MongoDB, ScyllaDB, ClickHouse, Redis, WebSocket, Docker, Kubernetes, Prometheus, Grafana
Key results:
→ Migrated Kotlin monolith to 6 Go microservices over one year using Strangler Fig pattern — reduced infrastructure costs by 35% and shortened release cycle from 2 weeks to 3 days
→ Built bot processing engine handling 50,000+ messages/day with p99 latency under 100ms: message parsing pipeline, scenario-based routing, and action execution
→ Increased paid conversion by 25% with a billing microservice: Stripe + local payment integrations, subscription management, automated upgrade/downgrade flows, webhook-based event handling
→ Built a live chat system on WebSocket + gRPC supporting 10,000 concurrent connections with persistent history in ScyllaDB and graceful reconnect
→ Delivered up to 10,000 messages/hour via mass broadcasting service on Kafka with rate limiting, retry logic, and dead letter queue (guaranteed delivery)
→ Reduced frontend network calls by 60% by designing a GraphQL API with request batching and DataLoader pattern
→ Set up analytics ETL pipeline: bot event aggregation via Kafka into ClickHouse with dashboards for conversion, retention, and engagement metrics
→ Built CI/CD pipeline in GitLab: automated tests, linting, Docker builds, canary deployments to Kubernetes with automatic rollback on metrics