Kirill Savelev

Backend • Senior • 34 years • Moscow, Russia • UTC+03:00 • Work permits: Russia • Available in 2 weeks
Project Manager
9+ years exp
SQL
JavaScript
Node JS
TypeScript
Python
API Design: 6/10
Data Layer & Database: 6/10
Scalability & Performance: 6/10
Active 1 day ago
+7 (905) 5026669
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles

Overview

A backend-focused engineer working at a solid senior level who builds API-driven LLM and integration services. The strongest proven skill is building LLM-backed evaluation pipelines and orchestration, evidenced by judge.py system prompts, Temporal workflows (temporal/workflows.py) and judge-related activities integrating embedding retrieval and Kafka publishing. There is limited public evidence of production-grade secrets management, API versioning, and full-scale system observability (tracing/alerts) in code shown.

Technical skills

SQL
JavaScript
Node JS
TypeScript
Python• Senior • 3y+
Node JS
Dotenv
Puppeteer
Python
aiogram
Aiohttp
Beautiful Soup
SQLAlchemy
Asyncio
Requests
Uvicorn
Alembic
python-telegram-bot• 9y+
FastAPI
HTTPX
Databases
pgvector
Redis
SQLite
Apache Kafka
ClickHouse
MS SQL• 9y+
PostgreSQL
AI/ML
ChatGPT
Claude Code
CUDA Toolkit
Cursor
Embeddings
LLM
Model Context Protocol
Perplexity
PyTorch
RunPod
Whisper
YandexGPT
Anthropic SDK
Transformers
Claude• 3y+
NLP• 3y+
RAG
DevOps
Caddy
Docker
Docker Compose
Git
Grafana
Nginx
Debian
Containers
Observability
Rest API
Ubuntu
Frontend
Next.js
React Query
React Router
React.js
Tailwind CSS
Vite
PostCSS
QA
Playwright
Postman• 3y+

Timeline

Technical Founder • Executive
Skladnoystol.ru • Full-Time
Nov 2017 to Present 8 Years 9 Months Moscow In office
Developed internal CRM and automation tools, including a database-driven system for managing media access and operational data. Built a Telegram-bot based CRM workflow and automated business calculations to reduce manual effort and errors. Created e-commerce and marketing-related backend services integrating analytics and LLM-assisted content generation.
python-telegram-bot
Claude
MS SQL
Project Manager / Call Center Team Lead • Lead
D&D Group • Full-Time
Nov 2013 to Oct 2017 3 Years 11 Months Moscow In office
Managed call-center operations and coordinated project activities for the team. Organized workflows and supported delivery of operational goals based on the company’s processes. Focused on improving day-to-day execution and team management during 2013–2017.
Senior Backend Developer Confidence: Medium API Engineer
A backend-focused engineer working at a solid senior level who builds API-driven LLM and integration services. The strongest proven skill is building LLM-backed evaluation pipelines and orchestration, evidenced by judge.py system prompts, Temporal workflows (temporal/workflows.py) and judge-related activities integrating embedding retrieval and Kafka publishing. There is limited public evidence of production-grade secrets management, API versioning, and full-scale system observability (tracing/alerts) in code shown.
API Design
6/10
How well APIs are designed
Solid API design with async endpoints, streaming SSE, file upload handling, task-based async workflows and pagination in external client; lacks explicit versioning and advanced idempotency patterns but shows pragmatic error handling and input checks.
Evidence
legaljudge/backend/api/evaluate.py: starts Temporal workflows and returns task_id for async processing
legaljudge/backend/api/chat.py: StreamingResponse SSE implementation and session/file upload endpoints
bot-skorozvon/skorozvon_client.py: paginated REST fetching (fetch_all_projects) with page params
Data Layer & Database
6/10
Working with databases
Multiple datastores used with parameterized queries and pgvector usage; shows embedding insertion and ClickHouse logging, but no long migration history or explicit transaction/isolation tuning.
Evidence
legaljudge/backend/data_pipeline/seed_sample_data.py: inserts embeddings into pgvector using parameterized executemany with ON CONFLICT DO NOTHING
legaljudge/backend/db/clickhouse.py: ClickHouse client wrapper and log_evaluation function
bot-skorozvon/db.py: aiosqlite schema creation and parameterized CRUD queries
Scalability & Performance
6/10
Handling load and speed
Evidence of scalability thinking - async I/O, connection pools, Temporal for orchestration, Kafka for events and retries - but caching and invalidation strategies are basic and rate-limiting/benchmark artifacts are absent.
Evidence
legaljudge/backend/temporal/workflows.py: RetryPolicy and activity timeouts for workflow reliability
legaljudge/backend/kafka/producer.py: aiokafka producer wrapper for publishing events
legaljudge/backend/services/cache.py: redis.asyncio usage for caching and result storage
System Architecture
5/10
Overall system structure
Modular service layout (api, services, db, temporal, data_pipeline) and clear orchestration boundaries using Temporal; architecture is pragmatic rather than highly novel or cross-project scale-proven.
Evidence
legaljudge/backend/main.py: application composition wiring APIRouters, DB and external services
legaljudge/backend/temporal/workflows.py: separation of parse/upload/judge/log activities
legaljudge/backend/temporal/activities.py: activity implementations integrating storage, embedding and Kafka
Security & Auth
4/10
Protecting data and access
Shows basic boundary validation, file size checks and safe parameterized DB usage, plus token refresh handling for external API clients; lacks explicit API auth flows, granular authz, dependency audit and secrets lifecycle controls in code shown.
Evidence
legaljudge/backend/api/evaluate.py: file size checks and upload validation
bot-skorozvon/skorozvon_client.py: OAuth token refresh and credential handling logic
bot-skorozvon/db.py: use of parameterized SQL queries to avoid injection
Reliability & Observability
5/10
Stability and monitoring
Good observability basics - consistent logging, unit tests for core logic, and retry/timeouts in workflows; missing structured tracing/correlation ids and formal alerting/metering artifacts in code provided.
Evidence
legaljudge/backend/tests/: unit tests for parser, retriever and judge logic (tests/test_* files)
legaljudge/backend/temporal/workflows.py: explicit retry and timeout configuration
legaljudge/backend/kafka/producer.py & temporal/activities.py: log + publish activity integrating logging and event emission
Expertise
Backend AI & LLM• Senior
Databases & Vector Storage• Senior
Messaging & Real-time• Senior
Microservices & API Architecture• Senior
Python• Senior
Technologies
PostgreSQL
Redis
ClickHouse
pgvector
SQLite
Apache Kafka
Uvicorn
Requests
Aiohttp
Recommendations
  • Develop LLM-backed backend services and orchestration (Temporal workflows) for legal/knowledge-domain products - work on judge.py, temporal activities and evaluate endpoints.
  • Build integration-heavy automation (Telegram/HTTP API integrations) and real-time notification pipelines using Kafka and async HTTP clients - suitable to expand bot-skorozvon components.
  • Expand database & vector expertise by adding explicit schema migrations, migration_chain history and production-grade pgvector tuning and ClickHouse ingestion pipelines.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
savvie-portfolio legaljudge bot-skorozvon
Middle AI/ML Engineer Confidence: High LLM Engineer
A pragmatic engineer who builds LLM-backed production services and integrations and is at an early senior / strong-middle level. The strongest proven skill is architecting LLM-driven evaluation and RAG pipelines with Temporal orchestration and streaming inference, evidenced by temporal/workflows.py, temporal/activities.py and api/chat.py. Public code lacks custom model training, experiment tracking, GPU/latency optimization and deeper research-level artifacts.
Model Architecture & Training
2/10
How well models are designed and trained
Mostly applied use of prebuilt embedding models and inference APIs; no custom model architectures, training loops, or hyperparameter experimentation present.
Evidence
legaljudge/backend/services/embedder.py: SentenceTransformer usage and encode/encode_batch methods
legaljudge/backend/data_pipeline/seed_sample_data.py: calls Embedder.encode_batch for embedding generation
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Concrete, production-oriented data pipelines for document parsing, chunking and embedding with fallback parsing and text-splitting; clear handling of chunk storage and pgvector insertion.
Evidence
legaljudge/backend/data_pipeline/chunk_and_embed.py: chunking and upsert pipeline using langchain_text_splitters and asyncpg
legaljudge/backend/services/parser.py: parse_pdf with pdfplumber primary and pymupdf fallback
legaljudge/backend/data_pipeline/seed_sample_data.py: preparing and inserting pgvector rows
Experimentation & Evaluation
4/10
How results are measured and tested
Has unit tests targeting parsing and judge logic and uses structured evaluation flows, but lacks experiment tracking, hyperparameter sweeps or reproducible ML experiment tooling.
Evidence
legaljudge/backend/tests/test_judge.py: tests for judge parsing and behavior
legaljudge/backend/tests/test_parser.py: tests for parser fallback logic
legaljudge/backend/tests/test_retriever.py: tests for retrieval and context formatting
MLOps & Deployment
5/10
How models are shipped to production
Real deployment & orchestration engineering evident - Temporal workflows, worker activities, Kafka publish, ClickHouse logging, MinIO upload activity and async service wiring; solid pragmatic MLOps integration though not enterprise-grade observability shown.
Evidence
legaljudge/backend/temporal/workflows.py: Temporal workflows with retry policy and timeouts
legaljudge/backend/temporal/activities.py: activities for parsing, embedding, judging and log/publish
legaljudge/backend/kafka/producer.py: AIOKafkaProducer usage and publish_eval_completed
Computational Efficiency
3/10
How efficiently computing resources are used
Some efficiency awareness - batching of embeddings and async patterns, streaming responses and retry policies - but no measured GPU/latency profiling, quantization, or low-level optimization.
Evidence
legaljudge/backend/services/embedder.py and seed_sample_data.py: embedding batch_size usage
legaljudge/backend/api/chat.py: streaming SSE using anthropic.AsyncAnthropic and incremental token streaming
legaljudge/backend/temporal/workflows.py: RetryPolicy and timeouts indicating operational performance considerations
Research Depth & Innovation
2/10
Depth of research and new ideas
Applied prompt engineering and structured evaluation prompts are present, but there is no evidence of novel research, custom layers, paper reimplementations, or reproducible SOTA experiments.
Evidence
legaljudge/backend/services/judge.py: extensive system prompts and response parsing for evaluation
legaljudge/backend/api/evaluate.py: orchestration for evaluation workflows (document/case/dialogue) using Temporal
Expertise
LLM• Middle
RAG• Middle
MLOps & Model Lifecycle• Middle
Industries
Artificial Intelligence• Middle
Commerce• Middle
Professional Services• Middle
Technologies
SQL
Cursor
Rest API
Claude• 3y+
ChatGPT
Claude Code
Model Context Protocol
SQLAlchemy
CUDA Toolkit
Caddy
Debian
Embeddings
Beautiful Soup
NLP• 3y+
Anthropic SDK
MS SQL• 9y+
YandexGPT
Transformers
Git
PyTorch
Docker
Ubuntu
Nginx
Grafana
LLM
RAG
Perplexity
Whisper
HTTPX
aiogram
python-telegram-bot• 9y+
RunPod
Recommendations
  • Develop robust experiment tracking (MLflow or W&B) and add reproducible eval scripts for any tuning runs
  • Add performance monitoring and latency/throughput benchmarks for embedding and inference paths (before/after numbers)
  • Replace hard-coded credentials and secrets with env/config-driven secret management and scan code for exposed tokens
  • Extract prompt templates and instrument prompt/versioning to enable A/B on prompts and guardrails
  • Add simple GPU profiling or inference batching experiments if moving beyond embeddings to heavier models
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
legaljudge skl-site eye-tracker
Middle DevOps Engineer Confidence: Medium Generalist
A practical generalist-level engineer comfortable building Python services, integrations and small data/automation tools. The strongest proven skill is backend application development with tests and DB migrations - evidenced by the FastAPI app, Alembic migration and pytest-based tests for the mobile-backed API. The public code lacks CI/CD pipelines, production orchestration (Kubernetes), and structured infra-as-code practices.
CI/CD Pipelines
Automated build and deploy
Not evidenced in public code
Infrastructure as Code
2/10
Managing servers with code
Basic container/infrastructure artifacts (Dockerfile, docker-compose) are present but there is no evidence of production-grade IaC practices like remote state, locking, versioned modules or infra tests.
Evidence
bot-skorozvon/Dockerfile: simple single-stage image for Python app
bot-skorozvon/docker-compose.yml: service definitions, volumes and restart policy
Containerization & Orchestration
2/10
Working with containers
Containerization is used (Docker + docker-compose) but there is no orchestration (Kubernetes manifests), no tuned resource requests/limits, no readiness/liveness probes, and no multi-stage image optimizations or non-root user setup.
Evidence
bot-skorozvon/Dockerfile: FROM python:3.12-slim, installs requirements, CMD python main.py
bot-skorozvon/docker-compose.yml: service definitions for bot and caddy
Observability & Monitoring
2/10
Watching system health
Basic structured logging is used across services and tests exist for the backend, but there are no SLOs, burn-rate rules, alertmanager/alert routing, dashboards-as-code or advanced observability constructs.
Evidence
bot-skorozvon/main.py: logging.basicConfig usage and logger imports
bot-skorozvon/telegram_sender.py: logger usage and warning/error messages
bot-skorozvon/max_sender.py: logger.warning and logger.error usage
Reliability & Incident Response
1/10
Keeping systems up
Some resilience-minded code exists (token caching/refresh and try/fallbacks around network/send operations), but there are no deploy strategies, runbooks, postmortems, chaos experiments, PDBs, or graceful shutdown orchestrations beyond basic try/except patterns.
Evidence
bot-skorozvon/skorozvon_client.py: token caching and refresh logic with fallback to password grant
bot-skorozvon/telegram_sender.py: try/fallback when sending audio then falling back to text message
Cloud & Cost Optimization
1/10
Smart use of the cloud
There is domain-level cost analysis and forecasting logic in ad analysis scripts which show understanding of advertising spend, but no cloud autoscaling, spot/eviction strategies, workload identity, or IAM infrastructure controls are present.
Evidence
skl-site/ad_dashboard.py: cost per visit and 30-day forecast calculations
skl-site/ppc_agent/ppc_agent.py: logic around spend, recommendations and saving snapshots
Expertise
Observability & Monitoring• Middle
Industries
Commerce• Middle
Technologies
Containers
Observability
Python• Senior • 3y+
Docker Compose
FastAPI
Asyncio
Alembic
Recommendations
  • Develop Telegram and messenger integrations and their backend APIs - extend the existing bot modules and async HTTP client code.
  • Build and operate PPC tooling and analytics workflows - expand the ppc_agent and ad_dashboard tooling with automated reporting and safer credential handling.
  • Harden deployment practices - add CI pipelines, container image hardening (non-root, multistage), and simple infra-as-code with remote state for repeatable deployments.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
bot-skorozvon skl-site memento