Aleksandr Lebedev
Python Developer
SQL
Bash
Perl
Python
Rust
Data Wrangling & Cleaning: 6/10
Predictive Modeling: 5/10
Reproducibility & Notebook Hygiene: 5/10
Active 21 day ago
+7 (917) 5378373 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic senior-level data engineer who builds async, message-driven microservices and data pipelines. The strongest proven skill is designing and implementing async domain services, messaging adapters and DB-backed repositories, evidenced by services/space_service/src/infrastructure/db/repositories/document_repository.py and the async messaging adapter implementations such as common/message_queue/adapters/consumer.py. There is limited evidence of formal statistical rigor, product-level monitoring or data-versioning workflows in public code.
Technical skills
SQL
Bash
Perl
Python• Senior • 3y+
Rust• Junior
Python
Alembic
Boto3
Uvicorn
HTTPX
Asyncio
Flask
SQLAlchemy
FastAPI
Databases
Apache Kafka
Redis
NATS
pgvector
PostgreSQL
RabbitMQ
Weaviate
AI/ML
Airflow
LangChain
LLM
NLP
ResNet
OpenAI SDK
Streamlit
NumPy
LangGraph
RAG
DevOps
Git
GitLab CI
Rest API
AWS
Docker
Nginx
CI/CD
Kubernetes
QA
Postman
Pytest
Timeline
Python Backend Developer
•
Middle
OOO DS-Soft
•
Full-Time
Developed backend components for an AI-enabled document archive, including semantic search and RAG features. Designed and improved server-side architecture using clean architecture principles and implemented inter-service communication with RabbitMQ. Built asynchronous synchronization with external sources (SMB, NFS, Yandex.Disk) and optimized graph-based category queries with caching. Implemented test coverage monitoring and PostgreSQL RLS policies; also contributed to CI/CD and Kubernetes-based MLOps workflows.
Python
FastAPI
SQLAlchemy
PostgreSQL
Rust
Docker
LangGraph
Weaviate
RabbitMQ
Asyncio
RAG
CI/CD
Kubernetes
Python Backend Developer
•
Middle
State Research and Design Institute of Rare-Metal Industry (Giredmet)
•
Full-Time
Built backend and ML services for a CV system used to assess semiconductor crystal synthesis quality, owning the server architecture for the project. Designed a microservice architecture using Flask and integrated CV models for fast inference. Improved inference performance by introducing a Detectron2-based model and optimized database queries with indexing and partial denormalization, significantly reducing query time. Reduced memory usage during batch image processing, optimized Docker image build via multi-stage builds, and supported parallel archival processing with multiprocessing; performed code reviews and temporarily acted as team lead.
Pythonsince 2024
Flask
SQLAlchemysince 2024
PostgreSQLsince 2024
Dockersince 2024
Nginx
NumPy
Senior Data Scientist
Confidence: Medium Data Engineer
A pragmatic senior-level data engineer who builds async, message-driven microservices and data pipelines. The strongest proven skill is designing and implementing async domain services, messaging adapters and DB-backed repositories, evidenced by services/space_service/src/infrastructure/db/repositories/document_repository.py and the async messaging adapter implementations such as common/message_queue/adapters/consumer.py. There is limited evidence of formal statistical rigor, product-level monitoring or data-versioning workflows in public code.
Statistical Rigor
4/10
Correct use of statistics
Notebooks show correct train/validation/test splitting and metric computation, but formal statistical analysis, uncertainty quantification and multiple-comparison awareness are limited.
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Strong evidence of production-oriented data wrangling and cleaning: file readers, async text extraction, DB repositories and unit-of-work patterns, plus vectorizer integration and S3 file storage.
Evidence
Exploratory Analysis & Visualization
3/10
Exploring and visualizing data
Some exploratory notebooks and visual outputs exist but EDA is lightweight and lacks written interpretation or structured data storytelling.
Predictive Modeling
5/10
Building models that predict
Predictive modeling uses standard, correct tooling (Hugging Face Trainer, metric callbacks, inference pipeline) and includes an ONNX conversion script, but modeling is conventional with no novel algorithmic contributions.
Business Insight & Impact
3/10
Turning analysis into business value
Architecture is organized into domain use cases and event flows which enables product integration, but explicit business-metric framing, cost-of-error analysis and impact quantification are not present in the code artifacts.
Reproducibility & Notebook Hygiene
5/10
Clean, repeatable analysis
Reproducibility practices are present - tests, alembic migrations and scripts to export models are included and notebooks set random_state - but environment pinning, data versioning and CI pipeline details for full reproducibility are limited.
Expertise
Streaming• Middle
Analytics• Middle
Industries
Data & Analytics• Middle
Media & Entertainment• Middle
Technologies
Python• Senior • 3y+
PostgreSQL
SQLAlchemy
FastAPI
OpenAI SDK
NumPy
Asyncio
Streamlit
HTTPX
Boto3
Recommendations
- Build and own message-driven extraction and embedding pipelines (async consumers, vectorization, S3 storage, metadata persistence) to productionize document search and QA flows.
- Implement end-to-end ML model deployment pipelines including model versioning, DVC or data registry, automated evaluation and CI for reproducibility.
- Develop streaming consumers and publishers for near-real-time processing and observability, leveraging the existing async messaging adapters and adding metrics and alerting.
- Lead integration work that connects document extraction, vectorization and downstream search services while hardening secrets handling and environment configuration.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle AI/ML Engineer
Confidence: Medium LLM Engineer
A backend-focused engineer with solid experience building async microservices and LLM-integrated document pipelines at an upper-middle / junior-senior boundary (senior score 4.5). The strongest proven skill is engineering production-ready LLM-backed document workflows and services, supported by the document ingestion/vectorization stack and LLM generators (e.g., converter/summary/cards generator and HTTPVectorizer integrations). The work shows limited evidence of custom research-level model design or systematic efficiency benchmarking and would benefit from more experiment-tracking and low-level optimization artifacts.
Model Architecture & Training
4/10
How well models are designed and trained
Practical model training and export work is present (HF Trainer-based training, metrics, ONNX export) but there are no custom architectures or low-level training innovations.
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Solid data pipeline and feature engineering for text - readers, detectors, parsers, DB repositories and vectorizer integration are implemented.
Evidence
Sanch0pansa/sipi_archive/services/document_content_service/src/infrastructure/text_processing/document_text_extractor.py
Sanch0pansa/sipi_archive/services/document_content_service/src/infrastructure/text_processing/readers/pdf.py
Nochninog/hackathon_emotional_tone_definition/common/parser/adapters/parser.py
Experimentation & Evaluation
3/10
How results are measured and tested
Reproducible experiment flow is present (train/val/test split, metrics, Trainer usage) and there are unit tests for application logic, but there is limited evidence of systematic experiment tracking or A/B pipelines.
MLOps & Deployment
4/10
How models are shipped to production
MLOps and deployment concerns are addressed - async services, messaging (NATS / aio-pika), FastAPI entrypoints, S3 storage and ONNX export for inference are implemented.
Computational Efficiency
3/10
How efficiently computing resources are used
Some efficiency work exists (batch tokenization, ONNX export, dataloader tuning) but there is no systematic profiling, quantization, or GPU-memory/batching engineering with before/after measurements.
Research Depth & Innovation
2/10
Depth of research and new ideas
Evidence of applied ML and use of existing LLM/transformer tools is clear, but there is limited sign of novel research, custom layers, or reproduced SOTA implementations.
Expertise
RAG• Middle
LLM• Middle
Industries
Artificial Intelligence• Middle
Data & Analytics• Senior
Technologies
SQL
Redis
Weaviate
LangGraph
Rest API
LangChain
Airflow
NATS
pgvector
Flask
RabbitMQ
NLP
GitLab CI
CI/CD
Git
AWS
Docker
Kubernetes
Nginx
Apache Kafka
LLM
RAG
ResNet
Recommendations
- Lead development of LLM-powered document processing and RAG pipelines - ingestion, vectorization, retrieval, summarization and event-driven orchestration.
- Implement and productionize LLM generation services with retries/guardrails and observable metrics (NATS + FastAPI + vectorizer already present).
- Convert and optimize trained models for deployment (ONNX conversion, inference wrappers, batching) and add profiling/quantization runs with measured before/after results.
- Develop and expand automated test coverage and reproducible experiment tracking (W&B / MLflow) for model training and evaluation workflows.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Medium API Engineer
A backend-focused API engineer with meaningful experience designing and implementing layered services, asynchronous workers and database-backed repositories. The strongest proven skill is building Python microservices with message-driven workflows and ORM-backed persistence, supported by concrete artifacts such as services/document_content_service/entrypoints/mq.py and multiple Alembic migration revisions. The public code lacks explicit production-grade operational plumbing in some areas - e.g., secrets management, documented rate limiting and measurable performance tuning are not evident.
API Design
6/10
How well APIs are designed
APIs show deliberate layering, typed DTOs, explicit error mapping and dependency wiring across both FastAPI and a .NET Minimal API host; good controller/use-case separation is present, but there is limited evidence of an API versioning strategy or idempotency-key infrastructure.
Evidence
services/space_service/src/infrastructure/api/controllers/documents/create_document.py
services/document_content_service/entrypoints/rest.py
url-shortener/src/UrlShortener.Api/Endpoints/LinkEndpoints.cs
Data Layer & Database
6/10
Working with databases
Data layer uses ORM + migrations and a Unit-of-Work / repository pattern consistently, with multiple Alembic revisions and EF Core migration artifacts showing schema evolution; there are not many hand-tuned SQL snippets or explicit isolation-level handling visible.
Evidence
sipi_archive/migrations/versions/f3746b68693a_add_space_service_entities.py
services/space_service/src/infrastructure/db/repositories/document_repository.py
url-shortener/src/UrlShortener.Infrastructure/Database/Migrations/20260719093408_InitialCreate.cs
Scalability & Performance
5/10
Handling load and speed
Scalability primitives are present - async I/O, background MQ subscribers and message-based decoupling with NATS - and a HTTP vectorizer client is implemented; there is limited evidence of measured performance tuning, caching invalidation strategy or production rate limiting policies.
Evidence
shared/infrastructure/messaging/publisher.py
services/document_content_service/entrypoints/mq.py
shared/infrastructure/vectorizer/http_vectorizer.py
System Architecture
6/10
Overall system structure
The codebase follows Clean Architecture and DDD layered boundaries across multiple services with clear DI / composition-root patterns and dedicated entrypoints, demonstrating an intentional service decomposition; it is not presented as a large distributed system with advanced cross-service orchestration or SLAs.
Evidence
services/space_service/src/application/adapter/uow.py
shared/infrastructure/rest/base_controller.py
url-shortener/src/UrlShortener.Api/DependencyInjection/ApplicationRegistration.cs
Security & Auth
6/10
Protecting data and access
Authentication and token management are implemented (JWT token manager, bcrypt-based password handling), and input validation and domain error translation are present; however some secret handling is weak or hardcoded and revocation/refresh policies are not fully detailed in code.
Evidence
services/space_service/src/infrastructure/jwt/token_manager.py
services/space_service/src/infrastructure/db/orm/user.py
url-shortener/src/UrlShortener.Api/Validation/CreateLinkSchemaValidator.cs
Reliability & Observability
6/10
Stability and monitoring
The projects include structured exception handling, unit and architecture tests, and graceful shutdown signal handling in MQ entrypoints, plus retry decisions in LLM generator graphs; operational controls like circuit breakers, backoff configuration, and extensive metrics/alerting configuration are limited or not visible.
Evidence
services/cards_service/entrypoints/mq.py
shared/infrastructure/rest/exception_handler.py
services/summary_service/src/infrastructure/summary_generator/amvera/graph.py
Verified artifacts
Expertise
Python• Middle
Microservices & API Architecture• Middle
Messaging & Real-time• Middle
Databases & Vector Storage• Middle
Industries
Artificial Intelligence• Middle
Education• Middle
Technologies
Uvicorn
Alembic
Recommendations
- Develop and operate REST and async microservices that integrate LLM/vector search - design the API contracts, background MQ workers and UoW-based persistence layers.
- Implement message-driven features and real-time flows using NATS and async patterns, including graceful shutdown, retries with configured backoff and observability hooks.
- Build database-backed application logic that includes migration history, repository/UoW implementations and vector search integration (pgvector) for semantic features.
- Harden production readiness: add secrets management, configurable backoff/circuit-breakers, structured metrics and rate limiting.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: