Pavel Tishchenko

NLP Developer
SeniorBackend Developer
2years in AI/ML
6/10API Design
4repositories checked by code analysis

Overview

A backend-focused engineer comfortable across Python ML inference and Java/Spring backend systems at a senior, pragmatic level. The strongest proven skill is designing and testing production-grade APIs and domain services, evidenced by the FastAPI inference service with metrics/caching and the Java transactional services with idempotency and optimistic-locking tests. There is less public evidence for advanced operational patterns like distributed queues, circuit breakers, secret rotation workflows, or documented DB migration histories.
Phone

Timeline

Information Technologies, Mechanics and Optics University (ITMO University)
Bachelor's Degree · ml
2023–2027 Saint Petersburg, Russia
Saint Petersburg State University
Non-Degree Program · Summer School on Mathematics and Programming
2026 Saint Petersburg, Russia
ML/NLP Research Engineer · Middle
MTC · Full-Time
Dec 2025 to Oct 2026 10 Months Moscow Fully remote

Trained and fine-tuned Transformer models using PyTorch and Hugging Face. Implemented distributed training with DDP, FSDP and DeepSpeed (ZeRO-2/3). Improved macro-F1 from 0.68 to 0.84 and rare-class F1 by 18%. Built reproducible training and evaluation pipelines.

Python
PyTorch
Transformers
FSDP
DeepSpeed
MLFlow
ML/LLM Engineer · Middle
Alpha Bank · Full-Time
Mar 2024 to Feb 2026 1 Year 11 Months Moscow Fully remote

Fine-tuned open-source LLMs on domain-specific datasets using PyTorch and Hugging Face. Optimized production inference with vLLM, batching and quantization, reducing p95 latency from 2.3s to 1.1s and increasing throughput from 18 to 42 requests/sec. Automated offline regression evaluation and CI/CD quality checks.

Python
PyTorch
Transformers
vLLM
Docker
RAG
CI/CD
PostgreSQL
ML/LLM Engineer · Middle
T-Bank · Full-Time
Mar 2025 to Dec 2025 9 Months Moscow Fully remote

Developed DPO fine-tuning pipelines using Hugging Face TRL, improving LLM win rate from 51% to 68%. Built multi-step AI agent workflows with LangGraph, increasing task success rate from 73% to 89%. Implemented structured tool calling, error handling and evaluation pipelines for LLM-based banking automation.

Python
PyTorch
TRL
DPO
LangGraph
FastAPI
Qwen
Llama
ML Research Intern (Recommender Systems) · Junior
Yandex · Internship
May 2023 to Feb 2024 9 Months Moscow In office

Contributed to candidate retrieval work within a recommender systems team. Trained two-tower retrieval models, performed offline evaluation, and prepared experimental solutions for product validation. Improved Recall@100 and NDCG@10 versus baseline, and built a reproducible offline evaluation pipeline with metrics and segmented slices. Performed error analysis to identify cold start, popularity bias, and low candidate diversity, informing follow-up experiments and A/B preparation.

Python
PyTorch

Technical skills

Languages
5
Python
Java
C++
SQL
Bash
Python
3
FastAPI
Pydantic
Uvicorn
AI/ML
12
LLM
BERT
vLLM
RAG
NumPy
PyTorch
Scikit-learn
Transformers
XGBoost
CatBoost
Airflow
MLFlow
Databases
5
FAISS
pgvector
PostgreSQL
Redis
Apache Kafka
DevOps
6
CI/CD
Prometheus
Docker Compose
Git
Rest API
Docker
Other
8
Pytest
Spring Boot
Testcontainers
CMake
Deep Learning
MLOps
NLP
SLI/SLO/SLA
Senior Backend Developer Confidence: High API Engineer
A backend-focused engineer comfortable across Python ML inference and Java/Spring backend systems at a senior, pragmatic level. The strongest proven skill is designing and testing production-grade APIs and domain services, evidenced by the FastAPI inference service with metrics/caching and the Java transactional services with idempotency and optimistic-locking tests. There is less public evidence for advanced operational patterns like distributed queues, circuit breakers, secret rotation workflows, or documented DB migration histories.
API Design
6/10
How well APIs are designed
Well-structured HTTP APIs with clear error contracts, batch endpoints, content validation, and test coverage; idempotency handled in Java services.
Evidence
BiRefNet-Semantic-Cutout/app/api/routes.py: remove_background and remove_background_batch endpoints with headers and validation
BiRefNet-Semantic-Cutout/tests/test_api.py: end-to-end tests covering health, upload validation, and error cases
java_back_proj/src/main/java/ru/tischenko/vk/api/*Controller.java: REST controllers with Swagger annotations and pageable handling
Data Layer & Database
6/10
Working with databases
Deliberate database design with JPA entities, repositories, transactional boundaries, optimistic-lock handling and idempotency records; tests exercise native queries and repository behavior.
Evidence
java_back_proj/src/main/java/ru/tischenko/vk/domain/*.java: JPA entity definitions (e.g. TaskEntity, SprintEntity, IdempotencyRecordEntity)
java_back_proj/src/main/java/ru/tischenko/vk/repository/*Repository.java: Spring Data JPA repositories and custom queries
java_back_proj/src/test/java/ru/tischenko/vk/concurrency/OptimisticLockingIntegrationTest.java: integration test for optimistic locking behaviour
Scalability & Performance
4/10
Handling load and speed
Evidence of caching, metrics and pragmatic batching for ML workloads; limited advanced scaling patterns (no explicit rate-limiting, circuit breakers, or extensive async queueing).
Evidence
BiRefNet-Semantic-Cutout/requirements.txt and README.md: Redis and Prometheus included as operational components
BiRefNet-Semantic-Cutout/app/services/cache.py: cache key and ResultCache implementation
Loss-Landscape-Research-Pipeline-CIFAR-10-/src/surface.py: batched eval and DataLoader usage for performance
System Architecture
5/10
Overall system structure
Modular service decomposition and clear module boundaries across Python inference service, ML research pipeline, and Java domain services; thoughtful singletons and DI in FastAPI and Spring Boot layers.
Evidence
BiRefNet-Semantic-Cutout/app/main.py: application factory, lifespan, singletons attached to app.state
BiRefNet-Semantic-Cutout/app/services/segmentation.py: lazy-loaded thread-safe model singleton
java_back_proj/src/main/java/ru/tischenko/vk/service/ops/SprintOperationsService.java: domain service encapsulating transaction and business logic
Security & Auth
5/10
Protecting data and access
Conscious auth and input-safety practices - JWT-based security in Java, upload validation and size limits in FastAPI; secret lifecycle and token revocation less visible.
Evidence
java_back_proj/src/main/java/ru/tischenko/vk/config/SecurityConfig.java and JwtAuthFilter.java: JWT handling and authentication filter
BiRefNet-Semantic-Cutout/app/api/routes.py and app/core/exceptions.py: upload content-type check and payload size validation
BiRefNet-Semantic-Cutout/app/config.py and pydantic settings usage: centralized config
Reliability & Observability
5/10
Stability and monitoring
Solid observability and reliability basics - Prometheus metrics, structured logging and exception-to-status mapping; resilience patterns such as retries/backoff or circuit breakers are not apparent.
Evidence
BiRefNet-Semantic-Cutout/app/main.py: Prometheus metrics middleware and /metrics endpoint
java_back_proj/src/main/java/ru/tischenko/vk/config/RequestTracingFilter.java: MDC request tracing integration
BiRefNet-Semantic-Cutout/app/core/logging.py and app/core/metrics.py: logging configuration and metric definitions
Expertise
Backend AI & LLM· Middle
Java· Senior
Microservices & API Architecture· Senior
Industries
Artificial Intelligence· Middle
Technologies
Java· Senior
PostgreSQL
Redis
Docker Compose
Spring Boot
Prometheus
Testcontainers
Pydantic
Uvicorn
Recommendations
  • Develop ML inference microservices with robust observability - build on the FastAPI + lazy model-loading pattern and add structured metrics, retries and cache invalidation.
  • Implement transactional business flows and idempotent endpoints in Java where correctness matters - use the existing IdempotentOperationExecutor and expand integration tests for edge races.
  • Lead API design and endpoint contracts including pagination, error schemas, and backward compatibility for public REST surfaces.
  • Harden operational resilience by adding retries with jitter, circuit breakers, documented migration chains, and explicit load-testing for hotspot endpoints.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Embedded Engineer Confidence: Medium Generalist
A systems-focused C++ developer at a solid mid/senior application level who produces reliable, security-conscious user-space tooling. The strongest proven skill is implementing cryptographic file-transfer and transport logic with explicit artifacts in crypto.cpp (OpenSSL-based AES-GCM, RSA-OAEP, RSA-PSS) and tcp.cpp (non-blocking connect, timeouts, framed IO). There is little or no evidence of embedded/firmware, hardware drivers, HDL, low-level resource-constrained optimization, or on-device HIL/OTA workflows 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
Working with limited resources
Not evidenced in public code
Real-time & Timing
2/10
Precise timing control
Basic real-time/timing discipline for IO: non-blocking TCP connect with poll, socket-level IO timeouts and guarded read/write helpers reduce blocking/jitter risk but there is no deterministic WCET analysis or hard real-time design.
HDL & Circuit Logic
Designing digital circuits
Not evidenced in public code
Reliability & On-device Testing
4/10
Testing on real hardware
Solid reliability-focused practices for a user-space secure transfer tool: temporary file usage and cleanup, explicit zeroing of symmetric keys, replay-store commit checks, explicit ACK protocol and unit-test integration in CMake; no on-device HIL or OTA evidence.
Expertise
Low-level Development & Tooling· Middle
IoT & Connectivity Protocols· Junior
Technologies
C++· Senior
CMake
Recommendations
  • Develop secure network services or command-line tools in C++ that require careful streaming IO and cryptography (implementing protocols, streaming encryption, and robust ACK/retry logic).
  • Own design and implementation of cross-platform transport libraries and packet formats (socket edge cases, non-blocking connects, framed transfer, large-file streaming).
  • Implement cryptographic protocol components and test suites (OpenSSL-based primitives, signing/verification, key-wrapping, unit tests and CI integration).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle AI/ML Engineer Confidence: High Research
A senior-level, research-focused machine learning engineer who builds reproducible experimental pipelines and pragmatic CV inference services. The strongest proven skill is implementing loss-landscape analysis and related numerical methods, demonstrated by the implementations in src/surface.py, src/quadratic_fit.py and src/hessian_directions.py. There is limited public evidence of large-scale production deployment, distributed training, advanced efficiency engineering (quantization/profiling) or integrated experiment-tracking systems.
Model Architecture & Training
4/10
How well models are designed and trained
Solid, conventional model and training engineering: custom ResNet-like model, complete training loop with SGD and LR schedule, clear checkpointing. No novel architecture or large-scale distributed training evidence.
Data Pipeline & Feature Engineering
3/10
How data is prepared for models
Standard data-loading and reproducible synthetic loaders; correct normalization and deterministic seeding but no advanced augmentation/augmentation pipelines or sophisticated leakage handling.
Experimentation & Evaluation
5/10
How results are measured and tested
Good experiment & evaluation engineering: reproducible seeds, cached surface .npz outputs, metric computations, scripts to run full pipelines and produce LaTeX-ready reports. Experiment tracking is local/file-based; no external experiment-tracking system integration shown.
MLOps & Deployment
5/10
How models are shipped to production
Production-minded inference service: FastAPI application factory, dependency injection, lazy model loading, thread-safe singleton, Prometheus metrics and unit tests for endpoints and services. Deployment infra is implied (Docker Compose mentioned) but full CI/CD or large-scale deployment automation is not shown.
Computational Efficiency
3/10
How efficiently computing resources are used
Some efficiency-conscious choices (fp16 support, pin_memory, limiting max_batches, caching of computed surfaces) but no deep profiling, quantization, distributed/data-parallel training or low-level GPU optimization evidence.
Research Depth & Innovation
6/10
Depth of research and new ideas
Strong research depth for the specific problem: implements loss-landscape tooling (filter-wise direction normalization, Gram-Schmidt orthogonalization, finite-difference Hessian 2x2 projection, multiple quadratic fits) reproducing academic methods.
Expertise
Computer Vision & Image Analysis· Middle
MLOps & Model Lifecycle· Middle
Technologies
Deep Learning
MLOps
Python· Senior
SQL
Rest API
CatBoost
Airflow
pgvector· since 2024
FAISS· since 2024
vLLM· since 2024
MLFlow· since 2026
XGBoost
FastAPI· since 2024
Scikit-learn
NLP· since 2026
CI/CD· since 2024
Transformers
NumPy
Git
PyTorch
Docker· since 2026
Apache Kafka
LLM· since 2024
RAG· since 2024
BERT· since 2024
SLI/SLO/SLA
Recommendations
  • Lead implementation of reproducible research experiments and analysis tools for model geometry (use the loss-surface and quadratic-fit code as the core).
  • Develop production-grade computer vision inference APIs and lightweight orchestration for model serving and observability (build on the FastAPI + Prometheus + lazy-loading pattern).
  • Add experiment-tracking (W&B/MLflow), performance profiling and model optimization (quantization, benchmarking) to transform research pipelines into deployable artifacts.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:

Job preferences

Work permits
Russia
Salary
from $30k per year
Employment type
Full-Time
Locations
Saint Petersburg
Open to AI agents: they read this profile and start a dialog through Alionalion.io/@pavel-tishchenko/mcp
Alion · People, companies and AI agents in one graphalion.io/@pavel-tishchenko