Oleg Alion
AI Engineer
4+ years exp
JavaScript
TypeScript
SQL
Python
Node JS
Data Pipeline & Feature Engineering: 5/10
MLOps & Deployment: 4/10
Computational Efficiency: 4/10
Active 18 days ago
+7 (922) 4831622 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic LLM engineer operating at a conservative senior level (tier_score 4.0) who delivers production-ready LLM integrations and async automation. The strongest proven skill is building LLM-driven document ingestion and comparison pipelines with concrete artifacts in pdf_to_md.process_pdf and extract_from_markdown that implement caching, chunking and schema-guided extraction. What is not evidenced is custom model training, rigorous experiment tracking, quantization or distributed model training and serving.
Technical skills
JavaScript
TypeScript• Junior
SQL• Middle • 4y+
Python• Senior
Node JS• Junior
Python
SQLAlchemy
Asyncio
Aiohttp
Requests
Node JS
Electron
Express
C
FFmpeg
Databases
MS SQL
PostgreSQL
SQLite
AI/ML
Claude
RAG
OpenAI SDK
NLP
VLM
Chain-of-Thought
DeepSeek
LLM
Prompt Engineering
Claude Code
Frontend
React.js
Zustand
Tailwind CSS
Vite
DevOps
Docker
Docker Compose
Debian
WebSockets
GCP
Rest API
Ubuntu
Zabbix
QA
Postman
Playwright
Timeline
AI Engineer
•
Middle
Digital Siberia
•
Full-Time
Built end-to-end AI-first monitoring solutions as the sole developer, covering architecture, deployment, and 24/7 autonomous operation. Developed video surveillance monitoring for ~100 cameras across incompatible vendor systems with status checks, frame capture, and daily email reports. Implemented RTSP/SMB and Wi‑Fi integrations with FFmpeg, deduplicated Bitrix24 alerts, and multimodal DeepSeek LLM agents controlled via Playwright. Also created a local speech-to-text to DeepSeek summarization pipeline and delivered real-time Wi‑Fi monitoring with Zabbix plus a Yandex Maps web UI.
Claude Code
DeepSeek
Playwright
Bitrix24
FFmpeg
SQLite
Zabbix
Node JS
Prompt Engineering
Rest API
AI Engineer / AI Product Engineer
•
Middle
Gleb Mikhailovich Timofeev (IP)
•
Full-Time
Developed an ETL pipeline for VK dialogs to support AI-driven business analytics. Parsed coach-student conversations via VK API, normalized data into a database, and used DeepSeek to classify learning stages, extract tasks, detect unanswered questions, and generate per-student summaries. Implemented scheduled Python jobs for daily benchmarking, and deployed services to an Ubuntu VPS with systemd and centralized logging. Integrated Google Calendar/Sheets and Telegram Bot API, and used Claude Code for iterative Node.js/Python development plus endpoint testing in Postman.
DeepSeeksince 2024
Claude Codesince 2024
Python
Node JSsince 2024
GCP
Prompt Engineeringsince 2024
Chain-of-Thought
Postman
Ubuntu
Rest APIsince 2024
LLM
IT Support Administrator (First Line)
•
Middle
AmTel-soft
•
Full-Time
Managed first-line user requests related to missing or inconsistent database data. Performed initial diagnosis, analyzed incident causes, and determined whether resolution was possible on the first support level. Maintained incident reporting and a knowledge base, working with Jira and Confluence and using SQL queries to reconcile data between records. Reduced first-response processing time and decreased escalations and repeated tickets by standardizing troubleshooting materials.
Jira
Confluence
SQL
Senior AI/ML Engineer
Confidence: High LLM Engineer
A pragmatic LLM engineer operating at a conservative senior level (tier_score 4.0) who delivers production-ready LLM integrations and async automation. The strongest proven skill is building LLM-driven document ingestion and comparison pipelines with concrete artifacts in pdf_to_md.process_pdf and extract_from_markdown that implement caching, chunking and schema-guided extraction. What is not evidenced is custom model training, rigorous experiment tracking, quantization or distributed model training and serving.
Model Architecture & Training
2/10
How well models are designed and trained
Integration-focused LLM work: well-crafted prompts and API usage but no custom model training, fine-tuning, or custom architectures.
Evidence
VKCurator_bot/bot/classifier.py: is_delayed_response uses OpenAI.chat.completions with PROMPT and JSON extraction
test_222/src/extract_params.py: extract_from_markdown builds EXTRACT_PROMPT and calls client.chat.completions.create
test_222/src/compare.py: llm_compare_batch and compare_params use LLM batched calls for ambiguous comparisons
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Robust document/data pipeline and feature extraction: structured schema, chunking, caching and normalization tailored to technical drawings and DOCX parsing.
Evidence
test_222/src/pdf_to_md.py: process_pdf, clean_text, cache_key and caching of vision results
test_222/src/extract_params.py: chunk_markdown, CHUNK_CHAR_LIMIT and extract_from_markdown for progressive extraction
test_222/src/schema.py: PARAM_SPECS defines the extraction schema used by the pipeline
Experimentation & Evaluation
1/10
How results are measured and tested
Minimal formal experimentation or tracking - generates human-readable reports but lacks experiment tracking, baseline comparisons, or reproducible ML experiments.
Evidence
test_222/src/compare.py: render_report produces detailed comparison reports for users (presentation-level evaluation)
MLOps & Deployment
4/10
How models are shipped to production
Practical deployment engineering: async bot, scheduler, background tasks, DB session management and safe defaults for LLM failures, but limited CI/CD, monitoring or model lifecycle tooling shown.
Evidence
VKCurator_bot/bot/scheduler.py: build_scheduler using APScheduler for daily jobs
VKCurator_bot/main.py: orchestration (init_db, build_bot, init_sheet) and startup/shutdown handling
VKCurator_bot/db/database.py and VKCurator_bot/db/crud.py: async_session_factory usage and async CRUD patterns
Computational Efficiency
4/10
How efficiently computing resources are used
Efficiency-minded engineering: caching of vision calls, chunking to respect model limits, async I/O and batched LLM requests to reduce cost/latency.
Evidence
test_222/src/pdf_to_md.py: cache_key and cache hit logic to avoid repeated vision calls
test_222/src/extract_params.py: CHUNK_CHAR_LIMIT and chunk_markdown to control context size
test_222/src/compare.py: llm_compare_batch batches multiple comparisons into one LLM call
Research Depth & Innovation
3/10
Depth of research and new ideas
Good applied research hygiene and domain heuristics (normalization, canonicalization, domain-specific rules) but no novel algorithms, papers, or custom model implementations.
Evidence
test_222/src/compare.py: _canon, _simple_compare and normalization heuristics for numeric, RAL and roman comparisons
test_222/src/schema.py: curated PARAM_SPECS used to guide extraction and normalization
Expertise
Conversational AI & Chatbots• Middle
Document Intelligence & OCR• Middle
LLM• Middle
Industries
Education• Middle
Science & Engineering• Middle
Technologies
Python• Senior
SQL• Middle • 4y+
PostgreSQL
Rest API
Claude
GCP
Docker Compose
Zabbix
DeepSeek
Claude Code
Debian
Prompt Engineering
Chain-of-Thought
NLP
VLM
OpenAI SDK
MS SQL
SQLite
Docker
Ubuntu
LLM
RAG
Asyncio
Requests
Recommendations
- Develop LLM-powered chatbots and notification systems that require async integrations, background tasks and safe LLM fallbacks.
- Build document-to-structured-data pipelines (vision+text) for engineering drawings, invoices or contracts, leveraging chunking and caching patterns shown.
- Implement production integrations around scheduled reporting, DB-backed message workflows and Google Sheets / third-party APIs for operational automations.
- Expand into MLOps around model evaluation and tracking (W&B/MLflow) and formalize CI/CD and monitoring for LLM cost/latency/health.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Backend Developer
Confidence: Medium API Engineer
A pragmatic mid-level backend engineer focused on async Python services and integrations, particularly chatbots and automation. Strongest proven skill is building production-ready messaging/automation flows with database backing and LLM integration, as shown by bot/notifier.py and db/crud.py in the VK curator bot. Missing from public code is evidence of large-scale distributed system design, formal load-testing, or comprehensive automated test suites.
API Design
3/10
How well APIs are designed
API/interaction design is pragmatic and consistent for the bot domain (command handlers, permission checks, background tasks), but lacks formal versioning, idempotency schemas and API contract boundaries.
Evidence
VKCurator_bot/bot/vk_listener.py: command handlers (/start, /stop, /sync, /broadcast) with permission gating
VKCurator_bot/bot/notifier.py: send_dm + check_and_alert showing recipient resolution and message content design
VKCurator_bot/bot/sheets.py: migration logic _migrate_legacy_columns demonstrating backward-compatibility handling for Google Sheets output
Data Layer & Database
4/10
Working with databases
Database layer shows careful use of async SQLAlchemy sessions, transactional commits and conditional updates; there is practical data-model handling but no deep evidence of multi-step migration history or hand-tuned SQL for scale.
Evidence
VKCurator_bot/db/crud.py: use of async_session_factory(), explicit transactions via session.commit(), conditional update of Conversation.last_student_message_at in save_message
VKCurator_bot/db/crud.py: upsert_participant and delete_conversation implementing idempotent upsert and cascaded deletes
Scalability & Performance
4/10
Handling load and speed
Concurrency and scaling patterns are present (asyncio, caching, background tasks, per-bot retry attempts), but no formal rate-limiting, distributed queueing, or documented load-testing.
Evidence
VKCurator_bot/bot/notifier.py: _members_cache TTL and Notifier.send_dm trying multiple API instances
VKCurator_bot/bot/vk_listener.py: asyncio.create_task used for background classification to avoid blocking main flow
VKCurator_bot/bot/classifier.py: asyncio.to_thread used to call blocking LLM client with timeout
System Architecture
4/10
Overall system structure
Code is modular and organized (separate modules for listener, notifier, classifier, DB, sheets), showing sensible boundaries for an integrated bot service; not evidence of multi-service distributed architecture or inter-service contracts.
Evidence
VKCurator_bot/bot/vk_listener.py: clear separation of message handling, commands and background classification
VKCurator_bot/bot/notifier.py and VKCurator_bot/bot/sheets.py: dedicated modules for notifications and external Google Sheets integration
VKCurator_bot/db/crud.py: DB access isolated in a crud module
Security & Auth
4/10
Protecting data and access
Reasonable security hygiene is visible - permission checks, safe defaults when secrets are missing, and use of parameterized ORM queries - but no formal secrets-management or threat-model documentation.
Evidence
VKCurator_bot/bot/vk_listener.py: _is_head_curator guard ensures sensitive commands are restricted
VKCurator_bot/bot/classifier.py: safe default behaviour when POLZA_API_KEY is missing and explicit timeout usage
VKCurator_bot/db/crud.py: use of SQLAlchemy ORM/parameters for DB operations (reduces SQL injection risk)
Reliability & Observability
4/10
Stability and monitoring
Good operational awareness - structured logging, retries in places, caching and background jobs - but limited evidence of systematic observability (metrics/alerts) or extensive test coverage in the human-authored files.
Evidence
VKCurator_bot/bot/notifier.py: structured logging calls (logger.info/warning) around alert flows
VKCurator_bot/bot/vk_listener.py: background tasks via asyncio.create_task and retry logic for fetching chat title
VKCurator_bot/bot/classifier.py: try/except with safe fallbacks for LLM calls
Expertise
Backend AI & LLM• Junior
Messaging & Real-time• Junior
Python• Junior
Industries
Education• Middle
Technologies
SQLAlchemy
Aiohttp
Recommendations
- Develop asynchronous Python backend services that integrate chat platforms, LLMs, and relational databases (alerting bots, automation, and reporting).
- Implement medium-complexity operational tooling: scheduled jobs, deduplicated helpdesk/email workflows, and small internal dashboards tied to a Postgres/SQLAlchemy store.
- Work on API-driven extensions (webhooks, web UIs, Google Sheets integration) and reliability improvements (retry/backoff strategies, metrics, and smoke tests).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: High App Engineer
A pragmatic app-focused engineer at a mid (middle) level who builds desktop/web automation and monitoring tooling with Electron, Playwright and a WebSocket-backed SPA. The strongest proven skill is integrating cross-process automation and real-time UI state (e.g., electron/main.js start-scan + Python runner orchestration and quiz-funnel-runner/src/store/useAppStore.ts handling WS/logs). There is limited public evidence of systematic frontend component libraries, comprehensive automated UI tests, or explicit performance benchmarking and CI-enforced a11y checks.
UI Component Architecture
4/10
How interface parts are built
Practical component/state architecture focused on a central store and IPC boundaries (Zustand + preload IPC). Clear separation between server, runner and UI layers but little evidence of a bespoke design system or comprehensive component test coverage.
Evidence
quiz-funnel-runner/src/store/useAppStore.ts: centralized Zustand store and WS/state handlers
quiz-funnel-runner/src/types/index.ts: typed domain models for UI
quiz-funnel-runner/electron/preload.js: explicit IPC bridge (contextIsolation) defining UI ↔ main process boundary
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive concerns and feature detection are addressed in UI scripts; map and admin UI handle variable datasets and mobile view adjustments. Not a showcase of advanced container queries or explicit RTL/i18n plumbing, but pragmatic layout and viewport handling are present.
Evidence
wifichecker/public/map.js: center calculation, mobile fallbacks and responsive map initialization
quiz-funnel-runner/src/store/useAppStore.ts: AbortSignal.timeout used for network checks (defensive network handling)
wifichecker/public/admin.js: keyboard Escape handling and dialog role usage
Performance Optimization
3/10
Speed of the interface
Some measured/performance-aware patterns (caching, batching and controlled concurrency appear in human-authored runner/server code) but no published before/after metrics or bundle-analysis artifacts. Reasonable pragmatic optimizations rather than deep perf engineering.
Evidence
quiz-funnel-runner/server/index.js: Playwright browser reuse, screenshot streaming and sequential funnel processing
quiz-funnel-runner/runner/runner.js: randomDelay/concurrency control and URL loop detection
Accessibility & Semantics
4/10
Usable for everyone
Accessible affordances are present (role attributes, aria-labels, keyboard close with Escape, semantic SVG roles). Evidence is at the interactive widget level rather than systematic a11y testing or CI gating.
Evidence
wifichecker/public/admin.js: dialog markup (role="dialog"), Escape key handling and aria labels on SVG charts
quiz-funnel-runner/server/index.js: informative log messages used for UI feedback (helps focus/announce)
State Management & Data Flow
5/10
Managing data in the app
Robust state & data flow across processes: client store (Zustand) + server WebSocket broadcasts + Electron main ↔ Python runner lifecycle with streaming JSON parsing. There is explicit handling for run state, stop/resume, and error propagation across boundaries.
Evidence
quiz-funnel-runner/src/store/useAppStore.ts: WS connection lifecycle, reconnect, runStart/runStop flows and AbortSignal usage
quiz-funnel-runner/electron/main.js: start-scan handler, Python process spawn, stdout JSON parsing and lifecycle/error handling
quiz-funnel-runner/server/index.js: activeScan state, broadcast() and graceful stop logic
UX & Visual Polish
4/10
Look and feel quality
UX-oriented details are implemented: progress/log streaming, screenshot capture and classification, and fail-safe behaviors (retries, fallbacks). Visual polish evidence is pragmatic (screenshots, live updates) but full component-level UI polish and animation/undo patterns are not visible in the inspected human-authored files.
Evidence
quiz-funnel-runner/server/index.js: broadcast of logs and screenshot events to UI, screenshot naming and classified storage
quiz-funnel-runner/src/store/useAppStore.ts: logs buffer, runProgress and user-facing error messaging
Expertise
React• Junior
Frontend AI Integration• Junior
Technologies
TypeScript• Junior
Node JS• Junior
Zustand
Tailwind CSS
Express
Electron
WebSockets
React.js
Vite
Recommendations
- Use this engineer to build cross-process automation tools and desktop UIs (Electron + headless/Playwright runner) that need robust process/lifecycle handling and realtime UI updates.
- Assign them to develop monitoring dashboards with real-time feeds and map-based visualizations (WebSocket feeds, SVG charts, Yandex/Map integrations).
- Let them implement integrations between frontend and backend automation services (IPC, streaming stdout JSON, error propagation and retries).
- Avoid assigning large-scale frontend design-system ownership or enterprise accessibility programs until more component-level tests and design-system artifacts appear.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: