Stepan Kitaev
Data Scientist
SQL
Java
Python
Data Pipeline & Feature Engineering: 4/10
Active 16 days ago
+7 (918) 7650180 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A mid-level ML practitioner who produces end-to-end experimental work: dataset construction, model training, and a simple model-serving layer. The strongest proven skill is building a computer-vision training pipeline and integrating the trained YOLO classifier into a FastAPI backend (model_research.ipynb and main.py). There is limited evidence of production-grade testing, CI/CD, robust monitoring, or formal statistical rigor in experiments.
Technical skills
SQL
Java
Python• Middle
Python
FastAPI
pySpark
SQLAlchemy
Pydantic
Uvicorn
Databases
PostgreSQL
MongoDB
AI/ML
BERT
CatBoost
Hadoop
LangChain
LLM
NLP
NumPy
OpenCV
PyTorch
Scikit-learn
Transformers
XGBoost
YOLO
Spark
Pandas
Torchvision
Jupyter Notebook
Embeddings
Llama
Qwen
RAG
DevOps
Docker
Git
Rest API
Docker Compose
Analytics
Matplotlib
Timeline
Data Scientist
•
Middle
ASE Digital Laboratory
•
Full-Time
Developed an end-to-end RAG solution for a portal of extracted lessons, including document indexing, retrieval pipeline tuning, and LLM-driven response generation scenarios. Deployed Qwen and Llama model variants for production use. Implemented an OCR module for bank guarantee scans with key-field extraction and post-processing to structured outputs. Trained models for defect detection and classification on X-ray images and evaluated their accuracy against task metrics.
RAG
Qwen
Llama
Embeddings
Lab Assistant
•
Middle
National Research Nuclear University MEPhI
•
Full-Time
Worked on computer vision methods to assess brittle-ductile fracture properties using image-based analysis. Developed a neural network for segmentation and classification of fracture-related metal regions. Built a dataset generation approach based on macroscopic object composition to support training data creation for the fracture task.
Middle AI/ML Engineer
Confidence: Medium LLM Engineer
A pragmatic LLM-focused engineer at a solid middle level who produces working retrieval and web-backend code. The strongest proven skill is building end-to-end retrieval plus API integration, evidenced by the Dataset.chunking and Embedder pipeline and the retrieval-to-chat glue in main.py. There is limited evidence of structured evaluation, custom model training, MLOps for model serving, or test coverage in public code.
Model Architecture & Training
2/10
How well models are designed and trained
Basic use of pretrained models and embeddings pipeline; no custom architectures or training loops.
Evidence
RAG_research/embeddings.py: Embedder._load uses SentenceTransformer and encoder.encode/encode with prompt_name
RAG_research/main.py: integration of retrieval context with a chat API (GigaChat) for generation
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Clear, pragmatic data preparation and chunking with validation and JSON I/O; simple but correct retrieval pipeline.
Evidence
RAG_research/dataset.py: Dataset.chunking implements chunk length, overlap checks, and JSON write/read
RAG_research/embeddings.py: embedding creation loop reads chunk.json, encodes text and writes back embeddings
Experimentation & Evaluation
1/10
How results are measured and tested
Minimal experimentation and evaluation artifacts - ad-hoc prints and no structured experiment tracking or held-out evaluation shown.
Evidence
RAG_research/main.py: simple print-based retrieval+chat flow without evaluation harness
RAG_research/embeddings.py: no eval/validation routine present for embedding quality
MLOps & Deployment
2/10
How models are shipped to production
Web service is production-minded at the application level (FastAPI, DB init, health checks), but model serving and MLOps practices are not implemented.
Evidence
shiz_book/backend/app/main.py: lifespan, health and init_db/init_mongo hooks for the FastAPI app
shiz_book/README.md: Docker Compose and deployment notes describing intended deployment topology
Computational Efficiency
1/10
How efficiently computing resources are used
Very limited evidence of compute efficiency work - basic batching/progress reporting and token truncation only.
Evidence
RAG_research/embeddings.py: use of truncate_dim (tokens) when loading SentenceTransformer
RAG_research/embeddings.py: tqdm used for progress reporting during embedding generation
Research Depth & Innovation
1/10
Depth of research and new ideas
Little research depth or novel algorithmic work; mostly integration of existing models and straightforward heuristics.
Evidence
RAG_research/embeddings.py: pipeline around SentenceTransformer for embeddings and similarity search
RAG_research/dataset.py: a simple custom chunking approach for text documents
Verified artifacts
Expertise
RAG• Middle
Industries
Media & Entertainment• Middle
Technologies
SQL
Rest API
LangChain
Qwen
Hadoop
CatBoost
Spark
Docker Compose
YOLO
Embeddings
Scikit-learn
NLP
Llama
Transformers
Git
PyTorch
Docker
LLM
RAG
BERT
pySpark
Recommendations
- Harden the RAG pipeline: add end-to-end evaluation (held-out queries, MRR/recall), reproducible experiment tracking (W&B or MLflow) and unit tests for chunking and search.
- Productionize inference: add a lightweight model-serving layer or async task queue, add rate-limiting, request timeouts, and proper TLS handling instead of verify_ssl_certs=False.
- Add CI and test coverage for the FastAPI app (unit + integration tests), and automate DB migrations and seeded bootstrap flows with tools like Alembic.
- Improve data handling and observability: schema checks, input validation, and basic telemetry/metrics (Prometheus/Grafana) for traffic, errors and latency.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Data Scientist
Confidence: Medium ML Practitioner
A mid-level ML practitioner who produces end-to-end experimental work: dataset construction, model training, and a simple model-serving layer. The strongest proven skill is building a computer-vision training pipeline and integrating the trained YOLO classifier into a FastAPI backend (model_research.ipynb and main.py). There is limited evidence of production-grade testing, CI/CD, robust monitoring, or formal statistical rigor in experiments.
Statistical Rigor
4/10
Correct use of statistics
Shows practical dataset checks and awareness of outliers/label problems and uses proper metrics (RMSE) for time-series experiments, but lacks formal statistical tests, uncertainty quantification, or rigorous multiple-comparison controls.
Evidence
SeriesIntroDetector/ml_research/dataset_research.ipynb
TimeSeriesPredictions/exp1_statistics_ml.ipynb
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Concrete, reproducible data-wrangling for video: timestamp fixes, per-video splitting, frame extraction, balancing classes and saving labels - good pipeline thinking and leakage avoidance by splitting at the video level.
Evidence
SeriesIntroDetector/ml_research/model_research.ipynb: parse_time / scan_paths / frame extraction and class balancing
SeriesIntroDetector/ml_research/dataset_research.ipynb: process_bad_times / scan_directories
Exploratory Analysis & Visualization
5/10
Exploring and visualizing data
Exploratory analysis is present with written reasoning and plotted training/validation curves; notebooks interpret dataset characteristics and training behavior, but visualizations are mostly diagnostic rather than formal data-storytelling tied to business KPIs.
Evidence
SeriesIntroDetector/ml_research/model_research.ipynb: EDA and training loss/accuracy plots
SeriesIntroDetector/ml_research/dataset_research.ipynb: dataset statistics and duration/fps inspection
Predictive Modeling
5/10
Building models that predict
Demonstrates end-to-end modeling (dataset creation, YOLO training, model saving) and uses sensible mitigation for overfitting (dropout), plus time-series baselines (moving averages, GRU, XGB). Lacks thorough error analysis, calibration, or robust CV beyond standard splits.
Evidence
SeriesIntroDetector/ml_research/model_research.ipynb: YOLO training (model.train, dropout, save)
TimeSeriesPredictions/exp1_statistics_ml.ipynb: GRU, XGB, TimeSeriesSplit and RMSE evaluation
Business Insight & Impact
2/10
Turning analysis into business value
Some product awareness - a web app wrapper and notes about convenient usage - but minimal evidence of formal business-metric framing, error-cost analysis, or actionable recommendations tied to stakeholders.
Evidence
SeriesIntroDetector/main.py: FastAPI endpoints and integration point for model inference
SeriesIntroDetector/README.md: description of web-app usage and intended UX
Reproducibility & Notebook Hygiene
4/10
Clean, repeatable analysis
Notebooks show reproducibility habits (requirements.txt, saving models, seeding) and reasonable directory structure; but there is limited evidence of pinned environments, CI, tests, data versioning (DVC) or production deployment hygiene.
Evidence
SeriesIntroDetector/requirements.txt
SeriesIntroDetector/ml_research/model_research.ipynb: saving model and using fixed random seeds
Expertise
Analytics• Middle
Industries
Gaming• Middle
Media & Entertainment• Middle
Technologies
OpenCV
Jupyter Notebook
XGBoost
Matplotlib
Pandas
NumPy
Torchvision
Recommendations
- Develop and harden reproducible pipelines - add environment locking (pip/poetry lock), a reproducible training script, and lightweight CI to run smoke tests on notebooks/scripts.
- Add automated data/versioning and artifact management (DVC or MLFlow/clear model registry) and unit/integration tests for the ingestion and preprocessing steps to prevent silent label errors.
- Improve model evaluation - add calibration checks, confusion/error analyses by video segment, and systematic cross-validation or out-of-fold validation for more trustworthy metrics.
- Harden the serving layer - add input validation, structured logging/metrics, and error handling for edge cases (corrupt uploads, unsupported codecs, out-of-memory frames).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Backend Developer
Confidence: Medium Generalist
A junior-level generalist with strong hands-on coding practice and client-side UI implementation experience. The strongest proven skill is frontend rendering and XSS-aware templating, demonstrated in S-Kitaev/shiz_book/frontend/js/ui.js where escapeHtml() and structured render functions are used consistently. There is little public evidence of production-grade backend engineering practices such as schema migrations, transaction/isolation choices, resilience patterns, or observability hooks.
API Design
2/10
How well APIs are designed
Light API-surface awareness visible in client-side code - routing and usage of API endpoints exist but no backend API design documents, versioning, or idempotency handling were authored in the analyzed human files.
Data Layer & Database
Working with databases
Not evidenced in public code
Scalability & Performance
Handling load and speed
Not evidenced in public code
System Architecture
2/10
Overall system structure
Reasonable module separation on the frontend (rendering, API usage, routing) but no demonstrated multi-service architecture decisions or documented service decomposition in the analyzed human files.
Security & Auth
2/10
Protecting data and access
Basic input/output sanitization and token usage are visible on the client side (XSS mitigation), but there is no human-authored evidence of robust auth lifecycle, refresh/revocation, or backend hardening in the analyzed files.
Reliability & Observability
Stability and monitoring
Not evidenced in public code
Expertise
Python• Junior
Microservices & API Architecture• Junior
Databases & Vector Storage• Junior
Technologies
Python• Middle
Java
MongoDB
PostgreSQL
SQLAlchemy
FastAPI
Pydantic
Uvicorn
Recommendations
- Develop small-to-medium single-service FastAPI endpoints and admin UI features - leverage existing frontend rendering code and implement clear API contracts.
- Improve backend production-readiness: add DB migration history, clear transaction boundaries, and simple observability (structured logs + basic metrics).
- Work on end-to-end features that pair frontend rendering with backend validation and auth flows (refresh/revocation) to demonstrate API design and security decisions.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: