Sergei Irin
Backend Developer
9+ years exp
C#
JavaScript
SQL
Python
Go
TypeScript
Reliability & Incident Response: 4/10
Active 17 days ago
+7 (925) 1240563 Invite to interview
Message
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.
Technical skills
C#
JavaScript
SQL• Junior • 9y+
Python• Senior • 7y+
Go• Senior • 5y+
TypeScript
C#
.NET• 9y+
Python
Django
FastAPI
Flask
pySpark
Go
Echo
Ruby
Ruby on Rails
Databases
MySQL
Apache Kafka• 5y+
PostgreSQL• 5y+
RabbitMQ• 5y+
Redis• 5y+
ClickHouse
MS SQL
Databricks
AI/ML
Spark
Airflow
Claude
DevOps
Azure
CI/CD
Git
Rest API
Docker Compose
Containers
Docker• 9y+
Kubernetes• 7y+
Azure DevOps• 6y+
Docker Swarm• 5y+
Jenkins• 5y+
AWS
QA
Selenium
Frontend
Angular• 9y+
React.js• 5y+
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.
Pythonsince 2024
.NET
Airflowsince 2024
ClickHousesince 2024
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
PostgreSQLsince 2021
Redis
RabbitMQ
Apache Kafkasince 2021
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.jssince 2020
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
Kubernetessince 2019
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.
.NETsince 2017
Angular
Kotlin
SQLsince 2017
Dockersince 2017
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• Senior • 7y+
Go• Senior • 5y+
Echo
Flask
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• Junior • 9y+
C#
MySQL
PostgreSQL• 5y+
Redis• 5y+
.NET• 9y+
Databricks
ClickHouse
RabbitMQ• 5y+
Azure DevOps• 6y+
Docker Swarm• 5y+
FastAPI
Ruby on Rails
Azure
MS SQL
CI/CD
Jenkins• 5y+
Django
Git
AWS
Docker• 9y+
Kubernetes• 7y+
Apache Kafka• 5y+
pySpark
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: