Georgev Tolkachev
Backend Developer
Node JS
TypeScript
JavaScript
Python
SQL
Model Architecture & Training: 6/10
Data Pipeline & Feature Engineering: 6/10
Experimentation & Evaluation: 6/10
Active 8 days ago
+7 (965) 5228758 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A practical ML engineer at a senior level who builds end-to-end applied ML systems integrating model training, validation, and production serving. The strongest proven skill is delivering production-ready ML services - evidenced by the training pipelines with GridSearch/CV and the FastAPI backend with async DB, Redis caching, Alembic migrations and monitoring hooks. The public code shows solid applied ML and serving engineering but not low-level efficiency work (quantization/CUDA/Triton), novel research architectures, or large-scale distributed training artifacts.
Technical skills
Node JS
TypeScript
JavaScript
Python• Senior • 3y+
SQL• Junior
Python
Alembic
Pydantic
Celery
FastAPI
SQLAlchemy
Databases
Databases
PostgreSQL
Redis
AI/ML
Scikit-learn
Pandas
LLM
RAG
DevOps
Docker Compose
Containers
Nginx
Docker• 3y+
Rest API
Frontend
Next.js
React.js
Timeline
Backend Developer
•
Middle
BEM - Velikiye Luki LLC
•
Full-Time
Designed and deployed a high-load backend service with FastAPI (async/await), including endpoint structure, validation, and robust error handling. Integrated external APIs and internal microservices with timeout/retry/fallback logic. Audited and optimized PostgreSQL queries and ORM hot paths with SQLAlchemy, and reduced API latency. Implemented background jobs with Celery using Redis and RabbitMQ, improving throughput of the main service, and added pytest-based unit/integration testing and CI checks; containerized services with Docker and supported GitLab CI/deployment.
FastAPI
SQLAlchemy
PostgreSQL
Redis
Celery
Docker
Python
Rest API
LLM
RAG
Senior AI/ML Engineer
Confidence: Medium ML Engineer
A practical ML engineer at a senior level who builds end-to-end applied ML systems integrating model training, validation, and production serving. The strongest proven skill is delivering production-ready ML services - evidenced by the training pipelines with GridSearch/CV and the FastAPI backend with async DB, Redis caching, Alembic migrations and monitoring hooks. The public code shows solid applied ML and serving engineering but not low-level efficiency work (quantization/CUDA/Triton), novel research architectures, or large-scale distributed training artifacts.
Model Architecture & Training
6/10
How well models are designed and trained
Sound applied model-building and training practice: pipelines, CV, GridSearch, thresholding, and model bundle saving for inference.
Evidence
PredictiveMaintenanceSystem/model_training_pipeline.ipynb: end-to-end training flow, GridSearchCV, pipeline with SMOTE and SVM, threshold search and joblib.dump of model bundle
PredictiveMaintenanceSystem/multiclass_pipeline.ipynb: cascade binary→multiclass training and model selection (RandomForest/SVM)
PredictiveMaintenanceSystem/backend/app/ml/inference.py: load_models and predict functions for runtime inference (ModelBundle pattern)
Data Pipeline & Feature Engineering
6/10
How data is prepared for models
Clear EDA and feature engineering plus an explicit preprocessing module and unit tests for feature behavior.
Evidence
PredictiveMaintenanceSystem/exploratory_data_analysis.ipynb: thorough EDA and data cleaning steps
PredictiveMaintenanceSystem/model_training_pipeline.ipynb: engineered features (temp_diff, power, tool_wear_torque) and encoding decisions
PredictiveMaintenanceSystem/backend/app/ml/preprocessing.py: engineer_features function
Experimentation & Evaluation
6/10
How results are measured and tested
Reasoned evaluation and validation: stratified splits, CV, ablation-like model comparisons, metric-driven threshold tuning and test isolation with unit/integration tests.
Evidence
PredictiveMaintenanceSystem/model_training_pipeline.ipynb: stratified train/val/test, cross_val_score, precision-recall threshold search and test-time evaluation
PredictiveMaintenanceSystem/multiclass_pipeline.ipynb: cross-validation and GridSearchCV for multiclass models
PredictiveMaintenanceSystem/backend/tests/unit/test_inference.py and backend/tests/integration/test_api.py: automated tests covering inference and API persistence
MLOps & Deployment
6/10
How models are shipped to production
Production-ready serving and lifecycle work: FastAPI app, async DB + Alembic migrations, Redis caching, Prometheus instrumentation, structured error handling and a process manager for Modal deployments.
Evidence
PredictiveMaintenanceSystem/backend/main.py: FastAPI app lifecycle, model loading and integration of logging/metrics/middleware
PredictiveMaintenanceSystem/backend/alembic/env.py: async alembic migration setup using async_engine_from_config and app.db.Base
PredictiveMaintenanceSystem/backend/app/core/config.py: typed settings, DATABASE_URL assembly and get_settings singleton
Computational Efficiency
2/10
How efficiently computing resources are used
Minimal explicit compute optimization; uses standard ML efficiency knobs (pipeline, n_jobs) but no low-level GPU/quantization or memory profiling artifacts.
Evidence
PredictiveMaintenanceSystem/model_training_pipeline.ipynb: GridSearchCV with n_jobs=-1 and use of pipelines
PredictiveMaintenanceSystem/model_training_pipeline.ipynb and multiclass_pipeline.ipynb: use of StandardScaler and careful pipeline placement to avoid leakage
Research Depth & Innovation
2/10
Depth of research and new ideas
Applied, pragmatic ML (classical models and pipeline engineering) rather than new research or custom layers; strong applied reasoning but no novel architectures.
Evidence
PredictiveMaintenanceSystem/multiclass_pipeline.ipynb: cascade classifier design (binary -> multiclass) documented and evaluated
PredictiveMaintenanceSystem/model_training_pipeline.ipynb: rationale for Borderline-SMOTE and F-beta optimization
Expertise
Industrial AI & Smart Manufacturing• Senior
MLOps & Model Lifecycle• Senior
Industries
Manufacturing• Senior
Technologies
SQL• Junior
PostgreSQL
Redis
Scikit-learn
Pandas
Docker• 3y+
LLM
RAG
Celery
Alembic
Docker• mentioned only
Docker Compose• mentioned only
Grafana• mentioned only
Loki• mentioned only
Recommendations
- Lead development of end-to-end predictive maintenance or industrial ML features - training pipelines, model validation and production inference with monitoring
- Implement backend services and MLOps integrations - FastAPI-based inference endpoints, async DB, Redis caching and Prometheus/Grafana observability
- Extend MLOps work around model versioning and CI for models - automated retraining pipelines, model bundle versioning and drift detection
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Medium API Engineer
A backend-focused API engineer at a middle level with solid test-driven practices and attention to API contracts. The strongest proven skill is building and validating REST API behaviors and business rules, demonstrated by comprehensive integration tests covering validation, auth, filters/sorting/pagination and error handling in tickets-app backend tests. There is limited public evidence of schema evolution/migrations, operational resilience patterns (retries/circuit-breakers) or advanced database tuning in the analyzed human-authored files.
API Design
5/10
How well APIs are designed
Clear, well-tested REST behavior (filters, sorting, pagination, error codes); lacks evidence of versioning strategy or explicit idempotency keys in the analyzed files.
Data Layer & Database
3/10
Working with databases
Shows practical DB testing (in-memory SQLite + SQLAlchemy metadata management) and dependency override for tests; no migration history, explicit transaction boundaries, or tuned SQL observed in these files.
Scalability & Performance
2/10
Handling load and speed
Small-scale resilience/throughput considerations are present (login rate limiting); no caching strategy, queueing or load-testing artifacts in the analyzed human-authored files.
System Architecture
3/10
Overall system structure
Separation of concerns is apparent through dependency overrides and well-scoped tests; lacks multi-service decomposition, config/secret management, or service-to-service contract evidence in the analyzed files.
Security & Auth
4/10
Protecting data and access
Concrete auth/authz behaviors and login-rate limiting are tested (bearer tokens, admin-only delete); token lifecycle, refresh/revocation, and input-sanitization logic are not present in these files.
Reliability & Observability
4/10
Stability and monitoring
Observability and deterministic behavior are validated in tests (health endpoint, request id propagation, controlled test DB initialization); advanced reliability patterns like retries/backoff or circuit breakers are not shown here.
Expertise
Python• Middle
Microservices & API Architecture• Middle
Industries
Information Technology• Middle
Technologies
Databases
Rest API
Recommendations
- Develop API-driven web services and business-rule-heavy endpoints (FastAPI + SQLAlchemy) with a focus on test coverage and clear error contracts.
- Implement and evolve backend features that require careful authorization and edge-case handling (authentication, admin-only actions, rate limiting).
- Work on expanding operational and data-layer capabilities - e.g., migration histories, transaction isolation choices, caching strategies and load testing.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle DevOps Engineer
Confidence: Medium Generalist
A backend-focused generalist at a solid middle level who writes well-structured Python services with comprehensive unit and integration tests. The strongest proven skill is API and observability engineering, evidenced by the logging and middleware tests and implementations (for example backend/app/core/logging.py and backend/tests/test_logging.py). The public code lacks CI/CD pipeline definitions, cloud/infra-as-code (Terraform/Pulumi) and Kubernetes-level deployment practices, so system-scale ops and cloud architecture are not evidenced.
CI/CD Pipelines
1/10
Automated build and deploy
Minimal CI/CD evidence - project includes buildable Docker images and docker-compose but no CI workflows, reusable pipelines, gating, artifact signing or deploy gates.
Infrastructure as Code
1/10
Managing servers with code
Infrastructure-as-code not evidenced beyond docker-compose; no Terraform/Pulumi modules, remote state, environment-separated modules or infra tests are present.
Containerization & Orchestration
4/10
Working with containers
Good containerization hygiene: multi-stage Dockerfiles, non-root runtime users, nginx unprivileged image for static serving and docker-compose service healthchecks - but no Kubernetes manifests, Helm charts or advanced orchestration.
Observability & Monitoring
5/10
Watching system health
Strong observability foundations: structured logging setup, request-id middleware, explicit logging configuration and unit tests asserting logging/request-id behavior plus HTTP health endpoint and compose healthchecks.
Reliability & Incident Response
2/10
Keeping systems up
Basic reliability practices: health endpoints, compose healthchecks and an in-process rate limiter with tests are present, but there are no deploy strategies (canary/blue-green), runbooks, SLOs or chaos exercises.
Cloud & Cost Optimization
Smart use of the cloud
Not evidenced in public code
Expertise
Observability & Monitoring• Middle
Technologies
Containers
Python• Senior • 3y+
Docker Compose
SQLAlchemy
FastAPI
Nginx
Pydantic
Recommendations
- Lead development of backend APIs and internal platform services, focusing on test-driven features and clear clean-architecture boundaries (e.g., new REST/JSON endpoints and domain services).
- Own observability improvements and production readiness work - extend logging/tracing, add SLOs and alerting playbooks based on backend/app/core/logging.py and health endpoints.
- Build CI/CD pipelines (reusable workflows) and infrastructure-as-code for deployments - convert existing Docker builds into parameterized reusable pipelines and add environment-separated IaC with remote state.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: