Dmitry Zolotarev
Machine Learning Engineer
C++
Python
Computational Efficiency: 4/10
Active 22 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic ML engineer with demonstrated ability to build and ship GPU-backed computer vision inference services. The strongest proven skill is production-oriented inference engineering, evidenced by MobileCLIP-based encoder and GPU-aware retrieval plus a benchmark measuring p50/p95 latencies (AmaHamster/app/adapters/mobileclip_encoder.py and AmaHamster/benchmark.py). There is no public evidence of custom model training, experiment tracking, large-scale data pipelines, or full production MLOps automation in the human-authored files.
Technical skills
C++
Python• Junior • 3y+
Python
Uvicorn
FastAPI• 3y+
Databases
PostgreSQL• 3y+
Apache Kafka
AI/ML
Arize Phoenix
Fine-tuning
LangChain
Langfuse
Model Context Protocol
RAG
Synthetic Data
Pillow
timm
huggingface_hub
Transformers
Deep Learning
PyTorch• 3y+
EasyOCR
Gradio
Label Studio
llama.cpp
Streamlit
Whisper
DeepEval
Open WebUI
LLM
DevOps
Rest API
Docker• 3y+
WebSockets• 3y+
Docker Compose
AWS
QA
Pytest• 3y+
Timeline
Machine Learning Engineer
•
Middle
Innotech
•
Full-Time
Developed LLM-based systems and RAG infrastructure for enterprise use cases. Designed a production-grade RAG pipeline library with automated quality evaluation and implemented document vectorization. Built an evaluation suite to improve query latency and created an analytics platform with custom MCP modules and real-time dashboards.
Apache Kafka
AWS
DeepEval
Open WebUI
FastAPI
PostgreSQL
Docker
Information Technologies, Mechanics and Optics University (ITMO University)
Bachelor's Degree •
Robotics and Artificial Intelligence
Machine Learning Research Assistant
•
Middle
ITMO University
•
Full-Time
Worked on synthetic video generation for multi-object tracking to address data scarcity in industrial scenarios. Implemented a WAN-based pipeline for photorealistic video synthesis with ground-truth annotations and built an end-to-end system combining YOLOv5 and SORT with conditional generation. Contributed to research documentation and publication of the synthetic data methodology.
PyTorchsince 2023
Machine Learning Engineer
•
Middle
Tatneft
•
Full-Time
Led development of multiple production ML systems for OCR and speech processing. Improved passport OCR quality with custom EasyOCR fine-tuning, built field detection with YOLOv8, and delivered FastAPI services with a Gradio UI packaged for deployment. Developed a voice-to-Excel reporting pipeline using whisper.cpp and llama.cpp, plus a scalable FastAPI model pool for concurrent multi-model inference.
EasyOCR
Whisper
llama.cpp
PyTorch
FastAPI
Gradio
Streamlit
Docker
Label Studio
Docker Compose
Backend Developer
•
Middle
Tatneft
•
Full-Time
Built production backend infrastructure for internal OCR applications used across the organization. Implemented a FastAPI MVC server for high-volume OCR requests, added PostgreSQL storage with JWT authentication and role-based authorization, and created async batch processing with WebSocket streaming. Wrote pytest test coverage with structured logging and containerized deployments with Docker on Linux.
FastAPIsince 2023
PostgreSQLsince 2023
Dockersince 2023
Pytest
WebSockets
Junior AI/ML Engineer
Confidence: Medium ML Engineer
A pragmatic ML engineer with demonstrated ability to build and ship GPU-backed computer vision inference services. The strongest proven skill is production-oriented inference engineering, evidenced by MobileCLIP-based encoder and GPU-aware retrieval plus a benchmark measuring p50/p95 latencies (AmaHamster/app/adapters/mobileclip_encoder.py and AmaHamster/benchmark.py). There is no public evidence of custom model training, experiment tracking, large-scale data pipelines, or full production MLOps automation in the human-authored files.
Model Architecture & Training
3/10
How well models are designed and trained
Inference-focused model engineering: correct use of GPU, model loading, preprocessing and embedding normalization, but no custom training loops or novel architectures.
Evidence
AmaHamster/app/adapters/mobileclip_encoder.py: MobileClipEncoder.__init__ - model creation and device placement; uses open_clip and reparameterize_model
AmaHamster/app/adapters/mobileclip_encoder.py: MobileClipEncoder.__call__ - inference path with inference_mode and autocast
AmaHamster/app/adapters/torch_hamster_search.py: builds reference embedding matrix and performs cosine search via torch.topk
Data Pipeline & Feature Engineering
2/10
How data is prepared for models
Basic data ingestion and validation for image inputs - filesystem loading and request-level validation are present but no complex feature engineering or large-scale ETL pipelines.
Evidence
AmaHamster/app/adapters/filesystem_hamsters.py: load_hamster_images signature (image discovery and deterministic ordering implied)
AmaHamster/app/web/api.py: _validate_image - image size and format checks and verification with PIL
Experimentation & Evaluation
3/10
How results are measured and tested
Reasonable local evaluation and testing: includes unit tests covering edge cases and a benchmark script measuring latency and percentiles, but no experiment tracking or ablation studies.
Evidence
AmaHamster/tests/test_api.py: multiple pytest tests for endpoint behavior and edge cases
AmaHamster/benchmark.py: timing loop, p50/p95 measurements and CUDA synchronization for inference benchmarking
MLOps & Deployment
2/10
How models are shipped to production
Basic serving and runtime concerns addressed - FastAPI app, readiness checks and warmup functionality exist, but no CI/CD manifests, deployment automation, or monitoring integrations in human-authored files.
Evidence
AmaHamster/app/web/api.py: create_app sets readiness flag and mounts static files; health endpoint implements readiness check
AmaHamster/app/adapters/mobileclip_encoder.py: warmup() ensures model warm state and synchronizes CUDA
Computational Efficiency
4/10
How efficiently computing resources are used
Clear attention to computational efficiency at inference time - explicit use of CUDA, float16 autocasting, inference mode and batched matrix ops with top-k selection; runtime benchmarking is included.
Evidence
AmaHamster/app/adapters/mobileclip_encoder.py: uses torch.inference_mode, torch.autocast(device_type='cuda', dtype=torch.float16) and embedding normalization
AmaHamster/benchmark.py: uses torch.cuda.synchronize and measures p50/p95/FP S to evaluate throughput and latencies
Research Depth & Innovation
1/10
Depth of research and new ideas
Little research novelty - code uses existing model components and libraries without implementing new algorithms, custom layers, or reproducing papers.
Evidence
AmaHamster/app/adapters/mobileclip_encoder.py: loads existing MobileCLIP model and uses standard preprocessing and encoding
Verified artifacts
Expertise
Computer Vision & Image Analysis• Junior
Technologies
C++
PostgreSQL• 3y+
Rest API
LangChain
llama.cpp
Docker Compose
Model Context Protocol
FastAPI• 3y+
WebSockets• 3y+
Fine-tuning
Arize Phoenix
DeepEval
Gradio
Langfuse
Open WebUI
timm
Label Studio
PyTorch• 3y+
AWS
Docker• 3y+
Apache Kafka
LLM
RAG
Whisper
Streamlit
Pillow
EasyOCR
Synthetic Data
Recommendations
- Develop small-to-medium CV inference services and prototypes that require GPU-aware deployment, benchmarking and low-latency retrieval.
- Implement model inference pipelines for image similarity search, including robust input validation, warmup, batching and end-to-end latency budgets.
- Build integration-level features around model serving: CI/CD for containerized GPU services, performance monitoring, and automated warmup or health probes.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Backend Developer
Confidence: Medium API Engineer
A pragmatic backend/API engineer at a mid (middle) level who delivers small ML-backed services and well-tested HTTP endpoints. The strongest proven skill is building inference-backed web services with concrete artifacts in AmaHamster - e.g., MobileCLIP-based encoder (app/adapters/mobileclip_encoder.py) and FastAPI endpoints with tests (app/web/api.py and tests/test_api.py). Public code shows limited evidence of data-layer work, large-scale distributed design, production observability, or auth/token lifecycle management.
API Design
4/10
How well APIs are designed
Practical, well-tested HTTP endpoints with explicit input validation and clear error contracts; missing higher-level API design features such as versioning, idempotency keys, or advanced pagination strategies.
Evidence
AmaHamster/app/web/api.py: match endpoint validates Content-Type, enforces size limits, returns precise HTTPException statuses
AmaHamster/tests/test_api.py: tests for content-type, empty body, oversized payload and readiness (asserts 415/400/413/503 responses)
Data Layer & Database
Working with databases
Not evidenced in public code
Scalability & Performance
5/10
Handling load and speed
Performance-aware inference and benchmarking (warmup, explicit CUDA checks/synchronization, P50/P95 timing); lacks system-level scaling components like cache invalidation, queuing, or connection pooling.
Evidence
AmaHamster/app/adapters/mobileclip_encoder.py: warmup(), torch.cuda checks and inference_mode/autocast usage
AmaHamster/benchmark.py: benchmark loop, timing, p50/p95 reporting and torch.cuda.synchronize for accurate timing
System Architecture
4/10
Overall system structure
Deliberate modular structure - core use-case separated from adapters and web layer; single-service deployment model appropriate for the size of the project but no evidence of multi-service contracts or distributed trade-offs.
Evidence
AmaHamster/app/main.py: composes adapters and use-case (project structure indicates ports/adapters separation)
AmaHamster/app/web/api.py: FastAPI app wiring and mounting of static assets (clear separation between HTTP layer and use-case)
Security & Auth
3/10
Protecting data and access
Good input-surface hygiene - content-type checking, size/dimension checks and error responses; no authentication/authorization, token lifecycle, or secrets-management patterns in the human-authored code.
Evidence
AmaHamster/app/web/api.py: content-type whitelist, MAX_BODY_BYTES checks and validate_image() with HTTPException codes
AmaHamster/tests/test_api.py: tests exercising content-type and size-related rejection cases
Reliability & Observability
4/10
Stability and monitoring
Unit tests and defensive error handling exist; benchmarking and warmup improve reliability of timing measurements. Observability/metrics and structured logging are not present in the human-authored subset.
Evidence
AmaHamster/tests/test_api.py: unit tests covering success and multiple failure modes
AmaHamster/app/adapters/mobileclip_encoder.py: warmup() that performs a GPU sync to make measurements reliable
Expertise
Python• Junior
Microservices & API Architecture• Junior
System Architecture• Junior
Industries
Artificial Intelligence• Junior
Technologies
Python• Junior • 3y+
Uvicorn
Recommendations
- Develop small to medium-scale ML inference APIs and prototypes that require GPU-aware inference, benchmarking and input validation (e.g., image search or vision microservices).
- Extend this work to production-ready services by adding structured logging/metrics, request tracing, and a simple lifecycle for model warmup and graceful shutdown.
- Implement basic deployment and scaling patterns for the service - containerization with health/readiness probes, a simple queue or worker for async heavy work, and a caching layer for repeated inferences.
- Add authentication/authorization and secrets handling for database or external integrations if the service will be exposed beyond trusted environments.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Intern Data Scientist
Confidence: Medium ML Practitioner
An ML-focused practitioner at a lower-mid level who produces working speech model inference and FastAPI service code. The strongest proven skill is building and wiring speech-to-text inference pipelines, evidenced by the Whisper and STT model wrappers (ai_models/whisper/model.py and ai_models/stt/model.py). There is little or no evidence of statistical rigor, model evaluation, scalable data pipelines, or production-grade testing and CI in the public artifacts.
Statistical Rigor
1/10
Correct use of statistics
No statistical analysis, hypothesis testing, uncertainty quantification or causal reasoning are present; artifacts are inference/deployment code only.
Data Wrangling & Cleaning
3/10
Preparing and cleaning data
Practical data handling for audio (loading, resampling, device placement) is implemented, but no systematic cleaning pipelines, provenance tracking, or leakage checks.
Exploratory Analysis & Visualization
1/10
Exploring and visualizing data
No exploratory data analysis or visualizations aimed at answering analytical questions are present; only small runtime/test snippets exist.
Predictive Modeling
3/10
Building models that predict
Contains model-loading and inference code for speech models and a basic factory pattern, but no training, model selection, cross-validation, calibration, or model evaluation framework.
Business Insight & Impact
1/10
Turning analysis into business value
Minimal business-impact framing or error-cost reasoning; code targets a runnable service but does not document KPIs or business metrics.
Reproducibility & Notebook Hygiene
2/10
Clean, repeatable analysis
Project includes runnable FastAPI service and a requirements file but lacks pinned environment/CI, thorough reproducibility tooling, tests, or data versioning.
Industries
Artificial Intelligence• Junior
Software• Intern
Technologies
Deep Learning
huggingface_hub
Transformers
Recommendations
- Develop production-grade model serving with automated tests and CI (unit tests for preprocessing, integration tests for inference paths).
- Add evaluation and monitoring: create reproducible validation pipelines, metrics (WER, latency), and hooks for model drift detection.
- Harden input handling and security for the API (sanitize filenames, validate uploads, rate limiting, secrets management).
- Introduce reproducibility tools: pin environment (lockfile or pyproject), add example evaluation notebooks with clear hypotheses and negative-result reporting.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: