Vladislav Moroz
Python Developer
Python
SQL
Bash
API Design: 5/10
Data Layer & Database: 5/10
Scalability & Performance: 4/10
Active 13 days ago
+7 (960) 8599091
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Career analytics
Roles
Overview
Backend engineer (senior-level) focused on asynchronous Python APIs and reliable inter-service messaging with a strength in practical API and transactional design. The strongest proven skill is building resilient payment workflow primitives - idempotent create, outbox pattern and a publisher/consumer setup as seen in src/payments/router.py and src/rabbit/*.py. The public code does not show advanced observability, formal load-testing artifacts or enterprise-grade secrets and token lifecycle management.
Technical skills
Python• Senior • 3y+
SQL• Middle • 3y+
Bash
Python
SQLAlchemy
Alembic
Aiohttp
Pydantic
Asyncio• 3y+
FastAPI• 3y+
Databases
PostgreSQL• 3y+
RabbitMQ• 3y+
Redis• 3y+
Apache Kafka
ClickHouse
pgvector
DevOps
Git
Docker Compose
Docker• 3y+
Rest API• 3y+
CI/CD
GitLab CI
gRPC
Kubernetes
AI/ML
PEFT
PyTorch
Computer Vision• 3y+
YOLO• 3y+
Fine-tuning
LLM
LoRA
NLP
ONNX
QLoRA
RAG
Transformers
Embeddings
LangChain
LangGraph
ChatGPT
Claude
QA
Pytest• 3y+
Swagger• 3y+
Timeline
Python Backend and NLP Engineer
•
Middle
Data Integral
•
Full-Time
Developed and supported AI backend services for intelligent document processing, semantic search, and business process automation. Built RAG pipelines by combining embeddings, vector search, and LLM generation, and implemented a full data preparation flow from OCR-related text cleanup to chunking. Integrated HuggingFace and OpenAI models behind a unified REST API, and optimized inference using ONNX Runtime, batching, and caching to improve throughput and p95 latency in production.
Python
FastAPI
RAGsince 2024
LLM
LoRAsince 2024
QLoRAsince 2024
ONNXsince 2024
PostgreSQL
Redis
Apache Kafkasince 2024
ClickHousesince 2024
Docker
GitLab CIsince 2024
CI/CD
Transformerssince 2024
NLP
Fine-tuning
Rest API
Swagger
SQL
Python Backend / NLP Engineer
•
Middle
Data Integral LLC
•
Full-Time
Built Python microservices for document intelligence, semantic search, and business-process automation using NLP and LLMs. Designed RAG pipelines for OCR-to-answer flows and implemented hybrid vector search using Qdrant and PostgreSQL with metadata filtering. Integrated HuggingFace and OpenAI models via a unified REST API, and optimized inference with ONNX Runtime, batching, async processing, and caching for production throughput.
Python
FastAPI
Apache Kafka
ClickHouse
PostgreSQL
Redis
ONNX
Transformers
RAG
LoRA
QLoRA
Docker
GitLab CI
Bash
Rest API
Swagger
Asyncio
Python Backend Developer
•
Middle
Neftegaz Analitika
•
Full-Time
Built a backend platform for aggregating production data and processing media (audio, video, images) using microservices. Improved reporting performance by optimizing SQL queries, indexes, and execution plans, and implemented caching to reduce database load and speed up repeated requests. Integrated ML models into production pipelines (including asynchronous audio transcription and object detection with YOLO) and developed resilient ETL workflows with background processing and reliability mechanisms.
Pythonsince 2023
FastAPIsince 2023
RabbitMQsince 2023
PostgreSQLsince 2023
Redissince 2023
Dockersince 2023
Pytestsince 2023
YOLO
Computer Visionsince 2023
Rest APIsince 2023
Swaggersince 2023
SQLsince 2023
Python Backend Developer
•
Middle
Neftegaz-Analitika LLC
•
Full-Time
Developed and maintained a backend platform for aggregating production data and processing multimedia (audio, video, images) using microservices and REST APIs. Improved reporting performance by optimizing SQL queries and database indexing, then implemented Redis caching to accelerate repeated reads. Integrated ML models into ETL pipelines (Whisper for speech-to-text and YOLO for object detection) and built resilient asynchronous processing with RabbitMQ workers and dead-letter queues.
Python
FastAPI
Redis
PostgreSQL
RabbitMQ
SQL
Computer Vision
Pytest
Docker
Asynciosince 2023
Rest API
Swagger
Russian State University of Oil and Gas
Bachelor's Degree •
Standardization and certification (Faculty of Mechanical Engineering)
Career analytics
Verified work history and code activity in one view - open-source impact, work rhythm, trust signals and a forecast of when this candidate is likely to move.
1
Years active
9
Commits analyzed
Work rhythm
UTC+3
12 AM6 AM12 PM6 PM12 AM
Code activity
Low
Peak
Last activity
Aug 2026 · 0 Days
Active days (90d)
2
Typical work hours
9 AM - 5 PM
Collaboration Quality
Senior Backend Developer
Confidence: Medium API Engineer
Backend engineer (senior-level) focused on asynchronous Python APIs and reliable inter-service messaging with a strength in practical API and transactional design. The strongest proven skill is building resilient payment workflow primitives - idempotent create, outbox pattern and a publisher/consumer setup as seen in src/payments/router.py and src/rabbit/*.py. The public code does not show advanced observability, formal load-testing artifacts or enterprise-grade secrets and token lifecycle management.
API Design
5/10
How well APIs are designed
Solid REST and API boundary design with idempotency handling, API-key auth, rate limiting and thorough input validation demonstrated across endpoints and tests.
Evidence
A1lure/Payments/src/payments/router.py: create_payment implements Idempotency-Key handling and API-key dependency
A1lure/Background-Cleaner/main.py: verify_api_key, limiter usage and content-type / threshold validation in /api/remove-background
A1lure/Background-Cleaner/tests/test_api.py: tests covering error contracts and input validation
Data Layer & Database
5/10
Working with databases
Clear data model and migration history plus transactional handling and explicit handling of IntegrityError for idempotency; uses async SQLAlchemy patterns and Alembic.
Evidence
A1lure/Payments/alembic/versions/1_create_payment_outbox.py: Alembic migration creating payments and outbox tables with indexes
A1lure/Payments/src/payments/models.py: SQLAlchemy declarative models with types, constraints and idempotency unique key
A1lure/Payments/src/payments/router.py: transaction flow using session.flush, commit/rollback and re-query on IntegrityError
Scalability & Performance
4/10
Handling load and speed
Thoughtful runtime and throughput choices - constrained ML inference with a semaphore and run_in_threadpool and an outbox publisher - but no evidence of measured load testing, advanced pooling or caching strategies.
Evidence
A1lure/Background-Cleaner/main.py: inference_semaphore and run_in_threadpool to limit concurrent model runs and avoid event-loop blocking
A1lure/Payments/src/rabbit/publisher.py: publish_outbox_messages loop with sequential publishing and error backoff sleep
A1lure/Payments/src/rabbit/consumer.py: consumer with DLQ binding and asynchronous processing
System Architecture
4/10
Overall system structure
Reasoned service decomposition into API, outbox publisher and consumer with startup/shutdown hooks and alembic migrations; architecture is pragmatic for small-to-medium scale services.
Evidence
Security & Auth
4/10
Protecting data and access
Good boundary checks and simple auth - API key checks, file signature validation, size and pixel limits and rate limiting are in place; no advanced auth/token lifecycle or dependency audit evidence.
Reliability & Observability
4/10
Stability and monitoring
Basic reliability and observability practices present - structured startup/shutdown, logging.exception, retry loop in publisher and graceful HTTP session teardown - but lacks metrics, structured correlation ids and advanced SRE artifacts.
Evidence
A1lure/Background-Cleaner/main.py: lifespan startup for model loading and logging.exception on processing errors
A1lure/Payments/src/rabbit/publisher.py: retry-on-exception loop with sleep and logging of failures
A1lure/Payments/src/rabbit/consumer.py: startup to create HTTP session and on_shutdown to close it
Expertise
Python• Middle
Microservices & API Architecture• Middle
Messaging & Real-time• Middle
Databases & Vector Storage• Middle
Backend AI & LLM• Middle
Industries
Financial Services• Middle
Technologies
Python• Senior • 3y+
PostgreSQL• 3y+
Docker Compose
SQLAlchemy
RabbitMQ• 3y+
FastAPI• 3y+
Asyncio• 3y+
Pydantic
Aiohttp
Alembic
Recommendations
- Develop payment-facing microservices that require idempotency, transactional outbox and RabbitMQ-based delivery.
- Build async ML inference endpoints where constrained concurrency and safe threadpool offloading are required.
- Implement small-to-medium scale API services with clear validation, rate limiting and deterministic error contracts.
- Integrate DB migrations and CI-driven deployment for services that need predictable schema evolution and consumer/producer coordination.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: