Gennadii Pogulyai
Python
MLOps & Deployment: 5/10
Data Pipeline & Feature Engineering: 4/10
Active 18 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
A backend-focused LLM-inference engineer at a mid-to-senior level who builds asynchronous, production inference pipelines integrating LLMs and audio transcription. The strongest proven skill is building reliable async pipelines and integrations - demonstrated by the Mango client parsing, worker implementations, transactional outbox and comprehensive pytest coverage (e.g., app/clients/mango.py, app/services/*_worker.py and tests/*). There is no evidence of custom model training, experiment tracking, GPU/quantization work or original research-level ML architecture in public code.
Technical skills
Python• Senior • 3y+
Python
FastAPI
Asyncio
HTTPX
Pydantic
Databases
MinIO
Apache Kafka
PostgreSQL
AI/ML
OpenAI SDK
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
A backend-focused LLM-inference engineer at a mid-to-senior level who builds asynchronous, production inference pipelines integrating LLMs and audio transcription. The strongest proven skill is building reliable async pipelines and integrations - demonstrated by the Mango client parsing, worker implementations, transactional outbox and comprehensive pytest coverage (e.g., app/clients/mango.py, app/services/*_worker.py and tests/*). There is no evidence of custom model training, experiment tracking, GPU/quantization work or original research-level ML architecture in public code.
Model Architecture & Training
2/10
How well models are designed and trained
No model training or custom architectures; work focuses on inference, prompt design, and post-processing/normalization of LLM outputs.
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Robust ETL-style logic and validation for ingesting Mango CSV/JSON, parsing rows and mapping to domain models; workers and repository functions show pipeline-oriented design.
Experimentation & Evaluation
1/10
How results are measured and tested
Automated tests cover behavior and validation, but there is no evidence of experiment tracking, reproducible ML experiments, ablations or evaluation dashboards.
MLOps & Deployment
5/10
How models are shipped to production
Production-oriented async workers, transactional outbox pattern, Kafka helpers, retries and DLQ handling indicate solid inference-serving and pipeline operations engineering.
Evidence
PoGen-dev/daleon_phone_calls/app/common/kafka.py:kafka_producer / kafka_consumer / publish_json
PoGen-dev/daleon_phone_calls/app/common/repository.py:save_call_and_enqueue (transactional outbox pattern)
PoGen-dev/daleon_phone_calls/app/services/*_worker.py: transcriber_worker, quality_worker, telegram_worker (background worker patterns and retry handling)
Computational Efficiency
2/10
How efficiently computing resources are used
Some attention to efficient IO and concurrency (async, httpx transport, rate-limit backoff) but no GPU/quantization or measured optimization work.
Research Depth & Innovation
1/10
Depth of research and new ideas
No novel research, paper implementations or custom model layers; innovation is in system integration and business logic, not ML research.
Expertise
Audio & Speech Processing• Middle
LLM• Middle
Conversational AI & Chatbots• Middle
MLOps & Model Lifecycle• Middle
Industries
Artificial Intelligence• Middle
Financial Services• Middle
Technologies
PostgreSQL
FastAPI
Pydantic
Recommendations
- Develop production LLM-inference pipelines and microservices that handle audio ingestion, transcription, scoring and notifications (worker-based, Kafka/MinIO/Postgres stack).
- Implement and extend evaluation and observability for model-inference quality - add metrics, drift detection and experiment tracking (W&B / MLflow) around the scoring logic.
- Build resilient integration endpoints and operational tooling - retries, backoff, transactional outbox, idempotency and thorough unit tests for each component.
- Hardening for performance - measurable optimizations for audio I/O, batching, request concurrency and rate-limit handling for third-party APIs.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: Medium Data Engineer
A pragmatic data-engineer with solid experience building async ingestion and processing pipelines for streaming data. The strongest proven skill is robust ingestion and parsing of remote provider payloads - evidenced by the MangoClient parsing, CSV handling and comprehensive unit tests around retries and idempotency. There is limited or no public evidence of statistical analysis, predictive-modeling work, or domain-specific commercial metrics in the analyzed human-authored files.
Statistical Rigor
Correct use of statistics
Not evidenced in public code
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Robust data ingestion and parsing code with defensive handling for multiple result formats, CSV parsing, datetime/timezone normalization and stable id fallback logic; includes retry and rate-limit handling around remote API calls.
Exploratory Analysis & Visualization
Exploring and visualizing data
Not evidenced in public code
Predictive Modeling
Building models that predict
Not evidenced in public code
Business Insight & Impact
3/10
Turning analysis into business value
Business-oriented rules and messaging are present (DLQ, outbox, notification captions, risk labels) and tests assert business expectations, but there is limited explicit linking to business metrics or cost-of-error trade-offs in the human-authored code.
Reproducibility & Notebook Hygiene
5/10
Clean, repeatable analysis
Good reproducibility practices via extensive pytest coverage and monkeypatching to create deterministic tests for async components; tests exercise retry/backoff, idempotency and context managers which aid reproducibility and CI automation.
Expertise
Big Data• Middle
Streaming• Middle
Technologies
Python• Senior • 3y+
MinIO
OpenAI SDK
Apache Kafka
Asyncio
HTTPX
Recommendations
- Develop asynchronous ingestion and processing services that integrate HTTP APIs, object storage and Kafka (clients, retries, idempotency, DLQ).
- Implement and harden transactional outbox patterns, idempotent storage flows and end-to-end tests for streaming pipelines.
- Build resilient SDK clients for third-party services with strong parsing, rate-limit handling and deterministic unit tests.
- Own integration work to connect LLM-based transcription/QA clients into production pipelines while enforcing strict validation and evidence checks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Medium Distributed Systems
A backend engineer at a middle level who focuses on asynchronous, message-driven processing pipelines. The strongest proven skill is building and testing resilient distributed-worker patterns (retries, DLQ, transactional outbox and idempotency), demonstrated in tests such as test_mango_ingestion_retries_three_times_then_enqueues_dlq and test_mango_store_downloads_uploads_and_enqueues. Public artifacts do not expose full production service implementations, migration histories or operational observability setups, so system-level operational maturity and large-scale performance tuning are not evidenced.
API Design
3/10
How well APIs are designed
API-level design patterns (idempotency, transactional outbox, topic naming) are exercised in tests, but human-authored files contain mostly tests rather than API implementation or explicit versioning/error-contract code.
Data Layer & Database
4/10
Working with databases
Database concerns are tested: pool creation and codec configuration, transaction semantics (save + outbox) and idempotency checks are asserted in tests, showing attention to data integrity, though migration history and hand-tuned SQL are not present in the analyzed human files.
Scalability & Performance
4/10
Handling load and speed
Scalability and performance patterns are present in tests: kafka producer/consumer contexts, connection pool sizing, retry/ DLQ behavior and idempotent processing; explicit caching/invalidation or load-test artifacts are not in the human-authored files.
System Architecture
5/10
Overall system structure
System decomposition and resilience architecture are strongly implied by multiple worker types (mango, transcriber, quality, telegram) and transactional outbox semantics validated in tests - the tests assert component boundaries, idempotency and failure-recovery behaviors.
Evidence
PoGen-dev/daleon_phone_calls/tests/test_workers.py::test_mango_store_downloads_uploads_and_enqueues
PoGen-dev/daleon_phone_calls/tests/test_workers.py::test_transcriber_processes_audio_and_continues_idempotently
PoGen-dev/daleon_phone_calls/tests/test_clients_infra.py::test_retry_republishes_then_moves_to_dead_letter
Security & Auth
2/10
Protecting data and access
Some surface security checks are covered in tests (proxy configuration, token presence), but comprehensive auth/token lifecycle, input validation policies, dependency audit or secrets handling are not visible in the human-authored test files.
Reliability & Observability
5/10
Stability and monitoring
Reliability practices are well tested: retry-to-dead-letter logic, graceful closing (aclose), pool close, transactional rollback cleanup and commit-after semantics for consumers; structured observability (metrics/alerts) is not present in the human-authored files but test coverage for failure modes is strong.
Evidence
Expertise
Messaging & Real-time• Middle
Microservices & API Architecture• Middle
Python• Middle
Backend AI & LLM• Middle
System Architecture• Middle
Databases & Vector Storage• Middle
Industries
Financial Services• Middle
Recommendations
- Develop and own small-to-medium message-driven services (ingest/transcribe/analyze pipelines) that require idempotency, DLQ and transactional outbox guarantees.
- Implement and extend reliable worker patterns and integration tests for async systems (kafka/rabbitmq) where retry/backoff, commit semantics and resource cleanup are critical.
- Work on payments/webhook-style services that require atomic save+publish semantics and idempotency protection.
- Contribute to Python backend codebases that integrate external APIs (storage, LLMs, messaging) with robust testing and failure-mode coverage.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: