Vitaliy Dulov
Software Developer
7+ years exp
Node JS
Python
Rust
Model Architecture & Training: 4/10
Data Pipeline & Feature Engineering: 4/10
Experimentation & Evaluation: 4/10
Active 15 days ago
+7 (922) 1650404 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic Rust systems/tooling engineer at a Middle level (approx 3.0/10) who builds CLI-first developer tools and content pipelines. The strongest proven skill is developer tooling and pipeline design - exemplified by loadout/src/main.rs (sync_target), loadout/src/catalog.rs (catalog parsing/resolution) and the integration tests in t3chn/loadout/tests/integration.rs that validate idempotent end-to-end flows. There is no evidence of game-engine work (rendering/shaders/physics), deterministic simulation, or multiplayer/netcode in the human-authored files analyzed; several other files in the tree are AI-authored or boilerplate and were ignored per analysis policy.
Technical skills
Node JS• Junior
Python• Senior • 7y+
Rust• Junior
Python
Celery
Asyncio
HTTPX
FastAPI• 4y+
Rust
SQLx
Clap
Serde
Databases
PostgreSQL
Apache Kafka• 4y+
AI/ML
AI Agents
AI/ML
MLFlow
Hyperopt
Scikit-learn
LightGBM
Pandas
NumPy
Evidently AI
OpenAI SDK
Claude
Gemini
LLM
Claude Code
DevOps
CentOS Stream
Git
Rest API
Ubuntu
Debian
Docker• 7y+
Nginx• 7y+
Prometheus• 7y+
Zabbix• 7y+
CI/CD• 4y+
GitLab CI• 4y+
Kubernetes• 4y+
Timeline
Senior Software Engineer
•
Senior
Cronit
•
Full-Time
Developed engineering workflows using AI development tools, from requirements and architectural planning through implementation, verification, testing, and documentation. Used Claude Code, Gemini, and GPT/Claude to decompose tasks, generate and review code, and handle edge cases. Defined how to provide and bound context for AI outputs and set acceptance criteria for when manual engineering review is required. Built and integrated backend automation in Python with API/database work, logging, CI/CD, and post-release changes support.
Python
Claude Code
Gemini
Claude
LLM
CI/CD
Senior Software Engineer
•
Senior
Traffic Arbitrage Platform
•
Full-Time
Migrated legacy Python services from Python 2 to Python 3 and contributed to moving toward a more stable microservice architecture. Set up the delivery pipeline using Docker, GitLab CI, and Kubernetes to automate build and deployment. Improved production logging, monitoring, and reliability while reducing manual operations during support.
Python
Docker
GitLab CI
Kubernetes
CI/CD
Python Developer
•
Middle
YallaMarket
•
Full-Time
Built backend services for logistics and operational workflows using Python, FastAPI, MongoDB, and Kafka. Customized Odoo to match logistics, accounting, and e-commerce processes and configured integrations with warehouses, payments, and internal systems. Created ETL/data pipelines for analytics and operational automation, and supported deployments with Docker, GitLab CI, and Kubernetes with observability practices.
Python
FastAPI
Apache Kafka
Docker
GitLab CIsince 2022
Kubernetessince 2022
CI/CDsince 2022
Python Developer
•
Middle
RYDLAB
•
Full-Time
Administered and configured web infrastructure including Nginx and ensured high availability and resilience. Implemented monitoring and alerting using Zabbix and Prometheus, and handled backup and restore procedures. Updated and optimized Linux systems, deployed services with Docker, and wrote Python scripts to automate routine infrastructure tasks.
Pythonsince 2019
Nginx
Zabbix
Prometheus
Dockersince 2019
System Administrator
•
Middle
Private Practice (Freelance)
•
Full-Time
Provided Linux server administration with a focus on security, backups, and disaster recovery. Configured web servers and databases to keep services running reliably and supported clients with technical troubleshooting. Managed IT operations as an independent small IT business.
Junior AI/ML Engineer
Confidence: Medium ML Engineer
A practical ML engineer at a solid middle level who builds end-to-end time-series ML systems and streaming data pipelines. The strongest proven skill is applied ML engineering - evidenced by predictor/models.py (Optuna tuning, LightGBM, ensemble), train.py integrations with MLflow, and predictor drift/reporting code. The public code lacks evidence of large-scale distributed training, production-grade serving/latency budgets, or novel research-level architectures.
Model Architecture & Training
4/10
How well models are designed and trained
Custom model code, hyperparameter tuning and training plumbing are present (Optuna, LightGBM, sklearn pipelines, MLflow integration) but there is no evidence of large-scale distributed training, custom CUDA/Triton kernels, or novel research-grade architectures.
Evidence
services/predictor/src/predictor/models.py: HuberRegressorWithHyperparameterTuning, LightGBMWithHyperparameterTuning, EnsembleModel and Optuna objective
services/predictor/src/predictor/train.py: training loop and MLflow usage (train orchestration)
services/predictor/src/predictor/model_registry.py: load_model / push_model using mlflow and infer_signature
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Clear, tested streaming and ETL pipelines (trades -> candles -> indicators) with structured feature-engineering utilities and configuration, but no large-scale data engineering infra (no Airflow/Dagster production pipelines shown).
Evidence
services/trades/src/trades/binance_client.py: historical + live ingestion clients and robust tests
services/candles/src/candles/main.py and tests: transforming trades into OHLCV candles (init_candle/update_candle)
services/technical-indicators/src/technical_indicators/indicators.py and tests: compute_indicators and indicator correctness tests
Experimentation & Evaluation
4/10
How results are measured and tested
Experimentation and evaluation tooling exist (MLflow, Optuna, test suites, Evidently drift reports) and there are tests that exercise model/data validation, but experiment-tracking/ablation artifacts and reproducible experiment history are not fully visible here (no W&B/MLflow server snapshots or recorded run history).
Evidence
pyproject.toml (predictor): declares mlflow, optuna and test tooling
services/predictor/src/predictor/train.py: integration points for mlflow and training procedure
services/predictor/src/predictor/drift.py: Evidently-based drift detection and report generation
MLOps & Deployment
3/10
How models are shipped to production
Some MLOps and deployment work is present - MLflow model registry usage, deployment docs for a local kind cluster and Kafka/RisingWave setup - but production serving, autoscaling, drift-monitoring pipelines, and structured CI/CD for models are thin or not fully implemented in code shown.
Evidence
deployments/dev/kind/README.md: local cluster setup (Kafka, RisingWave, MLflow) and developer deployment instructions
services/predictor/src/predictor/model_registry.py: MLflow push/load model helpers
pyproject.toml top-level: service scripts and workspace layout for services (services listed under [tool.uv.workspace])
Computational Efficiency
2/10
How efficiently computing resources are used
Minor efficiency considerations (LightGBM params, n_jobs, time-series CV) are used, but there is no evidence of measured GPU optimization, quantization, batching at scale, or memory/GPU profiling results.
Evidence
services/predictor/src/predictor/models.py: LightGBM pipeline uses n_jobs=-1 and tuned hyperparameters
services/predictor/src/predictor/models.py: Optuna tuning with TimeSeriesSplit but no GPU/quantization/profiling artifacts
Research Depth & Innovation
2/10
Depth of research and new ideas
The code implements sensible applied-ML patterns (ensembles, hyperparameter search, drift detection) but does not demonstrate novel research contributions, reproduced papers, or custom low-level model architectures.
Evidence
services/predictor/src/predictor/models.py: ensemble design and hyperparameter-search patterns
services/predictor/src/predictor/drift.py: Evidently-based drift detection and reporting
Expertise
Finance & FinTech AI• Junior
MLOps & Model Lifecycle• Junior
Industries
Data & Analytics• Junior
Financial Services• Junior
Technologies
AI/ML
Python• Senior • 7y+
Rest API
Claude
Zabbix• 7y+
Claude Code
MLFlow
Debian
FastAPI• 4y+
Prometheus• 7y+
Scikit-learn
AI Agents
GitLab CI• 4y+
LightGBM
OpenAI SDK
Evidently AI
CI/CD• 4y+
Pandas
NumPy
Git
Docker• 7y+
Kubernetes• 4y+
Gemini
Ubuntu
Nginx• 7y+
Apache Kafka• 4y+
LLM
Celery
HTTPX
CentOS Stream
Hyperopt
Claude• mentioned only
Claude Code• mentioned only
Recommendations
- Lead development of time-series model training and lifecycle (retraining, MLflow model registry, optuna experiments) - start with services/predictor/train.py and model_registry.py.
- Implement and harden streaming feature pipelines and ingestion (trades -> candles -> technical indicators) for production (focus on tests in services/trades and services/candles).
- Build model-monitoring and automated retraining flows (instrument predictor/drift.py into alerts and retrain triggers with measurable baselines).
- Work on MLOps tasks: CI/CD for model artifacts, documented deployment manifests (extend deployments/dev/kind) and stable inference serving — avoid low-level custom CUDA work unless there is explicit profiling evidence.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Backend Developer
Confidence: Medium Data Platform
A competent mid-level backend engineer who produces multi-language, test-covered services and developer tooling across a monorepo. The strongest proven skill is building data and real-time pipelines with concrete artifacts such as the crypto prediction services and the lunarcrush client tests (cryptopred services and lunarcrush client). Public code shows gaps in explicit DB migration history, formal API versioning/idempotency contracts, and secrets hardening.
API Design
3/10
How well APIs are designed
API surface and provider abstractions are present (CLI routes, provider adapters, publish clients) but there is little evidence of formal versioning/idempotency/canonical error contract design across services.
Evidence
context-engineering-blog/apps/cli/src/publishers/telegram.ts: publishToTelegram / validateText input validation and retry logic
context-engineering-blog/apps/cli/src/providers/index.ts and apps/cli/src/providers/claude.ts: provider abstraction for LLM backends
Data Layer & Database
3/10
Working with databases
Data layer shows awareness of SQL/Postgres and DB clients and test coverage, but there is limited visible migration history or hand-tuned SQL and no clear evidence of deliberate transactional/isolation design.
Evidence
cryptopred/services/predictor/pyproject.toml: references to psycopg2 and ML data stack
cryptopred/services/prediction-api/Cargo.toml: sqlx with postgres feature
Scalability & Performance
4/10
Handling load and speed
Good evidence of streaming / real-time architecture and retry/backoff patterns (Kafka, quixstreams, tokenized TTS pipelines and rate-limit handling) indicating attention to operational performance and resilience.
Evidence
cryptopred/services/*: quixstreams usage and Kafka/topic wiring referenced in READMEs and service code
cryptopred/services/lunarcrush/src/lunarcrush/client.py and tests: rate-limit and retry/backoff handling with tests
System Architecture
4/10
Overall system structure
Monorepo modular structure (apps/*, packages/*), CLI/tooling separation, and dedicated packages for video pipeline and shared types show deliberate modular architecture appropriate for multi-language monorepos.
Evidence
context-engineering-blog/package.json: pnpm workspace scripts and packages layout (apps/, packages/)
context-engineering-blog/packages/video-pipeline and apps/cli: separated package boundaries for reuse (package.json entries)
Security & Auth
3/10
Protecting data and access
Surface-level security hygiene is visible (input validation, env-based API keys, bandit config), but secrets/credential handling and threat hardening practices are only lightly evidenced.
Evidence
context-engineering-blog/apps/cli/src/publishers/telegram.ts: checks for botToken / channelId and error handling
cryptopred/pyproject.toml: bandit configuration present in tooling
Reliability & Observability
4/10
Stability and monitoring
Solid reliability and observability practices are present - tests across services, signal/shutdown handling, logging/tracing usage, and retry tests for external APIs indicate operational awareness.
Evidence
cryptopred/services/trades/src/main.py and candles/main.py: signal handlers and graceful shutdown patterns referenced in tests
cryptopred/services/lunarcrush/tests/test_client.py: tests for rate-limit retry and server error retry behavior
Verified artifacts
Expertise
Python• Junior
Node.js• Junior
Messaging & Real-time• Junior
Industries
Blockchain & Crypto• Junior
Financial Services• Junior
Technologies
Node JS• Junior
PostgreSQL
Asyncio
SQLx
Recommendations
- Lead development of data-platform features: streaming ingestion, schema evolution, and Postgres-backed analytics where the existing Kafka / quixstreams + sqlx experience is directly applicable.
- Build or extend developer-facing tooling and CLI workflows (LLM provider adapters, publish pipelines, video/audio integration) leveraging the existing apps/cli and video-pipeline packages.
- Implement improved operational boundaries: add documented DB migrations, explicit API error contracts/versioning, and stronger secrets/credential handling (rotate, vault integration).
- Improve backend reliability practices by formalizing retry policies with backoff+jitter, adding structured tracing (OpenTelemetry), and expanding automated chaos/smoke tests for streaming components.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Game Developer
Confidence: Medium Generalist
A pragmatic Rust systems/tooling engineer at a Middle level (approx 3.0/10) who builds CLI-first developer tools and content pipelines. The strongest proven skill is developer tooling and pipeline design - exemplified by loadout/src/main.rs (sync_target), loadout/src/catalog.rs (catalog parsing/resolution) and the integration tests in t3chn/loadout/tests/integration.rs that validate idempotent end-to-end flows. There is no evidence of game-engine work (rendering/shaders/physics), deterministic simulation, or multiplayer/netcode in the human-authored files analyzed; several other files in the tree are AI-authored or boilerplate and were ignored per analysis policy.
Gameplay Systems & Mechanics
How game logic works
Not evidenced in public code
Graphics & Rendering
Drawing game visuals
Not evidenced in public code
Physics & Math
Game physics and math
Not evidenced in public code
Engine Proficiency
Skill with the game engine
Not evidenced in public code
Performance & Frame Budget
1/10
Keeping the game smooth
Minimal attention to performance and stable hot-paths is visible (correct use of dedup/sort and idempotent sync patterns), but no measured profiling, zero-alloc hot-paths, or advanced frame-budget work is present in human-authored code.
Content Pipeline & Tooling
5/10
Tools for game content
Strong evidence of developer-focused tooling and content pipeline work: a Rust CLI with manifest/lock/trust model, idempotent sync/export, clone/checkout workflows and integration tests validating end-to-end behavior.
Expertise
Game Development Tools & Pipeline• Junior
Industries
Software• Junior
Technologies
Rust• Junior
Serde
Clap
Recommendations
- Lead development of CLI-based developer tools, package/skill managers, and internal content-pipeline utilities (export/sync/lock workflows).
- Implement and harden developer-facing automation - e.g., source sync, pinning, trust gating, and robust integration tests for platform/tooling workflows.
- Work on CI-focused infrastructure and developer UX for agent-first tooling (packaging, install flows, and deterministic test fixtures).