Sergey Sysoev

AI/ML • Middle • Moscow, Russia • UTC+03:00 • Work permits: Russia, Georgia, Spain, Serbia, United Arab Emirates, United States, Germany, Poland, Norway, Portugal, Italy • English: B2 • Available in 2 weeks

ML Engineer

4+ years exp

C++

Python

Data Pipeline & Feature Engineering: 4/10

Experimentation & Evaluation: 4/10

Invite to interview

Download CVCV

Overview

Technical skills

Projects

Timeline

Roles

Overview

A pragmatic embedded/firmware engineer at a middle level who builds ESP32-based device firmware and companion Python tools. The strongest proven skill is implementing device configuration and control stacks (AsyncWebServer/Preferences + FreeRTOS task pattern) as evidenced by InitializeSettingsServer.cpp and WiFiConfigManager.cpp. The work lacks register-level drivers, formal real-time analysis, watchdog/power management and on-device HIL/OTA testing evidence.

Phone

Technical skills

Languages

C++

Python

AI/ML

LLM

OpenCV

PyTorch

Transformers

Whisper

Ollama

vLLM

llama.cpp

ONNX

TensorRT

NumPy

Pandas

Scikit-learn

Numba

SciPy

Other

PostgreSQL

FFmpeg

Asyncio

Docker

Git

STL

PyTorch C++

CMake

FreeRTOS

Ultralytics

Jupyter Notebook

AI Agents

IoT

RAG

Computer Vision

Speech Recognition

Projects

agent dashboard

Jun 2026 to Present 4 Months

Веду проект - аналог Jira с агентами. Используем опенсорсные и проприетарные harness для интеграции с dashboards + локализованная среда для исполнения задач агентами(изолированный докер контейнер в котором агент не может сильно навредить в случае допущения ошибки). Функционала сильно больше, но в двух словах так.

Python

FastAPI

LangGraph

Docker Compose

Ruff

pre-commit

vLLM

Ollama

Pipeline data orchestration

Jun 2025 to Present 1 Year 4 Months

A streaming pipeline framework for pre-annotating object-detection datasets.

Point it at a stream of images, wire up a graph of nodes — dedup, detect, embed, select, save — and get a pre-labelled dataset ready for human review.

Python

YOLO

OpenCV

Timeline

Computer Vision / Applied ML Engineer • Middle

SberBank • Full-Time

Apr 2023 to Present 3 Years 6 Months Moscow In office

Built and adapted transformer-based models for production use with strict latency and resource constraints. Developed OCR and speech/ASR pipelines end-to-end, including model adaptation, post-processing, validation, and quality control, and deployed optimized edge inference on ARM/Linux. Improved inference performance via ONNX/TensorRT optimization and integrated ML inference stacks (Ollama, llama.cpp, vLLM) into streaming and agent-focused tooling for production systems.

Python

PyTorch

Transformers

Whisper

ONNX

TensorRT

OpenCV

Docker

Asyncio

PostgreSQL

Git

C++

FFmpeg

Ollama

llama.cpp

vLLM

LLM

National Research Nuclear University

Master's Degree • информационные системы и технологии

2023–2026 Moscow, Russia

National Research Nuclear University

Bachelor's Degree • Computer science

2019–2023 Moscow, Russia

Middle AI/ML Engineer Confidence: High Research

A developer focused on classical computer vision research and small tooling, operating at a solid junior-to-middle level. The strongest proven skill is designing and running reproducible evaluation experiments for blur-detection metrics, evidenced by the notebook that extracts multiple handcrafted features, benchmarks implementations, and trains a KNeighbors classifier (research.ipynb) together with evaluation helpers (validate_methods.py and time_checker.py). There is limited evidence of production ML engineering, serving, distributed training, or custom model architectures in public code.

Model Architecture & Training

2/10

How well models are designed and trained

Basic model usage and evaluation - uses scikit-learn KNN and standard preprocessing but no custom architectures, loss design, or training pipelines.

Evidence

Bleaff/BlurDetectionImplementation/research.ipynb: KNeighborsClassifier fit/predict and error_rates sweep Bleaff/BlurDetectionImplementation/validate_methods.py: is_blurred wrappers around metrics used as inputs to classifiers

Data Pipeline & Feature Engineering

4/10

How data is prepared for models

Clear data preparation and feature engineering for classical CV metrics - reads image sets, extracts multiple handcrafted metrics, standardizes features and splits train/test.

Evidence

Bleaff/BlurDetectionImplementation/research.ipynb: dataset construction, StandardScaler and scaled_features Bleaff/BlurDetectionImplementation/validate_methods.py: test_all_methods building per-method metric lists and writing CSV results

Experimentation & Evaluation

4/10

How results are measured and tested

Solid experiment and evaluation work for a small research project - classification reports, confusion matrices, plotting and runtime benchmarking are present.

Evidence

Bleaff/BlurDetectionImplementation/research.ipynb: classification_report, confusion_matrix, plotting of distributions and threshold analysis Bleaff/BlurDetectionImplementation/time_checker.py: time_it decorator and timing harness for comparative benchmarking

MLOps & Deployment

1/10

How models are shipped to production

Minimal MLOps or deployment artifacts - small CLI application and basic runtime guards but no serving, versioning, or model lifecycle automation.

Evidence

Bleaff/polygon_editor/edit_polygons.py: main() CLI, cv2.VideoCapture handling and save/load of polygon JSON

Computational Efficiency

3/10

How efficiently computing resources are used

Some attention to computational efficiency - uses numba and explicit timing to measure hotspots, but no measured before/after GPU/CPU profiling or production optimizations.

Evidence

Bleaff/BlurDetectionImplementation/time_checker.py: @nb.njit frequnecy_based_numba and timing collection Bleaff/BlurDetectionImplementation/research.ipynb: measured timings for different metric implementations

Research Depth & Innovation

3/10

Depth of research and new ideas

Research-oriented work at a modest depth - thoughtful comparison of classical metrics and an effective feature-combination idea, but no novel algorithmic contribution or paper-grade reproduction.

Evidence

Bleaff/BlurDetectionImplementation/research.ipynb: combining multiple classical metrics into a single k-NN classifier with high reported accuracy Bleaff/BlurDetectionImplementation/validate_methods.py: evaluation helpers and plotting utilities to support analysis

Expertise

Computer Vision & Image Analysis• Middle

Technologies

Python• since 2022 • Middle

PostgreSQL• since 2023

llama.cpp• since 2023

OpenCV• since 2023

vLLM• since 2023

Jupyter Notebook

Numba

Scikit-learn

SciPy

Computer Vision

AI Agents

Speech Recognition

ONNX• since 2023

TensorRT• since 2023

Ollama• since 2023

Transformers• since 2023

Pandas

NumPy

Git• since 2023

PyTorch• since 2023

Docker• since 2023

LLM• since 2023

RAG

Asyncio• since 2023

Whisper• since 2023

PyTorch C++

Ultralytics

Recommendations

Develop CPU-first CV pipelines and benchmarking suites that produce reproducible timing and accuracy reports, extending the existing time_checker and validation harness.
Harden and unit-test the metric implementations and evaluation scripts, adding CI tests and small synthetic-unit tests for edge cases and corrupted inputs.
Convert the exploratory notebook steps into reusable Python modules and a small experiment runner that logs runs and parameters (e.g., simple CSV/JSON logging or lightweight MLflow/W&B integration).
Improve robustness of data handling - remove hard-coded paths, add argument parsing or config files, and add defensive checks around file I/O and image loading.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

BlurDetectionImplementation Bleaff polygon_editor

Middle Game Developer Confidence: Medium Generalist

A pragmatic generalist developer at a Middle level (tier 3.0) who writes both small C++/SDL graphics prototypes and TypeScript service tooling. The strongest proven skill is building reliable Node.js integrations and service tooling with Google APIs and an MCP server, evidenced by src/index.ts, src/auth.ts, src/gmail.ts and package.json. There is limited evidence of advanced game-engine systems, renderer/shader engineering, deterministic simulation or measured performance optimization, and some C++ prototype code contains correctness issues rather than hardened production patterns.

Gameplay Systems & Mechanics

2/10

How game logic works

Basic gameplay loop and input-driven prototype code is present (SDL event loop, simple state like paused), but there are no non-trivial gameplay systems, decoupled state machines, or save/version migrations.

Evidence

Bleaff/Cubanoid/src/arrows_cube.cpp: main loop, SDL event handling and keyboard controls Bleaff/Cubanoid/main.cpp: instantiation and simple use of SmartPoint in a minimal demo

Graphics & Rendering

3/10

Drawing game visuals

Author wrote a small software renderer-style demo with explicit 3D rotation and projection math driving SDL rendering; this is useful graphics prototype work but not advanced renderer or shader engineering.

Evidence

Bleaff/Cubanoid/src/arrows_cube.cpp: manual rot_xyz rotation and projection then SDL_RenderDrawLineF calls Bleaff/Cubanoid/src/example.cpp: alternate variant of the wire-cube render path

Physics & Math

3/10

Game physics and math

Clear understanding of basic 3D/mathematical transforms and coordinate conversions (polar/cartesian), but no evidence of spatial partitioning, deterministic simulation, or custom physics integrators.

Evidence

Bleaff/Cubanoid/src/arrows_cube.cpp: rot_xyz function implementing Euler rotations Bleaff/Cubanoid/headers/PolarPoint.hpp: PolarPoint math and toCartesian conversion Bleaff/Cubanoid/headers/SmartPoint.hpp: combined Polar/Cartesian point container and arithmetic operators

Engine Proficiency

3/10

Skill with the game engine

Comfortable with engine/tooling basics - CMake packaging and SDL integration are authored, and the TypeScript project shows deliberate packaging and script usage - but there is not extensive evidence of editor tooling or deep engine customizations.

Evidence

Bleaff/Cubanoid/CMakeLists.txt: uses pkg_check_modules, links SDL2 image/ttf/mixer and sets compile options Bleaff/gmail_mcp/package.json: explicit build/dev/typecheck scripts and Node.js packaging setup

Performance & Frame Budget

1/10

Keeping the game smooth

Very little demonstrated performance engineering or measured frame-budget work; render loop uses VSync and reasonable framerate-friendly patterns but no profiling, pooling, or zero-alloc hot-paths are present.

Evidence

Bleaff/Cubanoid/src/arrows_cube.cpp: renderer created with SDL_RENDERER_PRESENTVSYNC (vsync used) Bleaff/gmail_mcp/package.json: build and typecheck scripts (tooling present but no perf instrumentation)

Content Pipeline & Tooling

1/10

Tools for game content

Minimal content-pipeline and tooling evidence beyond standard build scripts (CMake, npm). No asset import automation, CI pipeline configs, or editor tool plugins were found.

Evidence

Bleaff/Cubanoid/CMakeLists.txt: project build rules and pkg-config integration Bleaff/gmail_mcp/package.json: Node.js scripts for build/dev/typecheck

Expertise

Gameplay & Mechanics Development• Junior

Industries

Internet Services• Middle

Technologies

C++• since 2022 • Middle

CMake

STL

Recommendations

Own small-to-medium backend integrations and tooling (OAuth flows, API wrappers, service CLI) in Node.js/TypeScript.
Develop and prototype gameplay mechanics or interactive tech demos where a compact C++/SDL codebase suffices.
Implement build and deployment automation (CMake improvements, CI for native builds and TypeScript packaging) and harden cross-platform toolchains.
Avoid putting large rendering/engine tasks or high-performance netcode on this developer alone until deeper profiling and deterministic-simulation experience is proven.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

gmail_mcp Cubanoid

Middle Embedded Engineer Confidence: Medium Firmware Engineer

Embedded & Firmware

4/10

Low-level device code

Embedded firmware work on ESP32 with FreeRTOS task usage, web configuration portal, Preferences-based persistent settings and application-level servo control. The code shows practical RTOS task creation and lifecycle handling but relies on Arduino/AsyncWebServer/Servo libraries and lacks register-level drivers, ISR design, watchdog strategy or low-power measurements.

Evidence

Bleaff/ArduinoViolations/InitializeSettingsServer.cpp: start_monitor_thread (xTaskCreatePinnedToCore) and monitor_network_connection Bleaff/servo_server/WiFiConfigManager.cpp: connectSavedWiFi (WiFi.begin with timeout loop) and startConfigPortal Bleaff/servo_server/ServoController.cpp: begin/stopServos/attachServer (servo.attach + web handlers writing microseconds)

Hardware-Software Interface

3/10

Connecting code to hardware

Hardware-software interface is implemented at the protocol/API level (HTTP endpoints for servo and camera control, framed TCP stream reader) rather than register-level drivers. There is correct framing of streamed JPEG frames and simple request/response control for servos, but no register/datasheet-referenced peripheral drivers or bus recovery logic.

Evidence

Bleaff/servo_server/servoCamera.py: stream_receiver (4-byte size prefix framing and recv loop) Bleaff/servo_server/ServoController.cpp: HTTP handlers /move /stop /status (microseconds writes via Servo library) Bleaff/servo_server/WiFiConfigManager.cpp: setupServerRoutes (HTTP /save route storing servo pin settings into Preferences)

Resource Constraints

2/10

Working with limited resources

Some resource-awareness (Preferences for persistent storage, tuning stack size when creating a FreeRTOS task) but no linker scripts, flash/RAM budgeting, or measured power / memory footprints. Static defaults and simple persisted values are used but there is limited evidence of rigorous resource-constrained design.

Evidence

Bleaff/ArduinoViolations/InitializeSettingsServer.cpp: xTaskCreatePinnedToCore with stack size 3000 Bleaff/servo_server/WiFiConfigManager.cpp: use of Preferences for storing pins and offsets

Real-time & Timing

3/10

Precise timing control

Basic timing and latency awareness is present (WiFi connect timeout loops, frame-rate and bitrate computation in stream reader, microsecond servo control). However the firmware uses blocking delays and polling loops rather than capture/compare timers or documented WCET reasoning, and no priority inversion mitigation is visible.

Evidence

Bleaff/servo_server/servoCamera.py: FPS measurement and recv loop timing in stream_receiver Bleaff/ArduinoViolations/InitializeSettingsServer.cpp: monitor_network_connection with connect timeout logic Bleaff/servo_server/ServoController.cpp: microsecond writes via writeMicroseconds for servo positioning

HDL & Circuit Logic

Designing digital circuits

Not evidenced in public code

Reliability & On-device Testing

2/10

Testing on real hardware

Some pragmatic reliability steps - persistent portal option, reconnect attempts, reboot on settings save - but no watchdog strategy, firmware CRC/versioning, OTA rollback, or on-device automated tests / HIL evidence. Error handling is basic and there are blocking calls that could reduce robustness in constrained scenarios.

Evidence

Bleaff/servo_server/WiFiConfigManager.cpp: /save handler triggers ESP.restart() after storing settings Bleaff/servo_server/WiFiConfigManager.cpp: connectSavedWiFi includes a 10s timeout loop with delay and status checks Bleaff/ArduinoViolations/InitializeSettingsServer.cpp: monitor_network_connection implements connect retry and prints connection status

Expertise

Firmware• Middle

IoT & Connectivity Protocols• Middle

Industries

Hardware• Middle

Technologies

IoT

FreeRTOS

Recommendations

Implement and maintain ESP32-based IoT device firmware (web configuration portals, persistent settings, network lifecycle).
Develop companion host-side tooling for camera/servo systems (robust TCP framed streams, thread-safe buffering and UI display).
Extend firmware towards production-readiness: add watchdogs, OTA with rollback, non-blocking drivers and resource budgeting.
Integrate automated on-device tests or HIL (Renode/QEMU or hardware testbenches) and add firmware versioning and CRC checks.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

servo_server ArduinoViolations