Dmitry Odegov
Python
Data Pipeline & Feature Engineering: 6/10
MLOps & Deployment: 5/10
Research Depth & Innovation: 5/10
Invite to interview
Download CVCV
Overview
Technical skills
Roles
Overview
A senior-level backend engineer focused on asynchronous API systems and LLM/RAG tooling. The strongest proven skill is designing resilient async APIs and RAG pipelines, evidenced by ChatService orchestration (FrankenJet/backend/app/services/chat.py), vectorizer gRPC microservice and FAISS/pgvector integration. Public code lacks explicit deployment runbooks and wide-spectrum SRE artifacts (detailed rate-limiting policies, infra-as-code for production), so operational hardening is not fully evidenced.
Technical skills
Python
Python
FastAPI
SQLAlchemy
Boto3
Asyncio
aiogram
Alembic
Aiohttp
Databases
PostgreSQL
ElasticSearch
Redis
FAISS
pgvector
RabbitMQ
DevOps
AWS
AI/ML
NumPy
Senior AI/ML Engineer
Confidence: Low LLM Engineer
A senior LLM-focused engineer with strong hands-on experience building production RAG/LLM systems and related infra. The strongest proven skill is end-to-end RAG/LLM engineering and orchestration, supported by the RagPipeline, retrieval methods (reciprocal rank fusion) and many tests (see avia-rag-bot/app/rag and tests). There is limited evidence of custom model training loops, experiment tracking, or low-level GPU optimization in public code.
Model Architecture & Training
4/10
How well models are designed and trained
Strong applied model engineering for LLM-based inference and RAG orchestration (system prompts, embeddings, client wrappers), but no evidence of custom training loops or new model architectures.
Evidence
avia-rag-bot/backend/app/rag/pipeline.py: RagPipeline
avia-rag-bot/backend/app/llm/embeddings.py: EmbeddingClient
FrankenJet/backend/app/services/chatbot.py: ChatBotServices (LLM / GigaChat integration)
Data Pipeline & Feature Engineering
6/10
How data is prepared for models
Well-structured ETL and vectorization pipelines - dedicated chunker/parser, manifest and embedding workflows, dataset prep and augmentation for CV.
Evidence
avia-rag-bot/backend/etl/chunker.py: chunk_document
avia-rag-bot/backend/etl/parser.py: parse_markdown
Ride-Monitor/dataset-prep/src/ride_monitor_prep/service.py: DatasetPrepService
Experimentation & Evaluation
4/10
How results are measured and tested
Good automated test coverage and unit/integration tests for LLM/RAG behaviors and ETL; little evidence of formal experiment tracking (W&B/MLflow) or A/B pipelines.
Evidence
avia-rag-bot/backend/tests/unit/llm/test_prompt_guard.py
FrankenJet/backend/tests/api/test_articles.py
MLOps & Deployment
5/10
How models are shipped to production
Production-minded infra: vectorizer microservice (gRPC), FAISS index manager, ETL scripts, gRPC/proto and service run scripts indicate deployment readiness and MLOps work.
Evidence
FrankenJet/vectorizer/app/service.py: VectorizerService (gRPC service)
avia-rag-bot/backend/app/core/faiss_manager.py: FaissManager
FrankenJet/vectorizer/proto/vectorizer_pb2_grpc.py: generated gRPC stubs (service surface)
Computational Efficiency
4/10
How efficiently computing resources are used
Practical efficiency work (FAISS usage, embedding batching and async patterns) but no low-level GPU/CUDA optimizations, quantization, or measured before/after profiling artifacts.
Evidence
avia-rag-bot/backend/app/core/faiss_manager.py: search and index write helpers
avia-rag-bot/backend/app/llm/embeddings.py: iter_embed_batches / embed_texts (batching)
Research Depth & Innovation
5/10
Depth of research and new ideas
Clear applied research-level design in retrieval and RAG (reciprocal-rank-fusion, decision-tree guidance, multi-method RAG orchestration) showing thoughtful algorithmic choices.
Evidence
avia-rag-bot/backend/app/rag/retrieval.py: reciprocal_rank_fusion, VectorRetriever
avia-rag-bot/backend/app/rag/decision_tree.py: decision tree guidance generation
Expertise
LLM• Senior
MLOps & Model Lifecycle• Senior
RAG• Senior
Conversational AI & Chatbots• Senior
Industries
Transportation & Logistics• Middle
Recommendations
- Lead development of production RAG-powered assistants and retrieval pipelines (RagPipeline, retrieval lanes, rerank).
- Build/operate embedding and vectorization microservices (gRPC vectorizer, FAISS index management, batch embedding).
- Implement ETL and document-chunking pipelines for knowledge base indexing and QA (chunker/parser modules).
- Integrate and harden conversational platforms with prompt guards, SSE tracing and idempotency (chat service, prompt_guard, sse_manager).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: Low Data Engineer
A strong mid-to-senior data-engineer focused on backend and ETL for vector search and RAG systems. The strongest proven skill is building robust async ETL and ingestion pipelines with resumable embedding checkpoints (evidence: backend/app/services/etl.py and backend/scripts/init_data.py). There is limited evidence of statistical analysis, experiment design, or formal ML evaluation workflows in the public human-authored code.
Statistical Rigor
Correct use of statistics
Not evidenced in public code
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Clear, production-grade ETL and data ingestion code with type conversions, checkpointing, incremental embedding reuse, and robust error/cancellation handling.
Evidence
backend/scripts/init_data.py:DataUtils.convert_data_types - comprehensive type conversion and safe date/UUID parsing
avia-rag-bot/backend/etl/chunker.py:chunk_document - document chunking and content-type extraction
backend/app/services/etl.py:ETLService._embed_missing - batching embeddings, checkpoint saves, and asyncio.CancelledError handling
Exploratory Analysis & Visualization
Exploring and visualizing data
Not evidenced in public code
Predictive Modeling
4/10
Building models that predict
Inference and embedding services plus CV training scripts exist, but no evidence of rigorous model evaluation pipelines or advanced ML experimentation (limited model-tuning traces).
Evidence
vectorizer/app/models.py:EmbeddingModel - embedding interface using FastEmbed and SentenceTransformer
vectorizer/app/service.py:VectorizerService - gRPC serving of embedding endpoints
Ride-Monitor/training/src/ride_monitor_train/train.py:TrainingService - YOLO training orchestration
Business Insight & Impact
2/10
Turning analysis into business value
Product READMEs and PRD-like docs show domain intent (airport staff assistant, aviation encyclopedia), but there is limited code linking analysis to explicit business metrics or cost-of-error calculations.
Evidence
FrankenJet/README.md - project description focused on aviation product goals
avia-rag-bot/README.md - RAG bot for airport staff and mentions of evaluation and RAG methods
Reproducibility & Notebook Hygiene
6/10
Clean, repeatable analysis
Good reproducibility practices for a backend service: many integration/unit tests, DB/bootstrap scripts, ETL checkpointing and manifest generation; environment pinning files are not prominent in the analyzed human-authored content.
Evidence
backend/tests/* - extensive unit and integration tests covering API, ETL, RAG pipeline and prompt guard logic
backend/scripts/init_db.py and backend/scripts/init_data.py - DB bootstrap and data seeding scripts
backend/app/services/etl_checkpoint.py:IngestCheckpointStore - checkpoint saving/compatibility for resumable ingest runs
Expertise
Big Data• Middle
Streaming• Middle
Industries
Transportation & Logistics• Middle
Technologies
NumPy
Boto3
aiogram
Computer Vision• mentioned only
RAG• mentioned only
SQLite• mentioned only
Vision• mentioned only
Recommendations
- Develop production RAG and vector-search backends - ingest, embedding orchestration, FAISS integration, and SSE/RMQ streaming glue.
- Implement and maintain ETL pipelines and data onboarding tooling - chunking, embedding checkpointing, manifest/versioning and DB bootstrap scripts.
- Build and harden LLM-serving wrappers and safety guards - prompt-guarding, decision-tree guidance integration and robust error handling for LLM/RAG I/O.
- Take ownership of microservices that require async IO, message-brokers and S3/MinIO integration (notifications, vectorizer, and ingestion services).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: Low API Engineer
A senior-level backend engineer focused on asynchronous API systems and LLM/RAG tooling. The strongest proven skill is designing resilient async APIs and RAG pipelines, evidenced by ChatService orchestration (FrankenJet/backend/app/services/chat.py), vectorizer gRPC microservice and FAISS/pgvector integration. Public code lacks explicit deployment runbooks and wide-spectrum SRE artifacts (detailed rate-limiting policies, infra-as-code for production), so operational hardening is not fully evidenced.
API Design
6/10
How well APIs are designed
Clear, consistent REST API surface with error contract types, explicit idempotency handling and input validation; evidence of pagination/filtering and documented API routers.
Evidence
FrankenJet/backend/app/api/auth.py: auth endpoints and token flows
FrankenJet/backend/app/schemas/api.py: SuccessResponse/ApiResponse and status_ok usage
FrankenJet/backend/app/services/chat.py: client_message_id resume logic (idempotency) observed and referenced by tests (tests/api/test_chat.py)
Data Layer & Database
6/10
Working with databases
Layered data access with repositories, async SQLAlchemy usage, explicit transaction/commit/rollback in DBManager and Alembic migration hooks; selectinload and raw SQL helpers show awareness of N+1 and tuned queries.
Evidence
FrankenJet/backend/app/db/repository/base.py: BaseRepository with select_paginated/insert_all_conflict patterns
FrankenJet/backend/app/core/db_manager.py: DBManager with commit/rollback and context managers
FrankenJet/backend/alembic/dev/env.py and main/env.py: alembic environment present (migration pipeline)
Scalability & Performance
6/10
Handling load and speed
Asynchronous architecture, vector-search microservice, caching and queue integration indicate deliberate scalability choices; performance-conscious patterns (commit before external I/O, FAISS index use) are present.
Evidence
FrankenJet/backend/app/core/vectorizer.py and FrankenJet/vectorizer/: gRPC vectorizer microservice and vectorizer manager
FrankenJet/backend/app/core/cache_manager.py: Redis-backed caching manager and decorators
avia-rag-bot/backend/app/core/faiss_manager.py: FAISS index build/search indicating tuned vector search
System Architecture
6/10
Overall system structure
Modular microservice decomposition (backend, vectorizer, notifications) with explicit managers for ES, RMQ, S3 and clear service boundaries and lifecycle handling.
Evidence
FrankenJet/backend/app/core/rmq_manager.py: RMQManager with broker abstraction and subscriber/publisher context managers
FrankenJet/backend/app/core/es_manager.py: ESManager with start/close/context methods
Repo layout: distinct services - FrankenJet/backend, FrankenJet/vectorizer, FrankenJet/notifications (multiple pyproject.toml files)
Security & Auth
6/10
Protecting data and access
Thoughtful auth/security primitives: JWT lifecycle, token validation, password hashing, OAuth2 flows and prompt-guarding logic; input validation via Pydantic schemas is used consistently.
Evidence
FrankenJet/backend/app/services/security.py: hash_password, verify_password, create_jwt_token and decode_token
FrankenJet/backend/app/dependencies/auth.py: token extraction and role checks (HTTPBearer integration)
FrankenJet/backend/app/llm/prompt_guard.py (avia-rag-bot): prompt-injection detection logic and tests demonstrating defensive behaviour
Reliability & Observability
6/10
Stability and monitoring
Good reliability/observability practices: structured logging and handlers, retries/backoff for LLM HTTP calls, graceful lifecycle management and extensive tests covering retry and failure scenarios.
Evidence
FrankenJet/backend/app/core/logs_handlers.py: NotificationHandler for sending logs to bot (observability integration)
avia-rag-bot/backend/app/llm/http_retry.py: retry logic with backoff and tests covering retry behavior
FrankenJet/backend/app/core/api_settings.py and shutdown event usage in main.py: lifespan and graceful shutdown patterns
Expertise
Databases & Vector Storage• Senior
Microservices & API Architecture• Senior
Backend AI & LLM• Senior
Messaging & Real-time• Senior
Technologies
Python• since 2023 • Senior
PostgreSQL
Redis
pgvector
FAISS
SQLAlchemy
RabbitMQ
FastAPI
AWS
ElasticSearch
Asyncio
Aiohttp
Alembic
SQLite• mentioned only
Recommendations
- Lead development of RAG/LLM-backed APIs and conversational backends (idempotency, prompt-guarding and traceable RAG metadata).
- Implement or improve vector search infrastructure and DB migration strategies (PG + pgvector, FAISS maintenance, index versioning).
- Design and harden async microservices and messaging patterns (RabbitMQ subscribers, backpressure, observability dashboards and runbooks).
- Own reliability SRE tasks: production rate-limiting, SLOs/alerts, and end-to-end deployment infra (IaC + CI/CD) to bridge current code with ops.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: