Egor Ilin
AI Engineer
4+ years exp
SQL
JavaScript
Python
MLOps & Deployment: 6/10
Data Pipeline & Feature Engineering: 5/10
Computational Efficiency: 4/10
Active 6 days ago
+7 (950) 8247099 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
An experienced backend/LLM engineering practitioner at a Senior level focused on building production LLM observability and RAG systems. The strongest proven skill is engineering resilient, async observability pipelines and SDKs, as evidenced by the tracer/transport code and extensive integration tests. There is little to no evidence of custom model training, novel architectures or experiment-tracking infrastructure in the public code.
Technical skills
SQL
JavaScript
Python• Senior • 4y+
Python
structlog
Pydantic
Alembic• 4y+
Django• 4y+
FastAPI• 4y+
SQLAlchemy• 4y+
Asyncio• 4y+
HTTPX• 4y+
Databases
pgvector• 3y+
PostgreSQL• 3y+
Redis• 3y+
SQLite• 3y+
AI/ML
AI Agents• 3y+
LLM• 3y+
RAG• 3y+
DevOps
AWS
CI/CD
Git
Nginx
Rest API
Prometheus
OpenTelemetry
Docker• 3y+
QA
Pytest
Frontend
React.js
Timeline
AI / Backend Engineer
•
Middle
LLM Obs
•
Full-Time
Designed and built an LLM monitoring platform to track response time, token usage, request cost, and execution errors. Implemented a distributed tracing and metrics pipeline using FastAPI, Redis, and PostgreSQL, separating request ingestion from background processing and aggregation. Developed a Python SDK for LLM call tracing and built a RAG search service over documents with pgvector-based semantic search and Redis caching. Created additional backend services including an LLM tool-calling Telegram agent, a URL shortener with analytics and safety checks, and an SQL sandbox for executing queries on SQLite databases.
Docker
PostgreSQLsince 2023
Redis
pgvector
LLM
RAG
AI Agents
SQLAlchemysince 2023
SQLite
Python Developer
•
Middle
T1
•
Full-Time
Developed and maintained an automation system for bank and internal support ticket handling. The system transformed request data, called Oracle stored procedures, and executed standard processing flows automatically. Led a migration from Naumen Service Desk to a new SD platform, adapting authorization/data exchange, request formats, statuses, and business logic. Refactored internal Telegram bots into a modular structure and moved PostgreSQL access to async SQLAlchemy while fixing SQL injection by using parameterized queries; also built a Python/Qt desktop tool for managing automation templates.
Python
PostgreSQL
SQLAlchemy
System Administrator
•
Middle
Republican Comprehensive Center for Social Services of the Udmurt Republic
•
Full-Time
Set up workstations and the local network to ensure stable operation of the IT infrastructure. Resolved technical issues reported by users and supported the ongoing operation of servers. Provided operational support for day-to-day infrastructure needs and troubleshooting.
Senior AI/ML Engineer
Confidence: High LLM Engineer
An experienced backend/LLM engineering practitioner at a Senior level focused on building production LLM observability and RAG systems. The strongest proven skill is engineering resilient, async observability pipelines and SDKs, as evidenced by the tracer/transport code and extensive integration tests (llm-obs/sdk/llm_obs/tracer.py and llm-obs/backend/tests/integration/test_ingest_batch_status.py). There is little to no evidence of custom model training, novel architectures or experiment-tracking infrastructure in the public code.
Model Architecture & Training
1/10
How well models are designed and trained
No evidence of custom model architectures or training code; repository contains inference wrappers and provider integrations rather than model building.
Evidence
ai-docs-chat/app/llm/gigachat.py
ai-docs-chat/app/llm/ollama.py
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Clear, production-focused data pipelines for RAG and ingest flows: chunking, parsing, indexing and retrieval with accompanying repository code and scripts.
Evidence
ai-docs-chat/app/pipeline/chunker.py
ai-docs-chat/app/pipeline/indexer.py
test_analiticheskie_programnie_resheniy/app/db/repository.py
Experimentation & Evaluation
3/10
How results are measured and tested
Basic evaluation and validation present (eval scripts and structured test-suite); lacks experiment tracking/benchmarking infrastructure (W&B/MLflow) or extensive ablation pipelines.
Evidence
ai-docs-chat/eval/run_eval.py
ai-docs-chat/eval/questions.json
llm-obs/backend/tests/integration/test_ingest_batch_status.py
MLOps & Deployment
6/10
How models are shipped to production
Strong MLOps/backend engineering: async services, task queue integration, migrations, idempotency, metrics and graceful shutdown considerations are implemented and tested.
Evidence
llm-obs/backend/app/main.py
llm-obs/backend/app/core/taskiq.py
llm-obs/backend/alembic/versions/891391a704b3_initial_schema.py
Computational Efficiency
4/10
How efficiently computing resources are used
Good practical efficiency work at the systems level - batching, async I/O, retries, idempotency and HNSW index creation; no low-level GPU/quantization or profiling evidence.
Evidence
llm-obs/sdk/llm_obs/tracer.py
llm-obs/sdk/llm_obs/transport.py
ai-docs-chat/alembic/versions/2548fdf5cfef_initial_documents_chunks_chat_sessions_.py
Research Depth & Innovation
1/10
Depth of research and new ideas
Little evidence of research-level contributions, novel algorithms or custom model layers - the work is engineering-focused rather than research implementations.
Evidence
ai-docs-chat/app/pipeline/rag.py
Expertise
LLM• Senior
RAG• Middle
Industries
Artificial Intelligence• Senior
Software• Middle
Technologies
Python• Senior • 4y+
SQL
PostgreSQL• 3y+
Rest API
pgvector• 3y+
FastAPI• 4y+
AI Agents• 3y+
CI/CD
Git
SQLite• 3y+
AWS
Docker• 3y+
Nginx
LLM• 3y+
RAG• 3y+
Asyncio• 4y+
Recommendations
- Develop LLM observability, monitoring and alerting products - implement SDK integrations, backends and alerting logic (use existing tracer and worker patterns).
- Build and extend production RAG services - document ingestion, chunking and retrieval pipelines using the existing pipeline/indexer and chunker components.
- Integrate enterprise deployment and MLOps flows - improve CI/CD, runtime role management and outbox/pubsub delivery for large-scale tenants using the alembic and taskiq patterns present.
- Extend SDKs and instrumentation for more languages or frameworks - expand the tracer/transport design to other environments and add richer diagnostics telemetry.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High API Engineer
A backend-focused API engineer at a senior level who has built a production-grade LLM observability service and SDK. The strongest proven skill is designing robust ingestion/workers and SDK delivery with idempotency and retry semantics - evidenced by process_span.py, the ingest/idempotency service and comprehensive tests (tests/integration/test_ingest_batch_status.py and sdk tests). Public code lacks large multi-service orchestration examples and long-running, cross-team operational histories (most evidence is a single well-architected service and SDK).
API Design
6/10
How well APIs are designed
API design shows deliberate decisions - versioned v1 routes, idempotency support, rate-limiting hooks and consistent error handling with tests; not just autogenerated CRUD.
Evidence
llm-obs/backend/app/api/v1/ingest.py: ingest_spans endpoint with idempotency handling and rate limiter dependency
llm-obs/backend/tests/integration/test_ingest_batch_status.py: tests exercising idempotency, error contracts and rate-limit headers
llm-obs/backend/app/api/v1/projects.py: API key creation/rotation endpoints and RBAC checks
Data Layer & Database
6/10
Working with databases
Data layer shows migration history, transactional patterns, idempotency store and careful trace/aggregate updates - evidence of schema evolution and transactional reasoning.
Evidence
llm-obs/backend/alembic/versions/d4e5f6a7b8c9_runtime_database_role_grants.py: runtime database role grants migration
llm-obs/backend/app/workers/process_span.py: ensure_trace_row, bulk insert usage and careful update/ON CONFLICT patterns
llm-obs/backend/app/services/ingest.py: PostgresIdempotencyStore and use of insert ... ON CONFLICT
Scalability & Performance
6/10
Handling load and speed
Scalability and performance patterns are present - bulk inserts, worker queues, outbox pattern, metrics and retryable transport with idempotency keys were implemented and tested.
Evidence
llm-obs/backend/app/core/metrics.py: Prometheus metrics and queue/outbox backlog queries
llm-obs/backend/app/workers/process_span.py: bulk_insert_spans, broker tasks and enqueue_outbox_event calls
llm-obs/sdk/llm_obs/transport.py and llm-obs/sdk/llm_obs_tests/test_tracer.py: transport retry/backoff behavior and idempotency key tests
System Architecture
5/10
Overall system structure
System architecture is modular with clear module boundaries (api, services, workers, core) and lifecycle/graceful-shutdown handling, though the system is a tightly-coupled service rather than a multi-service distributed system.
Evidence
llm-obs/backend/app/main.py: lifespan, middleware and graceful shutdown wiring
llm-obs/backend/app/services/outbox.py and llm-obs/backend/app/services/pubsub.py: outbox and pubsub manager separation
llm-obs/backend/app/core/config.py: settings validation and production-environment guards
Security & Auth
6/10
Protecting data and access
Security and auth displayed practical care - JWT/api-key handling, password hashing, api-key rotation and webhook DNS checks for SSRF, with tests covering policies and access control.
Evidence
llm-obs/backend/app/core/auth.py: JWT creation/validation, password hashing and api key resolution
llm-obs/backend/app/api/v1/projects.py: api key rotation and cache invalidation logic
llm-obs/backend/app/services/notifications.py and backend/tests/integration/test_notifications.py: webhook validation and DNS-based private-address checks
Reliability & Observability
6/10
Stability and monitoring
Reliability and observability are well represented - structured logging, Prometheus metrics, health/readiness checks, graceful shutdown and extensive tests for failure modes and retries.
Evidence
llm-obs/backend/app/core/metrics.py: Prometheus instrumentation and metric callbacks
llm-obs/backend/tests/unit/test_graceful_shutdown.py and llm-obs/backend/app/main.py: lifespan and graceful shutdown tests
llm-obs/sdk/llm_obs_tests/test_tracer.py: transport diagnostics, retry behavior and final-delivery diagnostics
Expertise
Backend AI & LLM• Middle
Microservices & API Architecture• Middle
Messaging & Real-time• Middle
Databases & Vector Storage• Middle
Industries
Artificial Intelligence• Senior
Technologies
Redis• 3y+
OpenTelemetry
Prometheus
Pydantic
HTTPX• 4y+
Alembic• 4y+
structlog
Recommendations
- Use this developer to implement and extend backend APIs and SDKs for LLM observability - specifically ingestion pipelines, idempotency and transport reliability.
- Assign them to design and harden data-layer features: migrations, partitioning/retention, transactional outbox and schema evolution work.
- Engage them to build and test worker-driven pipelines and observability (metrics, alerts, DLQ/retry runbooks and graceful shutdown).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle DevOps Engineer
Confidence: Medium Generalist
A pragmatic backend-focused generalist at a middle level who builds small-to-medium Python web and DB applications. The strongest proven skill is backend application development using async FastAPI and SQL handling - evidenced by sqlSandbox/main.py and sqlSandbox/db.py which implement async DB access, query parsing, lifecycle cleanup and error handling. The public code does not demonstrate CI/CD pipelines, infrastructure-as-code, container orchestration, observability-as-code or formal incident/runbook artifacts.
CI/CD Pipelines
Automated build and deploy
Not evidenced in public code
Infrastructure as Code
Managing servers with code
Not evidenced in public code
Containerization & Orchestration
Working with containers
Not evidenced in public code
Observability & Monitoring
Watching system health
Not evidenced in public code
Reliability & Incident Response
2/10
Keeping systems up
Minimal reliability-oriented engineering is present - resource lifecycle cleanup and basic DB error handling exist but there are no runbooks, deploy strategies or incident artifacts.
Evidence
sqlSandbox/main.py: lifespan asynccontextmanager that disposes engine and removes uploaded DB file
birthday-reminder/db.py: create_database handles ProgrammingError and add_person rolls back on IntegrityError
Cloud & Cost Optimization
Smart use of the cloud
Not evidenced in public code
Industries
Food & Beverages• Middle
Manufacturing• Middle
Technologies
SQLAlchemy• 4y+
Django• 4y+
Recommendations
- Develop backend services and internal web tools that perform data access and CRUD operations (FastAPI + async DB work).
- Implement and maintain small Django applications or MRP/ERP-style inventory modules with domain logic around recipes and costing.
- Build user-facing admin tooling that accepts uploads and performs safe SQL inspection with hardened validation and sandboxing.
- Work on application reliability tasks such as graceful shutdown, resource lifecycle automation and basic runbooks for small services.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: