Dmitry Odegov
Python
Data Pipeline & Feature Engineering: 6/10
MLOps & Deployment: 5/10
Research Depth & Innovation: 5/10
Active 16 days ago
Invite to interview
Message
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• Senior • 3y+
Python
FastAPI
SQLAlchemy
Asyncio
aiogram
Boto3
Alembic
Aiohttp
Databases
FAISS
PostgreSQL
ElasticSearch
RabbitMQ
Redis
pgvector
AI/ML
NumPy
DevOps
AWS
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• Senior • 3y+
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: