Roman Rovensky
Java Developer
7+ years exp
5+ projects
Python
C#
Java
PHP
Data Pipeline & Feature Engineering: 6/10
Experimentation & Evaluation: 6/10
MLOps & Deployment: 5/10
Active 10 days ago
+7 (993) 6036173 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
LLM-focused engineer at a senior level specializing in building small production LLM-powered scoring services and applied ML pipelines. The strongest proven skill is implementing an async LLM scoring API with structured Pydantic models, retry/backoff, caching and persistence as shown in src/infrastructure/llm_client.py, src/application/scoring.py and src/infrastructure/db.py. There is no public evidence of large-scale distributed training, GPU/quantization optimizations, or mature production observability and drift-monitoring systems.
Technical skills
Python• Senior
C#• Middle • 7y+ • 5+ projects
Java• Middle • 4y+ • 2 projects
PHP• Junior • 1 project
Python
FastAPI
Pydantic
Asyncio
Requests
SQLAlchemy
Uvicorn
Kotlin
Mockito
Databases
MySQL
PostgreSQL
pgvector
MS SQL• 3y+ • 3 projects
Redis
AI/ML
OpenAI SDK
Instructor
Pandas
NumPy
Scikit-learn
SHAP
Jupyter Notebook
LangChain
Optuna
DevOps
CI/CD
Docker
Docker Compose
GitLab CI
Rest API• 4y+
Mobile
JUnit
Timeline
Мои проекты
Website
Moscow Polytechnic University
Bachelor's Degree •
Информационные технологии
Java Developer
•
Middle
YUGGEOSTANDARD
•
Full-Time
Implemented a production cost calculation module that accounts for dynamic currency rates and logistics. Built asynchronous processing for external service calls to reduce API response times and added Redis caching for reference data and currency rates. Wrote unit and integration tests to improve release stability and configured GitLab CI pipelines using Gradle, Docker image builds, and test-environment deployment.
Java
Redis
JUnit
GitLab CI
Docker
Gradle
C#/.NET Developer
•
Middle
APOFEMA
•
Full-Time
Developed a service that generates multiple types of legal contracts from .docx templates and automated document filling to reduce manual work. Implemented asynchronous interaction with Word COM objects to prevent IIS hangs during heavy template processing. Designed a REST API for form handling and document generation, and optimized PDF creation speed through parallel conversion.
.NET
C#
Rest API
PHP Backend Developer
•
Middle
MIRASOFT
•
Full-Time
Migrated legacy PHP code from 5.6 to 7.3 and improved platform performance and security. Designed a role-based access model using JWT for a B2B system. Optimized MySQL query performance by adding indexes for frequently filtered fields and set up deferred bulk imports using Laravel queues, along with Docker Compose-driven deployment automation in GitLab CI.
PHP
Laravel
Docker Compose
GitLab CI
Senior AI/ML Engineer
Confidence: High LLM Engineer
LLM-focused engineer at a senior level specializing in building small production LLM-powered scoring services and applied ML pipelines. The strongest proven skill is implementing an async LLM scoring API with structured Pydantic models, retry/backoff, caching and persistence as shown in src/infrastructure/llm_client.py, src/application/scoring.py and src/infrastructure/db.py. There is no public evidence of large-scale distributed training, GPU/quantization optimizations, or mature production observability and drift-monitoring systems.
Model Architecture & Training
4/10
How well models are designed and trained
Practical model-building and tuning shown via notebooks (custom SGD logistic, ElasticNet/Lasso, Optuna), but no custom NN architectures or large-scale training pipelines.
Data Pipeline & Feature Engineering
6/10
How data is prepared for models
Strong data-prep and feature engineering: deterministic splits, ColumnTransformer pipelines, groupby features and careful leakage-aware temporal splits.
Experimentation & Evaluation
6/10
How results are measured and tested
Good experimentation and evaluation practices: custom metrics, comparisons to sklearn, cross-validation, Optuna, and result tables; reproducibility is notebook-based rather than a fully tracked experiment system.
MLOps & Deployment
5/10
How models are shipped to production
Clear production-oriented service design around an LLM: async FastAPI app structure, DI-style deps, async DB repository, Redis cache backend and unit/integration tests; deployment/monitoring concerns are not fully present.
Evidence
cowellme/ai-counterparty-risk/src/application/scoring.py: CounterpartyScoringService orchestration (cache checks, news fetch, llm scoring, persist)
cowellme/ai-counterparty-risk/src/infrastructure/db.py: async SQLAlchemy engine, repository save/get_latest and init_db DDL
cowellme/ai-counterparty-risk/tests/unit/test_scoring.py: unit tests using AsyncMock for service behavior
Computational Efficiency
3/10
How efficiently computing resources are used
Some pragmatic efficiency work (batching in custom KNN, use of async IO and n_jobs), but no GPU, quantization, distributed training or measured profiling/optimization artifacts.
Research Depth & Innovation
2/10
Depth of research and new ideas
Applied use of standard techniques (L1 selection, SHAP, Optuna) and correct engineering, but no original research, novel architectures or paper-level reproductions.
Expertise
LLM• Senior
Technologies
PostgreSQL
Redis
SHAP
Instructor
Pydantic
Requests
Recommendations
- Develop LLM-backed production APIs that need structured JSON outputs, caching and persistence (scoring, classification, summarization pipelines).
- Build end-to-end ML pipelines that combine classical feature-engineering and evaluation with LLM-based enrichment (news ingestion + LLM reasoning).
- Implement retrieval-augmented workflows (RAG) and vector search integration to replace the current mock news fetcher for real-world grounding.
- Strengthen MLOps by adding experiment tracking (W&B/MLflow), deployment observability, and drift detection for model/system monitoring.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: High ML Practitioner
A machine-learning practitioner at a senior-early level specializing in applied predictive modeling and feature engineering for real-world tabular problems. The strongest proven skill is building end-to-end modeling experiments and model selection pipelines, demonstrated by Jupyter notebooks that implement deterministic time/group splits, custom model implementations, hyperparameter search (Grid/Random/Optuna) and careful evaluation. Public artifacts do not show production-grade CI/CD, data-versioning (DVC), broad test coverage or large-scale distributed data processing expertise.
Statistical Rigor
5/10
Correct use of statistics
Good practical awareness of leakage, temporal splits and appropriate validation choices, but limited formal statistical inference, uncertainty quantification or multiple-comparison control.
Evidence
ML_Classification_problems/src/ml4.ipynb: roc_auc_custom and gini_score_custom implementations and discussion
ML_Validation/src/ml3.ipynb: train_test_split_date, train_val_test_split_date and explicit discussion of preventing leakage
Data Wrangling & Cleaning
8/10
Preparing and cleaning data
Strong, disciplined data wrangling and feature engineering with pipelines, imputation, careful train-only group statistics and explicit leakage-avoidance in group/time operations.
Evidence
ML_Classification_problems/src/ml4.ipynb: prepare_features, ColumnTransformer pipeline (numeric_transformer and categorical_transformer)
ML_Validation/src/ml3.ipynb: feature_mapping, creation of binary feature columns and safe photo_count handling
Exploratory Analysis & Visualization
6/10
Exploring and visualizing data
Exploratory analysis includes clear written interpretations, comparisons and stability checks; visualizations are limited and EDA is mostly tabular and narrative rather than wide-ranging plotting.
Evidence
ML_Validation/src/ml3.ipynb: compare_distributions and comparison_table with prose interpretation
ML_Classification_problems/src/ml4.ipynb: dataset description, date-based splits and narrative EDA sections
Predictive Modeling
8/10
Building models that predict
Strong predictive modeling practice: baseline-first, custom implementations, vectorized algorithms, appropriate CV and time-aware splits, hyperparameter search (Grid/Random/Optuna) and systematic error analysis.
Evidence
ML_Classification_problems/src/ml4.ipynb: CustomLogisticRegression, CustomKNNClassifier, CustomGaussianNB implementations and comparisons to sklearn
ML_Validation/src/ml3.ipynb: GridSearchCV / RandomizedSearchCV / Optuna usage and evaluate_model routine
Business Insight & Impact
6/10
Turning analysis into business value
Good business thinking: clear selection of evaluation metric tied to costs (Recall for auctions), discussion of FP vs FN tradeoffs and pragmatic model selection, but limited formal product/ROI instrumentation or deployment cost analysis.
Evidence
ML_Classification_problems/src/ml4.ipynb: section 'Выбранный метод для задачи выявления некачественных автомобилей' arguing for Recall and error-cost reasoning
ML_Validation/src/ml3.ipynb: problem framing around model quality estimation and leak avoidance
Reproducibility & Notebook Hygiene
5/10
Clean, repeatable analysis
Reproducibility practices present (pipelines, random_state, requirements.txt, deterministic splits), but no formal environment pinning, DVC/data versioning or test suite observed in analyzed human-authored files.
Evidence
ML_Validation/src/ml3.ipynb: functions set random_state seeds in splits (train_test_split_random, k_fold_split)
deep-research-agent/requirements.txt: pinned runtime dependencies for the FastAPI/LLM service
Expertise
Analytics• Middle
Industries
Real Estate• Middle
Transportation & Logistics• Middle
Technologies
Python• Senior
LangChain
pgvector
SQLAlchemy
Jupyter Notebook
Optuna
FastAPI
Scikit-learn
OpenAI SDK
Pandas
NumPy
Asyncio
Uvicorn
Recommendations
- Develop productionizable RAG/LLM-backed research services and APIs (FastAPI + async SQLAlchemy + pgvector) with robust CI, monitoring and security hardening.
- Lead modelization and feature engineering for tabular problems where time- or group-aware validation is critical, including building standard pipelines and model cards.
- Harden reproducibility and MLOps: add pinned environment files, CI tests, dataset versioning (DVC) and end-to-end deployment scripts.
- Extend to scalable data infrastructure tasks (streaming ingestion or Spark/Ray) once MLOps and testing are in place.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium UI Engineer
A frontend UI engineer (junior-to-middle level) focused on component-scoped styling and UX polish for web applications. The strongest proven skill is CSS-driven component design and UX polish, evidenced by comprehensive design tokens and utilities in LumenusErp/wwwroot/app2.css and multiple component-scoped .razor.css files. There is limited evidence of automated tests, broad state-management patterns or measured performance and accessibility tooling in the public artifacts.
UI Component Architecture
4/10
How interface parts are built
Component-scoped styling is consistently used (Blazor .razor.css pattern and global design tokens), showing deliberate CSS organization and token usage but little evidence of a custom component library or advanced composition patterns authored by the developer.
Responsive & Cross-browser
3/10
Works on all screens and browsers
Responsive rules and breakpoints are present with some media-query adjustments and mobile/desktop toggles, but there is no evidence of advanced fluid-type, container queries, or RTL/i18n readiness.
Performance Optimization
2/10
Speed of the interface
Some animation and reveal helpers and lightweight UX optimizations appear in CSS, but there are no measured performance artifacts, bundle analysis, virtualization code or explicit code-splitting evidence.
Accessibility & Semantics
3/10
Usable for everyone
Basic accessibility practices are visible such as clear focus styles and focus-within outlines; however there is limited explicit ARIA usage, keyboard-focus management beyond native dialog methods, or CI a11y tooling shown.
State Management & Data Flow
4/10
Managing data in the app
There is concrete async lifecycle and error-state handling in client-side code: a reconnect/resume flow with differentiated outcomes, visibility-change retry registration, and safe reload/resume decisions which indicate practical handling of edge async states.
UX & Visual Polish
4/10
Look and feel quality
Strong visual polish and UX attention is evident: design tokens, error-boundary styling, animated attention indicators, and UX affordances (thinking indicator, modal UX) improve perceived quality though many are CSS-driven rather than backed by measured UX experiments.
Evidence
Expertise
HTML & CSS• Middle
Modern Web Frameworks• Middle
Industries
Commerce• Middle
Data & Analytics• Middle
Recommendations
- Assign to build and refine component-driven UI libraries and design-token systems for enterprise Blazor or web apps.
- Use to implement client-side UX flows that require careful edge-state handling, such as reconnect/resume flows and modal UX.
- Have the developer add automated a11y checks, ARIA semantics and keyboard handling to custom widgets to raise accessibility maturity.
- Invest time in adding tests and measurable performance work (LCP/INP monitoring and lightweight code-splitting) to demonstrate deeper frontend engineering impact.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: