Romanov Danil
Python
Experimentation & Evaluation: 5/10
Data Pipeline & Feature Engineering: 4/10
MLOps & Deployment: 4/10
Active 16 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
An LLM-focused engineer with strong hands-on experience building agentic RAG systems and production backends at a mid-to-senior level. The strongest proven skill is building reliable LLM-driven pipelines and agent orchestration with streaming, tooling and evals - evidenced by the LangGraph-based agent/service (app/modules/agent/*) plus the evals harness and MLflow integration (backend/evals/*). The public codebase shows solid engineering (tests, DB savepoints, health checks) but does not contain custom model training, low-level optimization, or original research artifacts.
Technical skills
Python• Middle • 3y+
Python
FastAPI
SQLAlchemy
Asyncio
aiogram
Databases
Qdrant
PostgreSQL
AI/ML
MLFlow
OpenAI SDK
AI/ML
Middle AI/ML Engineer
Confidence: Medium LLM Engineer
An LLM-focused engineer with strong hands-on experience building agentic RAG systems and production backends at a mid-to-senior level. The strongest proven skill is building reliable LLM-driven pipelines and agent orchestration with streaming, tooling and evals - evidenced by the LangGraph-based agent/service (app/modules/agent/*) plus the evals harness and MLflow integration (backend/evals/*). The public codebase shows solid engineering (tests, DB savepoints, health checks) but does not contain custom model training, low-level optimization, or original research artifacts.
Model Architecture & Training
2/10
How well models are designed and trained
No custom model architectures or training loops; LLM use is integration-focused (model selection, prompts, and judge/eval harness).
Evidence
FinAgent/backend/evals/__main__.py: orchestration of agent runs against golden dataset (integration, not training)
FinAgent/backend/evals/scoring.py: judge + deterministic scoring using LLM judge (ragas) and regex checks
FinAgent/backend/app/shared/llm.py: get_chat_model wrapper for provider selection
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Robust document ingestion and preprocessing pipeline (PDF/CSV parsing, OCR fallback, chunking) and embedding ingestion to Qdrant.
Evidence
FinAgent/backend/app/modules/statements/parsers/pdf_parser.py: PDF extraction, bank detection, OCR fallback
FinAgent/backend/app/modules/statements/parsers/csv_parser.py: CSV parsing, date/amount normalization and errors
rag/local/services/pdf_processor.py: cleaning, chapter/article split, batching embeddings upload to Qdrant
Experimentation & Evaluation
5/10
How results are measured and tested
Dedicated offline evals harness with deterministic checks, Ragas judge integration and MLflow logging; substantial unit tests covering logic and regressions.
Evidence
FinAgent/backend/evals/__main__.py: runs golden dataset, logs to MLflow
FinAgent/backend/evals/scoring.py: deterministic + LLM-judge scoring
FinAgent/backend/evals/tests/test_evals.py: test coverage for eval pipeline
MLOps & Deployment
4/10
How models are shipped to production
Production-minded serving and lifecycle work: FastAPI SSE streaming, health checks, Alembic migrations, Qdrant ingestion and Docker-based deployment patterns.
Evidence
FinAgent/backend/app/main.py: FastAPI app with streaming endpoints and health responses
FinAgent/backend/app/core/health.py: health checks for Postgres, Qdrant, LLM provider, Tesseract, MLflow
rag/local/services/pdf_processor.py and rag/cloud/services/pdf_processor.py: Qdrant index creation and upsert batching
Computational Efficiency
2/10
How efficiently computing resources are used
Some efficiency-minded code (batch uploads, DB savepoints, statement timeouts), but no GPU/quantization/profiling or distributed training artifacts.
Evidence
rag/local/services/pdf_processor.py: batch_size and chunk truncation before embedding encoding
FinAgent/backend/app/modules/transactions/repository.py: execute_readonly_query uses begin_nested() and SET LOCAL statement_timeout
Research Depth & Innovation
1/10
Depth of research and new ideas
No original research or custom neural layers; innovation is applied system design rather than novel algorithms.
Evidence
FinAgent/backend/evals/scoring.py: practical evaluation heuristics and LLM-judge integration (applied, not research)
FinAgent/backend/app/modules/agent/graph.py: integration of LangGraph and prompt engineering (system design, not new algorithms)
Expertise
AI Agents & Agentic Workflows• Middle
RAG• Middle
LLM• Middle
Conversational AI & Chatbots• Middle
Document Intelligence & OCR• Middle
Industries
Financial Services• Middle
Technologies
SQLAlchemy
MLFlow
Cloud• mentioned only
Docker• mentioned only
LangChain• mentioned only
LangGraph• mentioned only
LLM• mentioned only
Ollama• mentioned only
PostgreSQL• mentioned only
RAG• mentioned only
Recommendations
- Develop RAG-driven, agentic backend services that require streaming LLM responses, tool-calling, and eval pipelines.
- Implement document ingestion and OCR pipelines for finance/legal domains, including Qdrant-based retrieval and embedding batching.
- Build and harden LLM-backed APIs with SSE streaming, DB transaction safety (savepoints) and deterministic evals (MLflow + Ragas).
- Operate conversational RAG bots (Telegram/web) that need robust user/admin flows, role management, and content moderation safeguards.
Middle Data Scientist
Confidence: Medium Data Engineer
A backend-focused data engineer at a solid middle level who builds document-ingestion and retrieval systems. The strongest proven skill is document parsing and ingestion into a vectorized RAG pipeline, evidenced by the pdf_processor modules that extract, clean, split and upload passages to Qdrant (local and cloud variants). There is little or no evidence of statistical analysis, modeling experiments, notebooks, or formal ML training workflows in the human-authored code set.
Statistical Rigor
Correct use of statistics
Not evidenced in public code
Data Wrangling & Cleaning
5/10
Preparing and cleaning data
Concrete, reusable ingestion and cleaning logic for document PDFs - robust text extraction, cleaning, chapter/article splitting and selection before embedding/upload.
Exploratory Analysis & Visualization
Exploring and visualizing data
Not evidenced in public code
Predictive Modeling
2/10
Building models that predict
Embedding-based retrieval is used (OpenAI or SentenceTransformer) and a vector DB is populated; no model training / predictive-modeling workflows or experiment design were present.
Business Insight & Impact
2/10
Turning analysis into business value
Product-minded features (admin stats, role checks, token bookkeeping) exist but there is little evidence of explicit business-metric framing or cost-of-error analysis.
Reproducibility & Notebook Hygiene
2/10
Clean, repeatable analysis
Reasonable reproducibility basics - requirements files and code that creates DB schema programmatically - but no pinned environment files, DVC, or CI pipeline visible in the human-authored set.
Expertise
Big Data• Middle
Analytics• Middle
Industries
Financial Services• Middle
Government• Middle
Technologies
AI/ML
Python• Middle • 3y+
PostgreSQL
OpenAI SDK
Asyncio
aiogram
FastAPI• mentioned only
LangChain• mentioned only
LangGraph• mentioned only
LLM• mentioned only
MLFlow• mentioned only
Ollama• mentioned only
Qdrant• mentioned only
RAG• mentioned only
Recommendations
- Develop production document-ingestion pipelines and RAG systems - cleaning, chunking, embedding batching, and Qdrant uploads (extend the pdf_processor pattern into a reusable ETL pipeline).
- Build and harden embedding & retrieval infra - add batching, retry/backoff, monitoring for embedder failures, and integration tests for vector DB operations.
- Own async backend microservices that expose SSE/chat streams and safe SQL read-only query endpoints - leverage the asyncpg/pool and careful savepoint patterns shown in the DB code.
- Implement reproducibility & ops hygiene - add pinned dependency manifests, lightweight CI that runs core unit/integration tests, and a small data-versioning step for fixture uploads.
Middle Backend Developer
Confidence: High API Engineer
A practical backend engineer at a solid middle level who builds integration-focused services (Telegram bot + RAG pipeline) with clear, pragmatic code. The strongest proven skill is building RAG ingestion and runtime plumbing - e.g., PDF parsing, batching embeddings and Qdrant upload in rag/local/services/pdf_processor.py and async DB pooling in rag/cloud/database/async_db.py. There is limited public evidence of designing large-scale distributed systems, advanced monitoring/observability, or production-grade secret-management patterns.
API Design
2/10
How well APIs are designed
Basic, correct handler-level API work for a Telegram bot and clear separation of handler/service layers, but no evidence of formal API versioning, idempotency keys, pagination contracts, or consistent error contract design.
Data Layer & Database
4/10
Working with databases
Solid application-level data layer practices: connection pooling, parameterized SQL, schema creation checks, and pragmatic repository-style functions; not a deep migration-history or advanced SQL-tuning story in the human-authored files.
Scalability & Performance
4/10
Handling load and speed
Good practical scaling measures: asyncpg pool sizing, running heavy CPU/IO work off the event loop, and batching for vector uploads; lacking advanced instrumentation, cache invalidation strategies, or sophisticated rate-limiting.
Evidence
FluDex7/rag/cloud/database/async_db.py: create_pool(min_size=1, max_size=10)
FluDex7/rag/local/services/pdf_processor.py: batch_size and upsert batching for Qdrant; use of SentenceTransformer for local embeddings
FluDex7/rag/cloud/handlers/user_handlers.py: offloading PDF processing to run_in_executor to avoid blocking the event loop
System Architecture
3/10
Overall system structure
Reasonable modular structure (handlers, services, database) and separate cloud/local variants show practical decomposition; architecture is straightforward app-level splitting rather than evidence of multi-service decomposition or sophisticated resilience boundaries.
Security & Auth
3/10
Protecting data and access
Basic security hygiene is present - parameterized DB queries, role checks before admin actions, file extension validation - but secrets handling, explicit rotation, SSRF/file path hardening and comprehensive input validation are not strongly evidenced in the human-authored files.
Reliability & Observability
3/10
Stability and monitoring
Good pragmatic reliability practices - logging and try/except around external ops, safe DB conn management, backgrounding long jobs - but no visible structured tracing, metrics, retry-with-backoff policies, or circuit-breakers in the human-authored files.
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Industries
Financial Services• Middle
Government• Middle
Technologies
Qdrant
FastAPI
Cloud• mentioned only
Docker• mentioned only
SQL• mentioned only
Recommendations
- Lead development of integrations and webhooks-driven services - Telegram bots, RAG ingestion pipelines and embedding ingestion jobs.
- Implement and harden vector-store ETL and embedding pipelines, including batching, backpressure and retry policies for Qdrant/embedding providers.
- Own mid-size API services that need robust async DB pooling and background job handling, including reliable file upload and parsing flows.
- Extend observability and resilience: add structured tracing, metrics, retries with jitter, and documented health/check endpoints.