Egor Pestov
AI Engineer
Python
TypeScript
Node JS
Rust
SQL
JavaScript
Solidity
Experimentation & Evaluation: 7/10
MLOps & Deployment: 6/10
Data Pipeline & Feature Engineering: 5/10
Active 11 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Roles
Overview
Backend engineer (senior-level) focused on building LLM-backed retrieval and RAG pipelines for security workflows. The strongest proven skill is designing a hexagonal Python FastAPI service with adapters, reproducible offline eval and extensive integration tests (see app/api/app.py, app/adapters/* and app/eval/*). The public code shows limited evidence of large-scale multi-region distributed systems, long migration histories, or advanced SRE/runbook artifacts.
Technical skills
Languages
7
Python
TypeScript
Node JS
Rust
SQL
JavaScript
Solidity
Python
7
FastAPI
Pydantic
HTTPX
SQLAlchemy
Alembic
Uvicorn
Mypy
Databases
3
PostgreSQL
pgvector
Redis
AI/ML
8
LLM
Claude
Gemini
Anthropic
Pydantic AI
Claude Code
AI/ML
RAG
Frontend
4
React.js
Next.js
Tailwind CSS
PostCSS
Web3
5
Arbitrum
Bitcoin
Solana
Ethereum
Slither
Other
13
Tokio
Axios
Electron
Playwright
GitHub Actions
Netlify
PoC Library
Docker
Rest API
CI/CD
WebRTC
Clean Architecture
Hallucination
Middle AI/ML Engineer
Confidence: Medium LLM Engineer
An LLM-focused engineer (senior level) who builds production RAG and agent systems for smart-contract security with an emphasis on reproducible evals and robust runtime behavior. The strongest proven skill is engineering reproducible, gated evaluation and retrieval ablations, demonstrated by the eval harness, committed detector-eval artifacts, and retrieval ablation reports (app/eval/* and assets/eval/reports). Public code shows strong deployment, testing and retrieval engineering, but it does not contain custom model training loops, low-level GPU/quantization work or novel ML algorithms.
Model Architecture & Training
2/10
How well models are designed and trained
Model architecture and training are minimal; the repo uses hosted LLMs and prompt/response orchestration rather than custom model training or novel loss/optimizer work.
Evidence
app/rag/rerank.py: llm_rerank performs LLM-based reranking of retrieval candidates
app/rag/embedding_classifier.py: EmbeddingClassifier wraps embedder-based classification (inference-level engineering, not training)
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
A well-engineered data pipeline for RAG: chunking, front-matter, vendored corpora, embedding fixtures and deterministic ingest are present; good handling of language/metadata edge-cases.
Evidence
app/rag/ingest.py: chunks_for / ingest pipeline and batched embedding calls
app/rag/chunk.py: chunk_text and paragraph splitting logic
scripts/record_embeddings.py: recording embedding fixtures for reproducible offline eval
Experimentation & Evaluation
7/10
How results are measured and tested
Honest, reproducible evaluation and gating are a clear focus: deterministic eval harness, gold sets, ablation reporting, and CI gates with statistical intervals are implemented and tested.
Evidence
app/eval/harness.py: run_detector_eval / run_agent_eval harness separating detector- and agent-level evaluation
app/eval/report.py and assets/eval/reports/detector-eval.md: rendering of eval with Wilson intervals and committed reproducible artifacts
tests/unit/test_recall_gate.py: unit test asserting the recall gating behavior
MLOps & Deployment
6/10
How models are shipped to production
Strong MLOps and deployment engineering for an LLM-backed service: adapter factories, provider routing, budget tracking, timeouts and app lifecycle/resource management are implemented with meaningful integration tests.
Evidence
app/adapters/llm/factory.py and app/adapters/llm/router.py: provider factory and routing with budget accounting
app/api/app.py and app/api/dependencies.py: FastAPI app lifecycle, DI and bounded ThreadPoolExecutor for concurrent requests
app/observability/budget.py and tests/unit/test_budget.py: budget tracker implementation and thread-safety tests
Computational Efficiency
5/10
How efficiently computing resources are used
Concrete efficiency work is present (batched embeddings, bounded executor, connection pooling awareness) though low-level GPU/quantization/compile-time optimizations are absent.
Evidence
app/agent/auditor.py and tests/unit/test_auditor.py: embedding batching and fan-out caps
app/adapters/vectorstore/pgvector_store.py (schema + pool-aware code): careful connection/pool handling and bootstrap of vector extension
Research Depth & Innovation
5/10
Depth of research and new ideas
Research-style rigor is applied to evaluation and ablations (RRF, hybrid vs dense analysis, cross-model judge), but there are no novel ML algorithms or reproduced SOTA training runs.
Evidence
app/eval/retrieval_harness.py and assets/eval/reports/ablation.md: ablation experiments and retrieval analysis
app/eval/judge.py and tests/unit/test_eval_judge.py: cross-model grounding judge that enforces judge != generator
Expertise
RAG• Middle
AI Agents & Agentic Workflows• Middle
Industries
Blockchain & Crypto• Middle
Technologies
AI/ML
Python• Middle
SQL
PostgreSQL
Redis
Rest API
Claude
pgvector
Claude Code
SQLAlchemy
GitHub Actions
Netlify
Pydantic AI
CI/CD
Docker
Gemini
LLM
RAG
Mypy
HTTPX
Alembic
Hallucination
Anthropic
Hallucination• mentioned only
Human-in-the-Loop• mentioned only
Python• mentioned only
Qdrant• mentioned only
RAG• mentioned only
Recommendations
- Develop RAG-backed LLM agents and grounded-audit pipelines with reproducible eval gates and metric-based CI
- Implement and harden production LLM service integrations (provider routing, timeouts, budget accounting, fallbacks and concurrency guards)
- Build retrieval and indexing components (embedding fixtures, chunking, ingest pipelines, and deterministic offline gates)
- Design measurable evaluation suites and ablation experiments for retrieval/grounding to support product-quality gates
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: High API Engineer
Backend engineer (senior-level) focused on building LLM-backed retrieval and RAG pipelines for security workflows. The strongest proven skill is designing a hexagonal Python FastAPI service with adapters, reproducible offline eval and extensive integration tests (see app/api/app.py, app/adapters/* and app/eval/*). The public code shows limited evidence of large-scale multi-region distributed systems, long migration histories, or advanced SRE/runbook artifacts.
API Design
5/10
How well APIs are designed
API design shows deliberate error handling, dependency wiring, and a consistent schema layer, but lacks explicit versioning strategy and advanced idempotency patterns at the HTTP boundary.
Evidence
app/api/app.py: create_app and lifespan wiring for dependencies and executor
app/api/dependencies.py: require_api_key and DI helpers
tests/unit/test_api_routes.py: coverage of routes behaviour and auth checks
Data Layer & Database
6/10
Working with databases
Data layer demonstrates explicit schema-init, connection-pool usage and DB specific SQL (pgvector + full-text), with integration tests; migration history is not visible as a chain in the provided files.
Evidence
app/adapters/vectorstore/pgvector_store.py: ConnectionPool usage, schema init and tsvector handling
tests/integration/test_pgvector.py: concurrent search and pool tests
app/adapters/vectorstore/factory.py: store factory showing multi-backend design
Scalability & Performance
6/10
Handling load and speed
Multiple runtime and performance decisions are present: bounded executors, batched embeddings, client timeouts and thread-safe budget accounting, plus integration tests for concurrency and thread-safety.
Evidence
app/agent/auditor.py: app-level bounded ThreadPoolExecutor, batching and fan-out guards
app/adapters/embedder/ollama_embed.py: default timeouts and network error handling
tests/integration/test_qdrant.py: test_concurrent_search_is_thread_safe
System Architecture
6/10
Overall system structure
Clear hexagonal architecture with ports/adapters, factories and separation between analyzer/llm/vectorstore layers; configuration and DI are explicit, and test harnesses exercise the boundaries.
Evidence
app/domain/ports.py: defined ports (StaticAnalyzer, LLMProvider, Embedder, VectorStore)
app/adapters/llm/factory.py: build_router showing provider selection and router pattern
app/api/app.py: composition of adapters, classifiers and router into a FastAPI app
Security & Auth
5/10
Protecting data and access
Good attention to auth at API boundary, secrets handling and input-sanitisation tests; some security patterns (rate limits, token lifecycle, revocation) are not evident in the analyzed code.
Evidence
app/api/dependencies.py: require_api_key using HMAC-style checks
app/config.py: Settings model with SecretStr for secrets
tests/integration/test_sparse_live.py and tests/unit/test_lexical.py: tests to guard tsquery/metacharacters and tokenisation
Reliability & Observability
6/10
Stability and monitoring
Strong reliability and observability signals: budget tracking with thread-safety, CI gating for retrieval metrics, many unit and integration tests, and explicit graceful-shutdown patterns for executors and resources.
Evidence
app/observability/budget.py and tests/unit/test_budget.py: budget tracker, thread safety and enforcement
tests/unit/test_retrieval_gate.py: deterministic offline gate and CI gating artifacts
app/api/app.py: lifespan context and process-wide ThreadPoolExecutor used for controlled shutdown
Verified artifacts
Expertise
Python• Middle
Rust• Middle
Node.js• Middle
Industries
Artificial Intelligence• Middle
Blockchain & Crypto• Middle
Technologies
Rust• Middle
FastAPI
Tokio
Pydantic
Uvicorn
Persistent• mentioned only
Recommendations
- Implement or extend production schema migration history (versioned migrations) and include migration tests to strengthen data-layer evolution guarantees.
- Own end-to-end production hardening for RAG (operational runbooks, autoscaling knobs for vector-store clients and documented backoff/circuit-breaker policies).
- Drive retrieval and ranking experiments into measurable A/B tests and automated monitoring (traceable dashboards for nDCG/recall drift and alerting on degradation).
- Build hardened provider fallbacks (exponential backoff with jitter, circuit breakers) and formalize idempotency and retry behaviours at the API boundary.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium Generalist
Generalist developer (senior-level by code evidence) focused on building secure CLI and small web/PWA tooling with strong domain knowledge in cryptocurrency operations. The strongest proven skill is secure Bitcoin transaction construction and key handling demonstrated in btc-dust-collector/src/wallet.ts and src/tx.ts implementing BIP86 tweaks, PSBT building and rune-safe sweep/withdraw logic. Public code lacks large-scale frontend architecture artifacts, formal accessibility audits or documented, measurable frontend performance work.
UI Component Architecture
3/10
How interface parts are built
Reasonable component-level choices in small, hand-rolled UI code and CLI UX; not a component library or design-system level architecture.
Responsive & Cross-browser
3/10
Works on all screens and browsers
Basic PWA and cross-platform attention is present (service worker, manifest, IndexedDB) but no advanced responsive or RTL work nor container-query usage.
Performance Optimization
3/10
Speed of the interface
Some pragmatic performance and operational choices: network retries, simple rate-throttling and batching in hot paths; no formal measured optimizations or bundle analysis found.
Evidence
gorka2354/btc-dust-collector/src/api.ts: retry loop with exponential-like backoff for HTTP calls (getUtxos)
gorka2354/btc-dust-collector/src/core.ts: deliberate sleeps and throttling between network reads to avoid overloading endpoints
gorka2354/btc-dust-collector/src/core.ts: batched workflow (scan/collect/withdraw) and dry-run default to reduce accidental heavy work
Accessibility & Semantics
2/10
Usable for everyone
Minimal explicit accessibility evidence; UI handles notifications and input state but no ARIA, focus-management or CI a11y rules observed.
State Management & Data Flow
4/10
Managing data in the app
Clear, pragmatic async/state discipline in small apps and CLI flow: IndexedDB for persistence, robust connection/reconnect logic, defensive network calls and CLI option handling.
Evidence
gorka2354/ghost-mesh-chat/net.js: connection lifecycle, ping/pong, reconnect scheduling and graceful teardown (reinitPeer, retryRoomConnect)
gorka2354/ghost-mesh-chat/db.js: IndexedDB openDB, save/load/sync query patterns for local persistence
gorka2354/btc-dust-collector/src/cli.ts and src/core.ts: well-scoped CLI flag parsing and guarded workflows (dry-run default, confirmation prompts, fee safety guards)
UX & Visual Polish
4/10
Look and feel quality
Good pragmatic UX polish for small tools: dry-run defaults, confirmations, clear CLI help, chat UX (typewriter, avatars, notifications), and rune-safe transaction semantics in crypto tooling.
Evidence
gorka2354/btc-dust-collector/src/core.ts: dry-run default, human confirmation prompts, fee-warning and force flags
gorka2354/ghost-mesh-chat/ui.js: typewriterEffect, drag overlay, file chunk sending, and renderHistory
gorka2354/ghost-mesh-chat/profile.js: in-app avatar editor and UX for profile modal
Expertise
React• Junior
PWA & Web APIs• Junior
Industries
Blockchain & Crypto• Middle
Technologies
JavaScript
TypeScript• Junior
Node JS• Middle
Tailwind CSS
Next.js
Electron
WebRTC
React.js
Axios
PostCSS
Recommendations
- Develop secure CLI and small desktop apps that need correct low-level crypto operations and safe defaults (sweeps, PSBTs, dry-run confirmations).
- Implement or maintain PWA-style chat clients and small WebRTC-based real-time frontends with IndexedDB persistence and graceful reconnect logic.
- Build developer tools and QA harnesses for AI-assisted developer workflows where careful resource/budget limits and honest degraded modes are required.
- Collaborate on integrations that require careful UX around destructive actions - e.g., file-rewrite or irreversible command guards and audited confirmations.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: