Egor Serov
Node JS
TypeScript
Python
Active 9 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
A practitioner focused on building LLM-driven agent systems and simple RAG pipelines at a middle-engineer level. The strongest proven skill is multi-agent orchestration and integration, evidenced by the StateGraph-based supervisor and agent implementations in agent.ipynb and app/agents.py. There is minimal evidence of model training, evaluation pipelines, production deployment infrastructure, or test coverage in the public code.
Technical skills
Node JS• Junior
TypeScript• Junior
Python• Middle
Node JS
Axios
Python
FastAPI
Pydantic
Uvicorn
Databases
Supabase
PostgreSQL
FAISS
AI/ML
LangChain
huggingface_hub
RAG
LLM
OpenAI SDK
Pandas
Frontend
React.js
Vite
Tailwind CSS
Recharts
ESLint
Prettier
PostCSS
autoprefixer
React Router
Middle AI/ML Engineer
Confidence: Medium LLM Engineer
A practitioner focused on building LLM-driven agent systems and simple RAG pipelines at a middle-engineer level. The strongest proven skill is multi-agent orchestration and integration, evidenced by the StateGraph-based supervisor and agent implementations in agent.ipynb and app/agents.py. There is minimal evidence of model training, evaluation pipelines, production deployment infrastructure, or test coverage in the public code.
Model Architecture & Training
1/10
How well models are designed and trained
No custom model architectures or training loops; only API-backed LLM usage and model instantiation.
Data Pipeline & Feature Engineering
2/10
How data is prepared for models
Basic document ingestion and chunking for RAG - uses PyMuPDF, text-splitter and FAISS but no sophisticated augmentation or leakage controls.
Experimentation & Evaluation
1/10
How results are measured and tested
Interactive notebooks demonstrate functional QA loops, but there is no experiment tracking, validation pipeline, or quantitative evaluation artifacts.
MLOps & Deployment
3/10
How models are shipped to production
Practical engineering of agent orchestration and runnable graphs with StateGraph and compile/run entrypoints, but limited production deployment tooling.
Computational Efficiency
2/10
How efficiently computing resources are used
Uses vector store (FAISS) and remote HF embeddings; shows awareness of efficient retrieval but no measured optimization, batching, or quantization work.
Research Depth & Innovation
3/10
Depth of research and new ideas
Design of a multi-agent supervisor/coder/files/research pattern shows thoughtful application design, but there are no novel algorithms or reproduced paper results.
Expertise
AI Agents & Agentic Workflows• Middle
RAG• Middle
LLM• Middle
Technologies
Python• Middle
LangChain
FAISS
OpenAI SDK
huggingface_hub
Pandas
LLM
RAG
Recommendations
- Develop production-ready agent services with clear separation between orchestration and execution - add service wrappers, unit tests, and CI/CD pipelines.
- Add evaluation and observability: instrument RAG answers with evaluation scripts, logging, and basic metrics to quantify retrieval+generation quality.
- Harden secrets and configs: move getpass and env handling to secure runtime config, and add safe key management guidance for notebooks.
- Implement lightweight performance measurements - timing of embed/lookup, index sizes, and memory profiling to drive practical optimizations.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Backend Developer
Confidence: Medium API Engineer
A pragmatic backend/API engineer at a solid middle level who independently implements async services, DB integration and observability. The strongest proven skill is backend API and data-integration design, evidenced by the Supabase connection-pooling and optimized async query logic in app/database/supabase_client.py. Public code does not show advanced distributed-system design, migration histories, or production-grade secret-management and measured performance testing.
API Design
5/10
How well APIs are designed
API design is pragmatic and consistent (clear endpoints, Pydantic models, dependency-based access control and caching) but lacks explicit versioning strategy, documented error contract beyond raising HTTPException, and no visible idempotency keys or advanced pagination patterns.
Evidence
KopatychDisko/Dashboard/backend/app/api/analytics.py: multiple REST endpoints using FastAPI, Query/Path args and cached decorator with key_params
KopatychDisko/Dashboard/backend/app/api/auth.py: TelegramAuthRequest Pydantic model and consistent HTTPException usage
KopatychDisko/Dashboard/backend/app/main.py: routers registered with clear prefixes (/api/analytics, /api/auth, /api/bots)
Data Layer & Database
6/10
Working with databases
Data layer shows deliberate design: an async connection-pool wrapper, careful query shaping and use of .in_ and .not_.like to reduce data volume; no migration history or explicit transaction handling surfaced.
Evidence
KopatychDisko/Dashboard/backend/app/database/supabase_client.py: ConnectionPool with asyncio.Lock, _get_connection_pool and SupabaseClient.initialize
KopatychDisko/Dashboard/backend/app/database/supabase_client.py: get_dashboard_metrics and _get_chart_data with tuned queries (.in_/.not_.like) and memory-side grouping to avoid N+1
Scalability & Performance
6/10
Handling load and speed
Evidence of scalability and performance work: async patterns, parallel queries via asyncio.gather, a response cache decorator and frontend service-worker caching; rate limiting and request timeout middleware exist. Missing are measured optimizations, load-test artifacts, or sophisticated cache invalidation rules.
Evidence
KopatychDisko/Dashboard/backend/app/database/supabase_client.py: parallelized data fetches using asyncio.gather and optimized query selection
KopatychDisko/Dashboard/backend/app/api/analytics.py: uses cached decorator and calls db_client.get_dashboard_metrics and get_funnel_stats concurrently
KopatychDisko/Dashboard/frontend/public/sw.js: networkFirstWithCache and cacheFirst strategies, plus API cache TTL
System Architecture
5/10
Overall system structure
Clear module boundaries (api, core, middleware, database) and considered middleware stack show sensible service decomposition and operational concerns; architecture is single-service monolith-style rather than multi-service distributed design.
Security & Auth
4/10
Protecting data and access
Authentication and input validation are present (Pydantic models, Telegram signature verification call), and there are rate-limiting and timeout middlewares; however some security practices need tightening (sensitive values logged, cookies configured insecurely for production).
Reliability & Observability
5/10
Stability and monitoring
Good reliability and observability basics: structured logging, health endpoint with DB check, explicit shutdown cleanup of the connection pool, and exception handlers. Missing are retry/backoff strategies, circuit breakers, centralized metrics exports or documented alerting rules.
Expertise
Microservices & API Architecture• Junior
Python• Junior
Databases & Vector Storage• Junior
Industries
Sales & Marketing• Junior
Technologies
PostgreSQL
Supabase
FastAPI
Pydantic
Uvicorn
Recommendations
- Use to build and extend FastAPI-based REST services that integrate SaaS databases (Supabase/Postgres) with attention to async patterns and caching.
- Implement analytics and dashboard endpoints where careful query shaping, concurrency and result-aggregation are needed.
- Harden auth and production ops - add secure cookie configuration, secrets management, structured sensitive-data logging rules and retry/backoff logic for DB calls.
- Develop telemetry and SLO-based alerting (Prometheus/OTel) and run targeted load tests to validate the async pooling and caching strategies.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium App Engineer
A practical frontend/app engineer at a middle experience level who builds SPA data flows and tooling-aware builds. The strongest proven skill is app-level data and network handling - evidenced by a centralized axios client with response interceptors, robust error handling and retry/backoff logic (KopatychDisko/Dashboard/frontend/src/utils/api.js and src/utils/errorHandler.js). The public code shows deliberate performance and UX work (service worker and Vite optimizations) but lacks comprehensive component architecture, accessibility care and test coverage.
UI Component Architecture
2/10
How interface parts are built
Limited component architecture evidence - the codebase contains utility hooks and global styles but few self-authored React components or a component design system.
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive behavior is implemented via media queries and Tailwind configuration; basic responsive breakpoints and fluid layout rules are present but there's no evidence of advanced techniques (container queries, RTL readiness, feature detection).
Performance Optimization
5/10
Speed of the interface
Concrete performance work is present - a detailed service worker with cache-first/network-first strategies and a Vite build config with manualChunks and esbuild tuning for smaller bundles and caching.
Accessibility & Semantics
2/10
Usable for everyone
Minimal accessibility evidence; some good basics (img alt attributes) exist but there are harmful patterns (removing focus states for the Telegram widget), no ARIA on custom widgets and no a11y tooling found in CI configs.
State Management & Data Flow
4/10
Managing data in the app
Solid app-level state and server-state discipline: centralized axios client, response interceptors, consolidated error handling with retry/backoff, and a focused data-loading hook. Missing request cancellation, optimistic updates with rollback, or state machines for complex flows.
UX & Visual Polish
4/10
Look and feel quality
Good UX and perceived-performance touches: loading spinner styles, deliberate micro-delays for smoothness in hooks, and offline/error UX via service worker; visual polish is present but accessibility trade-offs reduce its strength.
Verified artifacts
Expertise
React• Junior
Frontend Architecture & Build Tools• Junior
PWA & Web APIs• Junior
Web Performance & Optimization• Junior
Industries
Sales & Marketing• Junior
Technologies
TypeScript• Junior
Node JS• Junior
Tailwind CSS
React.js
Vite
Axios
PostCSS
ESLint
Prettier
Recharts
React Router
autoprefixer
Recommendations
- Use this developer to implement and integrate SPA data flows and API surfaces (login, analytics, paginated dialogs) with centralized error handling and retries.
- Assign them to performance and build optimization tasks - chunking strategies, service worker caching, and esbuild/Vite tuning.
- Have them implement feature-level state management (cancellation, optimistic updates, request deduplication) and add unit/e2e tests around critical flows.
- Pair them with an a11y specialist to fix focus/keyboard issues and add accessibility testing (axe/lighthouse) before production rollout.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: