Sergei Irin
Backend Developer
9+ years exp
Management: 3-5 years
Python
Go
SQL
JavaScript
TypeScript
C#
Reliability & Incident Response: 4/10
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A backend-focused platform/SRE engineer at a senior level who builds and tests high-load distributed services and multi-node database topologies. The strongest proven skill is designing and implementing distributed-database application logic and orchestration - evidenced by the Go Coordinator with ProxySQL and Redis-based dedicated-host promotion (RinSer/HighloadArchitect_HW4/dialogues/coordinator.go) and multi-node compose environments. There is limited evidence of production-grade CI/CD, IaC best practices (remote state, modules), observability stacks, runbooks, or cloud cost automation in public code.
Phone
Technical skills
Languages
6
Python
Go
SQL
JavaScript
TypeScript
C#
Databases
7
PostgreSQL
Apache Kafka
Redis
ClickHouse
RabbitMQ
MS SQL
Databricks
DevOps
6
Docker
Kubernetes
AWS
Azure DevOps
Jenkins
Docker Swarm
Other
20
.NET
React.js
Angular
Flask
Airflow
Echo
pySpark
Django
MySQL
Azure
Claude
FastAPI
Ruby on Rails
Docker Compose
Selenium
Rest API
Containers
Spark
Git
CI/CD
Timeline
Senior Backend Engineer
•
Senior
Constructor
•
Full-Time
Developed and supported high-throughput, high-availability microservices. Designed technical solutions and wrote system documentation, and built CI/CD pipelines using Infrastructure as Code. Implemented machine learning components and built big data workflows with Airflow and Luigi, using Databricks/PySpark for dataset analysis. Also built front-end components with React and TypeScript and integrated custom skills for the Claude AI platform.
Python
Flask
FastAPI
AWS
Docker
Databricks
pySpark
Airflow
ClickHouse
Claude
React.js
TypeScript
DWH Lead
•
Lead
Innova
•
Full-Time
Led a team responsible for developing and supporting enterprise data marts and analytical tools. Designed and upgraded data processing infrastructure to improve scalability and performance. Architected and developed new B2B services and analytical tooling, and performed code reviews while enforcing best practices across the team.
Python
.NET
Airflow
ClickHouse
MS SQL
PostgreSQL
Docker
Kubernetes
Apache Kafka
YouTrack
Senior Software Engineer
•
Senior
Innova
•
Full-Time
Led development and refactoring of backend services using C# and Go, focusing on performance improvements and scalability. Designed backend architectures for integrations with external services and implemented database schemas. Wrote unit and end-to-end tests, produced technical documentation, mentored junior and middle developers, and collaborated through code reviews.
.NET
Go
C++
React.js
PostgreSQL
Redis
RabbitMQ
Apache Kafka
Docker Swarm
Jenkins
National Research Nuclear University
Master's Degree •
Computer science
Software Engineer
•
Middle
Microsoft
•
Full-Time
Refactored and optimized legacy applications to improve performance and scalability. Upgraded a WebForms UI to a React-based interface to improve user experience and maintainability. Developed SQL scripts (T-SQL), stored procedures and functions, and configured automated CI/CD pipelines using PowerShell and Azure DevOps.
.NET
SQL
React.js
Azure DevOps
PowerShell
Senior Software Engineer
•
Senior
Sberbank
•
Full-Time
Designed and developed backend web services for internal enterprise applications using .NET Core. Implemented a WPF desktop application and migrated legacy systems to new platforms. Set up CI/CD deployments using Docker, Kubernetes, and TeamCity for release automation.
.NET
SQL
Docker
Kubernetes
TeamCity
Leading Software Engineer
•
Lead
Guta group
•
Full-Time
Developed enterprise web services and applications using .NET Framework/.NET Core and Angular. Built mobile IoT applications for Android and managed deployment and environment configuration. Led a development team through code reviews and task assignment, and contributed to service implementation and integration.
.NET
Angular
Kotlin
SQL
Docker
Senior DevOps Engineer
Confidence: Medium Platform SRE
A backend-focused platform/SRE engineer at a senior level who builds and tests high-load distributed services and multi-node database topologies. The strongest proven skill is designing and implementing distributed-database application logic and orchestration - evidenced by the Go Coordinator with ProxySQL and Redis-based dedicated-host promotion (RinSer/HighloadArchitect_HW4/dialogues/coordinator.go) and multi-node compose environments. There is limited evidence of production-grade CI/CD, IaC best practices (remote state, modules), observability stacks, runbooks, or cloud cost automation in public code.
CI/CD Pipelines
Automated build and deploy
Not evidenced in public code
Infrastructure as Code
2/10
Managing servers with code
Basic infrastructure-as-code artifacts exist (Dockerfiles and docker-compose / env.yml) but no versioned IaC modules, remote state, or infra tests; these are primarily instance/container provisioning and orchestration skeletons.
Evidence
RinSer/HighloadArchitect_HW3/Dockerfile: Galera cluster Dockerfile building MySQL/Galera nodes
RinSer/HighloadArchitect_HW4/env.yml: multi-node docker-compose style environment defining multiple MySQL instances, proxysql and redis
RinSer/HighloadArchitect_HW2/db.yml: docker-compose for single MySQL + adminer
Containerization & Orchestration
3/10
Working with containers
Container and orchestration work is present via Dockerfiles and multi-container compose files for multi-node DB topologies and ProxySQL, but lacks Kubernetes manifests, resource tuning, probes, or Pod disruption strategies.
Evidence
Observability & Monitoring
2/10
Watching system health
Some performance-observability tooling exists (a Go tool that parses load-test CSV, produces HDR histograms and scatter plots) but there is no evidence of production monitoring, alerting, dashboards-as-code, or SLO-driven alerts.
Reliability & Incident Response
4/10
Keeping systems up
Clear reliability-oriented engineering for a distributed DB-backed service: transactional patterns, context cancellation, host initialization and dynamic dedicated-host promotion based on user load; tests and a heavy benchmark are included. However, there are no runbooks, canary/blue-green deploy manifests, or incident postmortems.
Evidence
RinSer/HighloadArchitect_HW4/dialogues/coordinator.go: transactional AddUser/AddMessage with commit/rollback, context handling, host initialization and dynamic dedicated-host promotion via redis
RinSer/HighloadArchitect_HW4/main_test.go: unit tests and a BenchmarkAddMessages demonstrating performance-focused testing
Cloud & Cost Optimization
2/10
Smart use of the cloud
There is some thought for scaling and cost trade-offs at the application level - e.g., using ProxySQL, multiple MySQL nodes and promoting heavy users to dedicated hosts - but no explicit autoscaling, spot/eviction handling, rightsizing analysis or cloud cost tooling.
Expertise
Site Reliability Engineering• Senior
Platform Engineering & IDP• Middle
Technologies
Python• since 2019 • Senior
Go• since 2021 • Senior
Echo
Flask• since 2025
Recommendations
- Own and expand platform-level automation: convert the multi-node compose setup into versioned IaC (Terraform/CloudFormation/CDK) with remote state, locking and environment separation.
- Implement production observability: add Prometheus/Grafana export, instrument services with OpenTelemetry, and codify SLO-based alerts and alert routing.
- Harden deployments and secrets: replace plaintext credentials with SOPS/Vault or workload identity and add deploy strategies (canary/rollback) with automated gates.
- Build pipeline engineering: add reproducible CI pipelines with reusable workflows, caching strategy, artifact signing and deploy gates for safe rollouts.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle QA Engineer
Confidence: Medium Generalist
A backend-focused generalist at an early professional level who can build simple REST services, schema migrations and synthetic data loaders. The strongest proven skill is implementing REST endpoints and DB migration/data-loading logic, concretely shown in app.py, api.py and the init_db.sql/init.py scripts. The codebase lacks test automation, CI integration and structured error handling, so automated QA, contract testing and performance test harnesses are not evidenced.
Test Automation Frameworks
1/10
Building automated tests
Minimal evidence of any test automation framework. No fixtures, factories, mock servers, or parallelization/sharding configuration are present; the codebase contains Flask endpoints but no test harness or selector discipline.
Evidence
HighloadArchitect_HW7/app.py: Flask routes exposed but no test files or fixtures
HighloadArchitect_HW1/api.py: Flask endpoints implemented with no accompanying automation
Test Coverage & Strategy
1/10
What and how to test
No visible test coverage strategy or risk-based test organization. There are only application endpoints and migration scripts; negative-paths, boundary tests, property-based tests and mutation testing are absent.
Evidence
HighloadArchitect_HW7/app.py: multiple REST endpoints but no test suites or tagging
HighloadArchitect_HW1/api.py: authentication and friends logic present without tests
API & Integration Testing
2/10
Testing how parts work together
Some integration-oriented artifacts exist (DB migration endpoints and SQL schema) but there is no contract testing, schema validation in tests, idempotency checks or testcontainers-based integration harness.
Evidence
HighloadArchitect_HW1/api.py: /run_migration endpoint executes init_db.sql
HighloadArchitect_HW7/init_db.sql: schema definition for profiles table
Performance & Load Testing
1/10
Testing speed under load
Small signs of data-volume awareness (bulk data generation) but no real load testing harness, thresholds, SLOs, or percentile analysis.
Evidence
HighloadArchitect_HW7/init.py: nested loops inserting large numbers of profile rows for synthetic dataset generation
Bug Reporting & Analysis
1/10
Finding and describing bugs
Minimal operational logging and progress prints exist during migrations and data loads, but there are no reproducible bug reports, root-cause analyses, or flaky-test investigations.
Evidence
HighloadArchitect_HW7/init.py: print statements reporting progress of committed profiles
CI Test Integration
Running tests automatically
Not evidenced in public code
Expertise
Manual & Exploratory Testing• Junior
Industries
Internet Services• Middle
Technologies
Containers
Rest API
Selenium
Docker Compose
Recommendations
- Develop and maintain a small automated test suite (pytest) covering negative paths and boundary cases for the Flask endpoints; add schema validation assertions for responses.
- Introduce simple CI workflows that run the test suite and collect artifacts; add per-test fixtures that isolate DB state (testcontainers or dedicated test DB) and data factories instead of global state.
- Replace hard-coded secrets with configuration and add basic error handling around DB/cache connections and query results to make endpoints robust under failure.
- Create a lightweight contract/integration test that validates migration scripts and the /run_migration endpoint using schema assertions.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Intern Backend Developer
Confidence: Low Generalist
An entry-level backend engineer (Intern) with very little original backend code visible in the HUMAN-AUTHORED files. The strongest proven skill is basic Python web-framework familiarity, evidenced by Flask artifacts (HighloadArchitect_HW2/app.py, HighloadArchitect_HW3/app.py) and Django/DRF items referenced in the dependency and file lists (bitfinexapi/requirements.txt, bitfinexapi/bitfinexapi/views.py). There is no substantive public evidence of independent system design, migration history, resilience patterns, testing, or operational hardening.
API Design
How well APIs are designed
Not evidenced in public code
Data Layer & Database
Working with databases
Not evidenced in public code
Scalability & Performance
Handling load and speed
Not evidenced in public code
System Architecture
Overall system structure
Not evidenced in public code
Security & Auth
Protecting data and access
Not evidenced in public code
Reliability & Observability
Stability and monitoring
Not evidenced in public code
Expertise
Python• Intern
Microservices & API Architecture• Intern
Technologies
SQL• since 2017 • Junior
C#
MySQL
PostgreSQL• since 2021
Redis• since 2021
.NET• since 2017
Databricks• since 2025
ClickHouse• since 2024
RabbitMQ• since 2021
Azure DevOps• since 2020
Docker Swarm• since 2021
FastAPI• since 2025
Ruby on Rails
Azure
MS SQL• since 2024
CI/CD
Jenkins• since 2021
Django
Git
AWS• since 2025
Docker• since 2017
Kubernetes• since 2019
Apache Kafka• since 2021
pySpark• since 2025
Recommendations
- Focus on producing small, original backend features end-to-end (CRUD endpoints with tests) using Flask or Django so reviewers can evaluate design and ownership.
- Add explicit data-layer artifacts: schema migrations, transaction boundaries and a migration history (Alembic or Django migrations) with at least one non-trivial schema evolution.
- Instrument basic observability and resilience: structured logging with request ids, timeouts and retries with exponential backoff, and a minimal metrics/alerts setup.
- Add unit and integration tests (data-layer and API contract tests) and a short README or CONTRIBUTING that documents how to run tests and schema migrations locally.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: