Alexander Fedorako
ML Engineer
C++
Python
SQL
C
+375 (29) 1519193
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic systems-focused generalist at a senior level who delivers low-level C/C++ systems such as a custom dynamic memory allocator and multithreaded CPU/CUDA image-processing benchmarks. The strongest proven skill is low-level allocator and memory-management design, supported by allocator/src/core/{tcache.c,size_classes.c}, platform page_heap code and the allocator README with tests. There is little or no evidence of embedded MCU firmware, RTOS/task tuning, register-level drivers, or hardware boundary timing/WCET analysis in public code.
Technical skills
C++• Middle • 3y+
Python• Senior • 3y+
SQL• Senior • 3y+
C• Middle • 3y+
Databases
Firestore
PostgreSQL
MongoDB
Apache Kafka
RabbitMQ
Redis
ElasticSearch
MinIO
AI/ML
Keras
Langfuse
LangGraph
MediaPipe
NumPy
OpenCV
TensorFlow
LangChain
LLM
Model Context Protocol
DeepEval
Google ADK
RAG
Vertex AI
DevOps
Amazon EC2
Docker
Google Cloud Run
Rest API
Docker Compose
AWS
AWS Lambda
GCP
Kibana
Kubernetes
CI/CD
QA
Pytest
Timeline
AI Engineer
•
Middle
IBA Group
•
Full-Time
Built a distributed corporate web platform for creating AI agents using the MCP protocol. Implemented multi-agent orchestration with dynamic tool configuration and developed an agent workflow execution engine. Added observability for tracing and tool call analysis, and implemented safe Python execution with sandboxing, plus Kubernetes deployment and Elasticsearch/Kibana-based log/metrics visualization.
Python
LangChain
FastAPI
Pydantic
SQLAlchemy
MinIO
Kubernetes
ElasticSearch
Kibana
Poetry
Model Context Protocol
Python Developer
•
Middle
IBA Group
•
Full-Time
Developed software for a corporate AI agents platform and supported related internal tooling. Worked on integration and automation of enterprise workflows, contributing to back-end components. Collaborated with the team via reviews to maintain code quality and delivery reliability.
Python
БГУИР (бывш. МРТИ)
Bachelor's Degree •
Информатика и технологии программирования
AI Engineer
•
Middle
Innowise Group
•
Full-Time
Implemented a corporate AI agent system for customer support with RAG capabilities. Designed multi-agent dialog orchestration and built production-ready vector search by integrating Vertex AI. Created a RAG knowledge lifecycle manager service, added event-driven communication via Pub/Sub, and developed an evaluation pipeline with custom agent quality metrics.
Python
Google ADK
GCP
Vertex AI
Pydantic
DeepEval
Pytest
RAG
Python Backend Developer
•
Middle
Innowise Group
•
Full-Time
Developed and maintained backend microservices using FastAPI and a modular microservice architecture. Implemented event-driven flows with RabbitMQ and added Redis token handling logic. Built data-access layers with SQLAlchemy and Alembic migrations, and integrated AWS services for storage, notifications, and event-driven workflows.
Python
FastAPI
Django
SQLAlchemysince 2025
Pydantic
RabbitMQ
Redis
Poetrysince 2025
Pytest
LangChain
AWS
AWS Lambda
Alembic
Python Developer
•
Middle
EmotionIQ
•
Full-Time
Developed backend services for a platform that analyzes participant behavior and emotional signals. Built event-driven streaming with Kafka and implemented an LLM layer using LangChain to generate meeting summaries and reports. Added containerization support and test coverage using pytest, while supporting system architecture discussions across distributed components.
Pythonsince 2024
FastAPIsince 2024
Djangosince 2024
Pydanticsince 2024
Apache Kafka
LangChainsince 2024
Pytestsince 2024
Senior AI/ML Engineer
Confidence: High LLM Engineer
A mid-level LLM-focused engineer who builds production-ready LLM-backed APIs and simple computer-vision prototypes. The strongest proven skill is engineering LLM inference services with caching, health checks and thorough endpoint tests, evidenced by Sentiment-Text-Analyzer/src/services.py, src/cache.py and tests/test_app.py. There is little or no evidence of custom model training, research-level experiments, distributed GPU optimization, or full MLOps (experiment tracking, quantized inference) in the public code.
Model Architecture & Training
1/10
How well models are designed and trained
No custom model architecture or training pipelines; LLM usage is integration-only via LangChain/Ollama.
Evidence
Sentiment-Text-Analyzer/src/services.py: SentimentAnalysisService uses OllamaLLM and a ChatPromptTemplate; no custom architectures or training code
Data Pipeline & Feature Engineering
1/10
How data is prepared for models
Minimal data pipeline or feature engineering; only simple dataset loading in notebooks and caching logic for API responses.
Evidence
Computer-Vision-Masterclass/02_face_recognition.ipynb: get_image_data implementation that loads and converts dataset images
Sentiment-Text-Analyzer/src/main.py: generate_cache_key and usage of RedisCache for result caching
Experimentation & Evaluation
2/10
How results are measured and tested
Reasonable testing and error handling for the service layer and API endpoints, but no ML experiment tracking or evaluation pipelines.
Evidence
Sentiment-Text-Analyzer/tests/test_app.py: comprehensive endpoint tests covering cache hit/miss, timeouts, and error cases
Sentiment-Text-Analyzer/src/services.py: explicit timeout handling and ValidationError->SentimentAnalysisError mapping
MLOps & Deployment
3/10
How models are shipped to production
Production-oriented service patterns: FastAPI lifespan management, Redis cache abstraction, health checks and pydantic-based settings; light deployment hints in docs.
Evidence
Sentiment-Text-Analyzer/src/main.py: lifespan startup/shutdown that initializes Redis client and SentimentAnalysisService; health_check endpoint
Sentiment-Text-Analyzer/src/cache.py: RedisCache abstraction with health_check and clear_cache methods
Sentiment-Text-Analyzer/src/config.py: Settings using pydantic_settings for Ollama and Redis configuration
Computational Efficiency
1/10
How efficiently computing resources are used
Basic async and timeout handling present, but no evidence of GPU, batching, quantization, or other computational efficiency engineering.
Evidence
Sentiment-Text-Analyzer/src/services.py: asyncio.wait_for used to bound LLM calls with request_timeout
Sentiment-Text-Analyzer/src/main.py: async middleware measuring processing_time
Research Depth & Innovation
1/10
Depth of research and new ideas
No research-depth artifacts - notebooks and standard library/API usage only, no paper implementations or novel algorithms.
Evidence
Computer-Vision-Masterclass/01_face_detection.ipynb: examples using OpenCV cascades and dlib detectors
Computer-Vision-Masterclass/02_face_recognition.ipynb: LBPHFaceRecognizer demo
Expertise
LLM• Middle
Technologies
LangGraph
Rest API
LangChain
GCP
Firestore
Docker Compose
OpenCV
Model Context Protocol
RabbitMQ
Kibana
MinIO
Vertex AI
DeepEval
Langfuse
TensorFlow
NumPy
Keras
Docker
Kubernetes
ElasticSearch
Apache Kafka
LLM
RAG
MediaPipe
Google ADK
Google Cloud Run
AWS Lambda
Amazon EC2
Docker• mentioned only
Ollama• mentioned only
Rest API• mentioned only
Sentiment Analysis• mentioned only
Recommendations
- Develop production LLM-backed microservices with robust monitoring - build more RAG-style flows, streaming responses and retry/backoff for remote LLMs.
- Expand MLOps coverage: add experiment tracking (W&B/MLflow), CI for model/behavioral regressions, and structured model evaluation pipelines.
- Harden operational security and config handling: validate credentials handling, avoid exposing unset credentials in connection URLs, and add secrets management.
- Prototype end-to-end CV model training or fine-tuning (notebooks -> scripts) with reproducible pipelines if moving beyond demos
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: Medium API Engineer
A backend API engineer at a solid mid-to-senior level who demonstrates disciplined layering (domain, services, infrastructure) and async integration with multiple stores. The strongest proven skill is backend data and service design - concretely evidenced by src/infrastructure/database/repositories/model_repository.py (hand-written SQL and filtered pagination) and src/application/services/vehicle_service.py (business logic, preloading to avoid N+1, pubsub notifications). There is limited public evidence of production-grade operations work such as migration history, load testing, distributed tracing configuration, or explicit retry/backoff policies.
API Design
6/10
How well APIs are designed
API design shows versioning and consistent DTO usage, filtering/pagination via filter objects, and domain-level error types; idempotency keys and formal API contract/versioning policy are not evident.
Evidence
Auto-Dealer-System-Frontend: src/services/api/endpoints.js
Auto-Dealer-System-Backend: src/application/services/vehicle_service.py (returns DTOs, publishes data-change events)
Auto-Dealer-System-Backend: src/application/services/order_service.py (uses OrderFilter and status transitions)
Data Layer & Database
7/10
Working with databases
Data layer shows hand-written SQL, use of asyncpg, stored-function based filtering with separate count query, careful type mapping and parse_uuid helpers; there is clear repository/UoW separation but no visible migration history or explicit schema evolution chain in the analyzed human files.
Evidence
Auto-Dealer-System-Backend: src/infrastructure/database/repositories/model_repository.py (raw SQL, get_models_filtered, fetchval count)
Auto-Dealer-System-Backend: src/application/services/order_service.py (handles asyncpg exceptions and business-level DB errors)
Auto-Dealer-System-Backend: src/infrastructure/mongodb/repositories/log_repository.py (NoSQL aggregation pipelines and mapping)
Scalability & Performance
6/10
Handling load and speed
Scalability practices include cache namespace/versioning, pub/sub for data-change notifications, and explicit N+1 elimination by preloading media for many models; advanced load-testing, measured optimizations, or cluster-level strategies are not visible in the human-authored files.
Evidence
Auto-Dealer-System-Backend: src/application/services/user_service.py (CacheManager usage with namespace versioning)
Auto-Dealer-System-Backend: src/application/services/vehicle_service.py (preloads model media map to avoid N+1 queries)
Auto-Dealer-System-Frontend: src/services/api/interceptors.js (client-side token refresh queue to avoid redundant refresh calls)
System Architecture
6/10
Overall system structure
Code follows a layered/domain-driven structure (domain, application services, infrastructure repositories, abstractions) and uses pubsub to decouple flows; it's a clear API/service decomposition but not an observable multi-service, cross-process orchestration with hardened inter-service contracts in the analyzed files.
Evidence
Auto-Dealer-System-Backend: src/application/services/vehicle_service.py (service layer calling UoW + pubsub + mappers)
Auto-Dealer-System-Backend: src/application/services/user_service.py (service layer with cache invalidation and pubsub)
Auto-Dealer-System-Backend: src/infrastructure/database/repositories/model_repository.py (infrastructure repository implementing domain repo interface)
Security & Auth
6/10
Protecting data and access
Authentication and RBAC checks are implemented across services and client-side interceptors include a robust refresh flow; lower-level token lifecycle (revocation lists) and extensive input-sanitization gates or dependency audit evidence are limited in the human-authored code examined.
Evidence
Auto-Dealer-System-Frontend: src/services/api/interceptors.js (refresh token flow with queuing and logout-on-failure)
Auto-Dealer-System-Backend: src/application/services/user_service.py (uses IPasswordHandler.hash_password and enforces role checks)
Auto-Dealer-System-Backend: src/application/services/order_service.py (role checks when updating/deleting orders)
Reliability & Observability
5/10
Stability and monitoring
Logging and analytics are present (structured logger usage and MongoDB audit analytics pipelines), and services raise domain errors consistently; system-level reliability patterns like retries with backoff, circuit breakers, global timeouts, or documented graceful shutdown logic are not prominent in the analyzed human-authored files.
Evidence
Auto-Dealer-System-Backend: src/logger.py (logger setup referenced across services)
Auto-Dealer-System-Backend: src/infrastructure/mongodb/repositories/log_repository.py (aggregation pipelines for stats and anomaly detection)
Auto-Dealer-System-Backend: src/application/services/vehicle_service.py (uses logger warnings and info for operational traces)
Expertise
Python• Middle
Microservices & API Architecture• Middle
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Industries
Commerce• Senior
Technologies
MongoDB
PostgreSQL
Redis
AWS
Docker• mentioned only
MinIO• mentioned only
Nginx• mentioned only
Recommendations
- Use the developer to build and extend REST/HTTP JSON APIs and domain services (service layer + UoW + repository implementations).
- Assign database-focused work: implement hand-tuned SQL queries, stored-proc integration, and repository optimizations for Postgres performance.
- Engage them to implement caching, cache-invalidation and pub/sub data-change pipelines (Redis + pubsub) to reduce load and eliminate N+1 patterns.
- Have them own authentication and RBAC flows, token lifecycle improvements and S3 media upload integrations.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Embedded Engineer
Confidence: Medium Generalist
A pragmatic systems-focused generalist at a senior level who delivers low-level C/C++ systems such as a custom dynamic memory allocator and multithreaded CPU/CUDA image-processing benchmarks. The strongest proven skill is low-level allocator and memory-management design, supported by allocator/src/core/{tcache.c,size_classes.c}, platform page_heap code and the allocator README with tests. There is little or no evidence of embedded MCU firmware, RTOS/task tuning, register-level drivers, or hardware boundary timing/WCET analysis in public code.
Embedded & Firmware
Low-level device code
Not evidenced in public code
Hardware-Software Interface
Connecting code to hardware
Not evidenced in public code
Resource Constraints
6/10
Working with limited resources
Clear low-level resource-management work: custom dynamic allocator design (size classes, per-thread caches), large-object OS mappings and platform page-heap abstraction.
Real-time & Timing
2/10
Precise timing control
Has multithreaded CPU implementations and GPU (CUDA) variants plus benchmarking, but no evidence of RTOS timing analysis, WCET, or hard real-time design.
HDL & Circuit Logic
Designing digital circuits
Not evidenced in public code
Reliability & On-device Testing
5/10
Testing on real hardware
Reasonable on-device / unit test infrastructure and sanitizers; explicit test binaries and sanitizer/asan/tsan/ubsan targets in build system.
Verified artifacts
Expertise
Low-level Development & Tooling• Middle
Recommendations
- Lead development of performance-sensitive native libraries - memory allocators, custom allocators, and runtime memory tools.
- Build and optimize high-throughput image processing or compute kernels (CPU multithreaded + CUDA) with rigorous benchmarking and profiling.
- Develop low-level tooling and testing infrastructure - sanitizer/ASan/TSan pipelines, stress and HIL-like automated tests for system components.
- Integrate allocator and low-level components into production-grade CI with fuzzing, memory-stress tests and cross-platform portability work.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: