Egor Anisevich
Golang Developer
1+ project
Go
C
Python
C++
Data Layer & Database: 6/10
Scalability & Performance: 6/10
System Architecture: 6/10
Active 6 days ago
+7 (910) 0848877 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A Senior-level backend API engineer who primarily builds Python services integrating external systems and LLM tooling. The strongest proven skill is designing and implementing async, concurrent integrations with external APIs and CPU-bound offloads - for example backend/api/user/polygon/archive/uploader.py (PolygonImportClient, semaphore, retries, run_import) and the ProcessPoolExecutor usage for plagiarism checks. There is limited public evidence of large distributed systems tooling (Kafka/streaming), vector-database work, or extensive infra/observability (metrics/tracing) beyond logging and tests.
Technical skills
Go
C
Python• Senior • 3y+
C++
Python
Asyncio
Alembic
SQLAlchemy
FastAPI
Aiohttp
Pydantic
Uvicorn
HTTPX
Databases
Apache Kafka
ClickHouse
RabbitMQ
Redis
PostgreSQL
AI/ML
AI Agents• 1 project
LangChain• 1 project
PyTorch• 1 project
RAG• 1 project
DevOps
Docker
Nginx
Docker Compose
Containers
HAProxy
CI/CD
Kubernetes
GitHub Actions
Timeline
Team Lead and Fullstack Developer
•
Lead
CreateManager
•
Full-Time
Served as team lead while working on fullstack development for CreateManager. Implemented CI/CD automation for automatic server deployment and automatic execution of tests and linters. Supported delivery workflows using Docker and GitHub Actions.
GitHub Actions
CI/CD
Go and Python Backend Developer
•
Middle
X5 Tech
•
Full-Time
Worked on a backend for a unified mobile application within a team. Improved CI/CD pipeline performance by about 1.4x and reduced Docker image memory usage by about 2.1x. Contributed to building and operating services using Kubernetes-based deployment workflows.
Kubernetes
CI/CDsince 2024
National Research University Higher School of Economics
Bachelor's Degree •
Software Engineer
Backend Developer Intern
•
Junior
Yandex
•
Internship
Developed and maintained shared backend components within the Userver ecosystem using C++ and Python. Contributed to implementation and integration of common services used across projects. Worked as part of a backend internship group focused on reusable infrastructure components.
C++
Python
Senior Backend Developer
Confidence: High API Engineer
A Senior-level backend API engineer who primarily builds Python services integrating external systems and LLM tooling. The strongest proven skill is designing and implementing async, concurrent integrations with external APIs and CPU-bound offloads - for example backend/api/user/polygon/archive/uploader.py (PolygonImportClient, semaphore, retries, run_import) and the ProcessPoolExecutor usage for plagiarism checks. There is limited public evidence of large distributed systems tooling (Kafka/streaming), vector-database work, or extensive infra/observability (metrics/tracing) beyond logging and tests.
API Design
5/10
How well APIs are designed
API design is pragmatic and consistent (FastAPI routers, pydantic validation, pagination and filtering), but lacks an explicit versioning strategy or advanced idempotency primitives.
Evidence
backend/api/user/plagiarism/base_plagiarism.py: get_report - pagination (page/per_page) and filtering
backend/api/user/polygon/problems/*.py: many route definitions and routers (APIRouter usage)
backend/api/user/gpt/routes/chat/chat.py: unified_chat - request routing and action classification
Data Layer & Database
6/10
Working with databases
Solid data-layer work: SQLAlchemy 2.0 async models, alembic migration history, use of joinedload/selectinload to avoid N+1 and explicit commits where appropriate.
Evidence
backend/models/*.py: declarative models using SQLAlchemy mapped_column and relationships
backend/alembic/versions/*: multiple migration files present (migration_chain)
backend/api/user/plagiarism/base_plagiarism.py: queries using joinedload/selectinload and select/func
Scalability & Performance
6/10
Handling load and speed
Concurrency and performance decisions are deliberate - async I/O, throttling, process-pool for CPU-bound work and bounded concurrency for external API calls - though no load-test artifacts are present.
Evidence
backend/api/user/polygon/archive/uploader.py: PolygonImportClient uses aiohttp with asyncio.Semaphore(MAX_CONCURRENT_REQUESTS) and retry/backoff
backend/api/user/polygon/archive/uploader.py: run_import uses loop.run_in_executor for CPU-bound parse and asyncio.gather for concurrent uploads
backend/api/user/plagiarism/base_plagiarism.py: _plagiarism_executor ProcessPoolExecutor to offload C++ similarity computation
System Architecture
6/10
Overall system structure
Clear module boundaries and reasoned service decomposition (polygon, gpt, plagiarism, codeforces); background job design and sync layers are implemented, but there is limited evidence of multi-service contract/version management or advanced cross-service degradation policies.
Evidence
backend/api/user/gpt/ services and routes: extensive modularization of LLM/generation, file sync and session management
backend/api/user/polygon/archive/uploader.py: background import job design with ImportJob and per-problem ProblemStatus
app/server.py: application lifecycle handlers, exception handlers and middleware wiring
Security & Auth
6/10
Protecting data and access
Security basics are present - salted password hashing, JWT creation/verification, dependency-based auth and input validation with pydantic; secret/config management uses settings but full secrets-rotation/auditing traces are not visible.
Evidence
backend/api/crypt/crypt_password.py: hash_password and verify_password using passlib
backend/api/crypt/jwt_token.py: create_token, verify_token and fastapi dependency helpers
backend/api/pydantic_schemas/user/auth.py: validation rules for auth inputs
Reliability & Observability
6/10
Stability and monitoring
Good reliability and observability practices: logging, retries with backoff, timeouts, per-job error recording, background job resilience and many unit tests that exercise error paths; lacks explicit metrics/alerting or structured tracing integration in the visible code.
Evidence
backend/api/user/polygon/archive/uploader.py: retry/backoff logic in PolygonImportClient.call and per-problem error recording
app/middlewares/log_middleware.py and tests under backend/tests/unit/app/middlewares/test_log_middleware.py
backend/api/user/plagiarism/base_plagiarism.py: careful exception handling and DB commit patterns around ban/unban flows
Verified artifacts
Expertise
Backend AI & LLM• Senior
Python• Senior
Microservices & API Architecture• Middle
System Architecture• Senior
Industries
Education• Middle
Software• Middle
Recommendations
- Lead development of REST APIs that integrate third-party systems and LLMs, including background importers and job status systems (e.g., polygon importer style).
- Implement or extend async ingestion pipelines and CPU-bound offloads with robust retries and throttling (ProcessPoolExecutor + asyncio patterns shown).
- Own backend features that need careful DB schema evolution and migrations (Alembic + SQLAlchemy models present).
- Ship features that require secure auth/token handling and session lifecycle (JWT/password handling and token rotation).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle AI/ML Engineer
Confidence: Medium Generalist
A senior-level backend engineer with strong applied systems engineering skills in parsing, integration and concurrency. The strongest proven skill is robust document/archive parsing and test generation, demonstrated by the PDF-to-TeX parser and test grouping/normalization code in the archive parser (backend/api/user/polygon/archive/parser.py). Public code does not show custom ML model training, experiment tracking or model serving infrastructure.
Model Architecture & Training
How well models are designed and trained
Not evidenced in public code
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Robust data-processing and normalization pipelines for contest archives and tests, with careful deduplication and sample detection logic.
Evidence
backend/api/user/polygon/archive/parser.py:build_tests - test grouping, sample detection, duplicate detection and renumbering
backend/api/user/polygon/archive/parser.py:polygon_test_norm - normalization to match Polygon's comparison rules
backend/api/user/polygon/archive/parser.py:parse_archive - end-to-end archive parsing and task assembly
Experimentation & Evaluation
How results are measured and tested
Not evidenced in public code
MLOps & Deployment
How models are shipped to production
Not evidenced in public code
Computational Efficiency
6/10
How efficiently computing resources are used
Deliberate concurrency and CPU/IO separation: bounded concurrency for network calls, worker offloading for CPU-bound parsing and a process pool for C++ plagiarism work.
Evidence
backend/api/user/polygon/archive/uploader.py:PolygonImportClient - asyncio.Semaphore(MAX_CONCURRENT_REQUESTS) and shared aiohttp session with retry/backoff
backend/api/user/polygon/archive/uploader.py:run_import - parsing run in executor via loop.run_in_executor to avoid blocking the event loop
backend/api/user/plagiarism/base_plagiarism.py:_plagiarism_executor - ProcessPoolExecutor used to run C++ similarity computation off the event loop
Research Depth & Innovation
4/10
Depth of research and new ideas
Non-trivial document parsing and rendering logic (PDF -> TeX) implementing heuristics for math, superscripts/subscripts and table classification; engineering depth but not research novelty.
Evidence
backend/api/user/polygon/archive/parser.py:line_to_tex - span-level font-size and baseline handling to reconstruct math/superscripts
backend/api/user/polygon/archive/parser.py:extract_page_items and split_statements - table classification, example extraction and per-problem statement splitting
Expertise
Document Intelligence & OCR• Middle
Industries
Software• Middle
Technologies
C++
PostgreSQL
Redis
ClickHouse
RabbitMQ
GitHub Actions
CI/CD
Docker
Kubernetes
Nginx
Apache Kafka
Asyncio
HTTPX
Aiohttp
Recommendations
- Develop backend services that require robust file parsing and data normalization - e.g., archive importers, OCR post-processing pipelines and structured-extraction services.
- Implement integrations with third-party APIs that demand careful concurrency and retry logic - e.g., bulk uploads, signed API clients and asynchronous import jobs.
- Build data-processing microservices that need CPU/IO isolation - use this developer to design run_in_executor/process-pool pipelines and bounded-concurrency HTTP clients.
- Lead engineering work to harden automated content ingestion (tests, deduplication, canonicalization) and edge-case handling for production-grade pipelines.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior DevOps Engineer
Confidence: Medium Generalist
A middle-level generalist DevOps engineer who builds and operates self-hosted containerized network services. The strongest proven skill is deploying and operating a multi-service container stack, demonstrated by the multi-stage Dockerfile, the docker-compose.yml with healthchecks and service dependencies, and a Makefile with deploy/migrate/backup targets. Public artifacts do not show CI/CD pipelines, cloud autoscaling, advanced observability or progressive deployment strategies.
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 and operator automation via docker-compose, Makefile targets and shell scripts; no remote state, Terraform modules, environment-separated IaC or infra testing present.
Containerization & Orchestration
3/10
Working with containers
Concrete containerization work with a multi-stage Dockerfile, reasonable image selection and healthchecks in compose; lacks k8s manifests, resource requests/limits rationale, non-root containers or advanced orchestration patterns.
Observability & Monitoring
2/10
Watching system health
Basic observability signals exist - health endpoints and container healthchecks - but no SLOs, burn-rate alerts, alert routing or dashboards-as-code were found.
Reliability & Incident Response
3/10
Keeping systems up
Operational discipline is visible: alembic migrations, Makefile-driven predeploy/migrate/render/backup flows and restore tooling; there is no evidence of progressive deploy strategies, runbooks, or chaos/rehearsed DR.
Cloud & Cost Optimization
1/10
Smart use of the cloud
No cloud provider integration, autoscaling or cost-optimization artifacts; deployment appears targeted at single-host/container-compose self-hosting.
Expertise
Service Mesh & Networking• Junior
Industries
Internet Services• Junior
Technologies
Containers
Python• Senior • 3y+
Docker Compose
SQLAlchemy
FastAPI
HAProxy
Pydantic
Uvicorn
Alembic
Recommendations
- Lead development and ops for self-hosted networking products and edge services (VPN appliances, reverse-proxy and SNI routing stacks).
- Implement end-to-end CI/CD pipelines (reusable workflows, artifact signing and gated deploys) for container builds and infra changes.
- Add observability and SLO-driven alerts (Prometheus metrics, alert routing and burn-rate rules) and integrate dashboards-as-code.
- Harden release practices with progressive delivery (canary/blue-green), documented rollback criteria and automated infra testing.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: