Egor Pestov
AI Engineer
Python
SQL
Solidity
TypeScript
JavaScript
Node JS
Experimentation & Evaluation: 7/10
MLOps & Deployment: 6/10
Computational Efficiency: 6/10
Active 17 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
A senior-level LLM-engineer who builds production RAG/LLM orchestration and retrieval-backed audit systems, evidenced by app/agent/auditor.py and the app/eval harness. The strongest proven skill is system design for LLM-driven audits and reproducible evaluation, concretely shown in app/eval/harness.py and assets/eval/reports/detector-eval.json. There is little or no public work on custom model training, novel architectures, or low-level ML research in the provided human-authored code.
Technical skills
Python• Middle
SQL
Solidity
TypeScript• Junior
JavaScript
Node JS• Junior
Python
Alembic
FastAPI
Mypy
SQLAlchemy
Node JS
Electron
Axios
Databases
PostgreSQL
Redis
pgvector
Qdrant
AI/ML
Claude
Claude Code
Gemini
Hallucination
LLM
Pydantic AI
RAG
Frontend
Next.js
React.js
Tailwind CSS
PostCSS
DevOps
CI/CD
Docker
GitHub Actions
Netlify
Rest API
Web3
Arbitrum
Bitcoin
Slither
Solana
Ethereum
Mobile
Clean Architecture
QA
Playwright
Chips/EDA
PoC Library
Middle AI/ML Engineer
Confidence: High LLM Engineer
A senior-level LLM-engineer who builds production RAG/LLM orchestration and retrieval-backed audit systems, evidenced by app/agent/auditor.py and the app/eval harness. The strongest proven skill is system design for LLM-driven audits and reproducible evaluation, concretely shown in app/eval/harness.py and assets/eval/reports/detector-eval.json. There is little or no public work on custom model training, novel architectures, or low-level ML research in the provided human-authored code.
Model Architecture & Training
2/10
How well models are designed and trained
Little to no model-building or training code; engineering focuses on orchestration and adapters rather than custom architectures or training loops.
Evidence
app/adapters/llm/anthropic.py
app/adapters/llm/ollama.py
app/agent/synthesize.py
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Solid RAG data pipeline and chunking/ingest logic with batched embedding and vendored evaluation corpus; conventional feature engineering for retrieval tasks.
Evidence
app/rag/ingest.py
app/rag/chunk.py
app/eval/corpus.py
Experimentation & Evaluation
7/10
How results are measured and tested
Thoughtful, reproducible evaluation and honest metrics with CI gates and a cross-model grounding judge; clear emphasis on reproducibility and measured metrics.
Evidence
app/eval/harness.py
app/eval/metrics.py
assets/eval/reports/detector-eval.json
MLOps & Deployment
6/10
How models are shipped to production
Production-minded API and deployment patterns, adapter-backed vector stores, connection pooling and thread-safety for concurrent FastAPI usage.
Evidence
app/api/app.py
app/adapters/vectorstore/pgvector_store.py
app/adapters/vectorstore/qdrant_store.py
Computational Efficiency
6/10
How efficiently computing resources are used
Clear attention to efficiency - batched embeddings, connection-pool/bootstrap, thread-local clients and bounded executors to control concurrency and resource usage.
Evidence
app/agent/auditor.py
app/adapters/vectorstore/qdrant_store.py
app/adapters/vectorstore/pgvector_store.py
Research Depth & Innovation
3/10
Depth of research and new ideas
Demonstrates pragmatic engineering and domain-specific detectors; not focused on novel ML research or new algorithms in the public code.
Evidence
app/agent/auditor.py
app/eval/harness.py
Expertise
RAG• Middle
MLOps & Model Lifecycle• Middle
Technologies
Python• Middle
SQL
PostgreSQL
Redis
Rest API
Claude
Qdrant
Claude Code
SQLAlchemy
GitHub Actions
FastAPI
Netlify
Pydantic AI
CI/CD
Docker
Gemini
LLM
RAG
Mypy
Alembic
Hallucination
pgvector• mentioned only
RAG• mentioned only
Recommendations
- Design and implement RAG-powered audit/analysis services that require strict provenance, budget controls and concurrency safeguards.
- Productionize LLM-backed APIs and vector search backends (Postgres pgvector or Qdrant) including integration tests and CI gates for retrieval/eval.
- Build developer-facing tooling for reproducible evaluation (record/replay fixtures, deterministic eval CI gates) and retrieval quality monitoring.
- Lead integration projects that require LLM budgeting, graceful fallback, and resource-bounded parallel enrichment pipelines.
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
A senior backend engineer focused on API-driven, AI-assisted tooling and security automation. The strongest proven skill is building robust RAG/LLM pipelines and vector-store adapters (e.g., audit-copilot's LLM router, BudgetTracker, pgvector and Qdrant adapters with integration tests). Public code lacks evidence of multi-region production deployment patterns, formal API versioning or a secrets-vault integration for token lifecycle management.
API Design
5/10
How well APIs are designed
Sound API layering and DI (FastAPI app, pydantic schemas, explicit error handlers and tests) but no visible versioning strategy, idempotency-key scheme, or advanced API gateway/ratelimiting policy documented in code.
Evidence
audit-copilot/app/api/app.py: create_app and lifespan wiring of adapters (FastAPI)
audit-copilot/app/api/dependencies.py: require_api_key + dependency injection helpers
audit-copilot/tests/unit/test_api_routes.py: unit tests exercising audit/search/health routes
Data Layer & Database
7/10
Working with databases
Deliberate, production-oriented data-layer design: transactional replace/replace_source, idempotent schema bootstrap, connection pool handling and extension bootstrap for pgvector, and integration tests verifying correctness and concurrency.
Evidence
audit-copilot/app/adapters/vectorstore/pgvector_store.py: _init_schema, from_dsn_pool, replace_source transactional semantics and register_vector bootstrap
audit-copilot/tests/integration/test_pgvector.py: tests for replace_source removing orphans, pool concurrency, and fresh DB bootstrap
audit-copilot/app/adapters/vectorstore/qdrant_store.py: deterministic uuid5 id mapping and upsert-then-delete replace_source strategy
Scalability & Performance
6/10
Handling load and speed
Clear scalability choices - batched embeddings, bounded executor and fan-out guard, use of connection pools and thread-local clients - showing conscious handling of concurrency and cost vectors; lacks documented rate-limiting, multi-region replication or measured before/after optimization artifacts.
Evidence
audit-copilot/app/agent/auditor.py: batching of embed calls, _MAX_FINDINGS fan-out guard, bounded executor logic and graceful cancellation on budget/terminal errors
audit-copilot/app/adapters/vectorstore/pgvector_store.py: from_dsn_pool and ConnectionPool usage with configure callback
audit-copilot/app/adapters/vectorstore/qdrant_store.py: thread-local QdrantClient to avoid socket races under concurrent FastAPI threadpool
System Architecture
6/10
Overall system structure
Deliberate module boundaries and hexagonal-style ports/adapters, good separation of concerns and test harnesses; service decomposition is appropriate for a single application but not evidence of multi-service choreography or complex cross-service contracts.
Evidence
audit-copilot/app/domain/ports.py and adapters/*: clear ports/adapters (StaticAnalyzer, LLMProvider, Embedder, VectorStore)
audit-copilot/app/api/app.py: wiring of adapter factory functions and DI into the FastAPI app
audit-copilot/app/rag/* and app/agent/*: separated RAG, retrieval and synthesis layers
Security & Auth
6/10
Protecting data and access
Security-aware engineering: parameterized DB queries, require_api_key checks, SecretStr usage, and explicit handling of LLM error types and budget enforcement; not a full IAM/token lifecycle or secrets-vault integration visible in public code.
Evidence
audit-copilot/app/api/dependencies.py: require_api_key implementation and Request/Header handling
audit-copilot/app/adapters/vectorstore/pgvector_store.py: parameterized SQL (cur.executemany) preventing injection
audit-copilot/app/observability/budget.py and app/agent/auditor.py: BudgetTracker and explicit BudgetExceeded handling to prevent runaway LLM costs
Reliability & Observability
6/10
Stability and monitoring
Good reliability patterns: guarded per-finding error handling, cancellation on terminal errors, resource close() methods, unit and integration tests including concurrency and failure modes; limited evidence of distributed traces, correlation ids or production alerting rules in code.
Evidence
audit-copilot/app/agent/auditor.py: _guarded wrapper, _audit_parallel cancellation on BudgetExceeded/LLMError and order-preserving parallelization
audit-copilot/app/observability/budget.py: thread-safe BudgetTracker with tests
audit-copilot/app/adapters/vectorstore/qdrant_store.py and pgvector_store.py: explicit close() implementations and defensive bootstrap logic
Verified artifacts
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Microservices & API Architecture• Middle
Python• Middle
Industries
Blockchain & Crypto• Middle
Cybersecurity• Middle
Technologies
pgvector
Hunt• mentioned only
Persistent• mentioned only
Qdrant• mentioned only
Recommendations
- Lead development of RAG-powered audit services - design production-grade deployment (k8s, graceful shutdown, observability, SLI/SLO) for the FastAPI stack.
- Build and own scalable vector ingestion and retrieval pipelines - durable batching, backpressure, and index-rebuild strategies across pgvector and Qdrant.
- Implement secure API gateway features - request throttling, idempotency keys for expensive endpoints, and centralized secret management (Vault/External Secrets).
- Design cross-service contracts for a multi-service architecture - service meshes or API gateway patterns, and add distributed tracing/correlation ids to LLM calls and retrieval paths.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: High Generalist
A careful systems-focused developer at a senior-leaning level who produced security-minded CLI tooling in TypeScript for Bitcoin UTXO management. The strongest proven skill is cryptocurrency tooling and crypto-primitive correctness, demonstrated by the Wallet class (BIP86 taproot tweak in src/wallet.ts) and PSBT construction and signing in src/tx.ts. There is little to no frontend, visual, or automated-test evidence in the human-authored files, so UI, accessibility, and client-side state engineering are not demonstrated here.
UI Component Architecture
How interface parts are built
Not evidenced in public code
Responsive & Cross-browser
Works on all screens and browsers
Not evidenced in public code
Performance Optimization
Speed of the interface
Not evidenced in public code
Accessibility & Semantics
Usable for everyone
Not evidenced in public code
State Management & Data Flow
Managing data in the app
Not evidenced in public code
UX & Visual Polish
Look and feel quality
Not evidenced in public code
Industries
Blockchain & Crypto• Middle
Technologies
JavaScript
TypeScript• Junior
Node JS• Junior
Tailwind CSS
Next.js
Electron
React.js
Axios
PostCSS
Recommendations
- Develop security-critical CLI tooling and node-based utilities for Bitcoin/UTXO operations (sweeps, PSBT pipelines, fee-guarded broadcast flows).
- Build and maintain backend services or libraries that require correct cryptography and protocol knowledge (wallet derivation, taproot tweaks, PSBT helpers).
- Implement auditable, well-documented developer tools for crypto ops - e.g., instrumentation, deterministic dry-run modes, and gated broadcast pipelines.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: