Dmitry Filchenko
AI Engineer
11+ years exp
Python
SQL
JavaScript
Node JS
PowerShell
C#
TypeScript
PHP
Data Pipeline & Feature Engineering: 5/10
MLOps & Deployment: 5/10
Online
+7 (950) 7517588 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A backend-focused engineer at a senior level who builds careful, well-tested Python services and local tooling. The strongest proven skill is data-layer and analytics engineering (hand-tuned SQL and time-bucketed aggregation) as shown in token_lens/app/storage/queries.py. Not evidenced are large-scale distributed production deployments, advanced authn/authz lifecycle management, or formal API versioning and rate-limiting strategies in production.
Technical skills
Python• Senior
SQL
JavaScript
Node JS• Senior
PowerShell
C#• Senior • 11y+
TypeScript• Senior • 7y+
PHP• 7y+
Python
FastAPI
Uvicorn
HTTPX
Pydantic
Django
Asyncio
Node JS
Fastify
C#
SignalR
ASP.NET Core• 7y+
Entity Framework Core• 7y+
Databases
Chroma
SQLite
MS SQL• 10y+
MySQL• 7y+
AI/ML
ChatGPT
Embeddings
LM Studio
Prompt Engineering
RAG
Transformers
AI Agents• 3y+
LLM• 3y+
Frontend
React.js
Vite
React Query
Angular• 7y+
Bootstrap• 7y+
Zod• 3y+
DevOps
AWS
Bitbucket
CI/CD
Vector
Git• 14y+
TeamCity• 10y+
Graylog• 7y+
Nginx• 7y+
Rest API• 7y+
Docker• 6y+
WebRTC• 5y+
Mobile
Android SDK
MVC
MVP
Game Dev
Azure PlayFab
Unity• 11y+
QA
Playwright
Pytest
Timeline
Unity Developer
•
Middle
Logistiks
•
Full-Time
Developed and maintained Unity applications to visualize warehouse logistics and WMS operations using 3D/2D rendering. Implemented interactive simulation scenarios for analyzing and demonstrating warehouse processes. Built frontend and backend components for internal tooling and configured deployment and runtime environments for project instruments and demos. Delivered capabilities for designing and configuring warehouse scenarios for demos and testing.
Unity
C#
ASP.NET Core
WebRTC
Rest API
Git
LLM
AI Agents
Unity Developer
•
Middle
EnterAR
•
Full-Time
Worked on an AR platform for Magic Leap, contributing to the Unity client, backend components, and a WebRTC streaming system. Implemented and iterated AR application features for the device, including UI and business logic updates. Built backend logic and APIs for the AR-Assist platform. Integrated the Unity client with backend services and developed the streaming interaction layer.
Unity
C#
ASP.NET Core
WebRTCsince 2022
Rest API
Git
Unity Developer
•
Middle
Wirgo
•
Full-Time
Contributed to preparing a casual game for release by updating game business logic and implementing UI logic and interfaces. Extended and maintained a custom Unity game framework (Dramework4) and integrated ad, monetization, and analytics SDKs/plugins. Automated build processes through TeamCity and fixed release defects to support the launch. Supported integration and release readiness across project modules.
C#
Unity
TeamCity
Git
C# / Unity / Backend Developer
•
Middle
CraftGames
•
Full-Time
Designed and implemented client-server architecture for multiplayer shooter networking and backend services for casual games. Developed networking logic and client-server interaction and adapted game business logic for multiplayer constraints. Implemented REST APIs and external service integrations, including PlayFab integration. Worked with databases (MongoDB and MySQL) and supported build and deployment automation using TeamCity, Docker, and Git, with targeted NUnit tests.
C#
ASP.NET Core
Unity
Rest API
MySQL
Angular
Bootstrap
PHP
Nginx
TeamCity
Docker
Git
Developer
•
Middle
Crocomobi
•
Full-Time
Developed Unity-based casual game client and server components for outsourced projects. Implemented gameplay/business logic, UI, networking, and integrations with third-party services and SDKs/plugins. Optimized client-side application performance and contributed to backend business logic and database updates. Supported backend deployment and enhanced backend architecture through iterative improvements to networked components and data handling.
C#
Unity
PHPsince 2019
Nginxsince 2019
Angular
Bootstrap
MySQLsince 2019
Rest API
Git
Fullstack Developer
•
Middle
Petrovax Farm
•
Full-Time
Developed an SSCC code generator for a production line, including both client and server parts and integration with external systems. Implemented MVC architecture for a client-server application and added business logic for generating and processing packaging codes. Built REST API integrations and developed the UI with Angular and Bootstrap. Worked with MS SQL/T-SQL for data storage and processing and delivered end-to-end functionality through version control.
C#
ASP.NET Core
Angular
Bootstrap
MS SQL
Rest API
Git
Developer
•
Middle
Grand Capital
•
Full-Time
Built a CRM system and a RESTful service from scratch, contributing to overall architecture and both client/server business logic. Implemented MVC-based client and server components and developed the REST API. Optimized network interactions and designed database structures for the service. Worked with Entity Framework and MS SQL/T-SQL, and set up logging and diagnostics for the solution.
C#
ASP.NET Coresince 2019
Angularsince 2019
TypeScript
Bootstrapsince 2019
Entity Framework Core
MS SQL
Rest APIsince 2019
Graylog
Git
Developer / Team Lead
•
Lead
Datcroft Games
•
Full-Time
Developed and deployed client-server casual games and contributed to an MMO RPG project as a team lead. Owned client and server business logic, UI, payment servers, databases, testing tools, and deployment processes. Coordinated and discussed server-side task breakdown, supported development workflow optimization, and handled CI/deploy execution using TeamCity. Managed deployments to AWS and contributed to improving testing coverage and release readiness.
C#
Unity
MS SQLsince 2016
TeamCitysince 2016
Git
International Institute of Computer Technologies
Bachelor's Degree •
Computing Machines, Complexes, Systems and Networks
Developer
•
Middle
Game Insight
•
Full-Time
Contributed to the development of an MMO RPG project in Unity by extending and refactoring existing C# code. Implemented new application modules and improved project business logic through iterative development. Focused on maintaining and evolving Unity project components using existing code patterns and version control practices. Supported ongoing feature development with refactoring and module integration.
C#since 2015
Unitysince 2015
Gitsince 2015
Senior AI/ML Engineer
Confidence: High LLM Engineer
A senior-level LLM-focused engineer and builder of agent orchestration and local LLM observability tools. The strongest proven skill is engineering robust ingestion and analytics pipelines for LLM usage along with orchestration code - evidenced by token_lens/app/services/import_service.py, token_lens/app/storage/queries.py and mini-orchestrator runtime/orchestrator modules. There is minimal evidence of custom model training, research implementations, or low-level efficiency work (GPU/quantization) in public code.
Model Architecture & Training
1/10
How well models are designed and trained
Little to no evidence of model design or training code; primarily API clients and model selection wrappers rather than custom architectures or training loops.
Evidence
mini-orchestrator/mini_orchestrator/llm.py: OpenAiResponsesClient and LlmJsonResult (API wrapper, not training)
mini-orchestrator/mini_orchestrator/model_defaults.py: model selection helpers
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Well-structured ingestion and transformation pipelines for local LLM usage logs; careful parsers, incremental import logic, and SQL normalization indicate solid pipeline engineering.
Evidence
token_lens/app/services/import_service.py: import_usage_source, import_codex_logs (incremental import & parsing orchestration)
token_lens/app/sources/codex/parser.py: parse_usage_row, parse_response_event (parsing and normalization)
token_lens/app/storage/queries.py: complex SQL aggregation and bucketing logic
Experimentation & Evaluation
3/10
How results are measured and tested
Basic evaluation and test harnesses exist (eval runner and many unit tests), but there is no evidence of experiment tracking, systematic ablation studies or ML experiment management.
Evidence
mini-orchestrator/mini_orchestrator/evals/runner.py: eval suite runner and upsert/read APIs
token_lens/tests/test_api_contracts.py: broad unit tests exercising parsing, import and analytics paths
MLOps & Deployment
5/10
How models are shipped to production
Clear engineering for local deployment and runtime lifecycle: background import threads, UI server recovery, persistent runtime store and HTTP server entrypoints demonstrate production-aware MLOps and service design.
Evidence
token_lens/app/api/server.py: start_import_thread, ThreadingHTTPServer startup and import orchestration
mini-orchestrator/mini_orchestrator/runtime_store.py: sqlite-based runtime persistence and helpers
avito-bot/app/server.py: FastAPI/uvicorn service entry and runtime logging integration
Computational Efficiency
3/10
How efficiently computing resources are used
Some attention to efficiency and safety at the application and query level (scan limits, bucketing, incremental scans), but no low-level GPU or model-efficiency engineering.
Evidence
token_lens/app/storage/queries.py: RAW_ONLY_TASK_SCAN_LIMIT, TASK_USAGE_SCAN_MULTIPLIER and optimized SQL CTEs
token_lens/app/services/import_service.py: incremental scanning behavior and use of iter_rows_after to avoid full scans
Research Depth & Innovation
1/10
Depth of research and new ideas
No evidence of research-level contributions, custom layers, reproduced papers, or novel algorithms; code is engineering-focused rather than research artifacts.
Evidence
project: overall codebase (mini-orchestrator, token_lens, avito-bot) - engineering artifacts rather than paper implementations
Expertise
AI Agents & Agentic Workflows• Senior
LLM• Senior
MLOps & Model Lifecycle• Senior
Industries
Artificial Intelligence• Senior
Commerce• Senior
Technologies
Python• Senior
SQL
MySQL• 7y+
Rest API• 7y+
ChatGPT
WebRTC• 5y+
Embeddings
Prompt Engineering
AI Agents• 3y+
LM Studio
MS SQL• 10y+
CI/CD
Transformers
Django
Git• 14y+
SQLite
AWS
Docker• 6y+
Nginx• 7y+
LLM• 3y+
RAG
Asyncio
HTTPX
Graylog• 7y+
TeamCity• 10y+
Bitbucket
Vector
Recommendations
- Develop multi-agent orchestration systems, approval-gated runtimes and production LLM integrations (use for orchestrator, dispatch and runtime services).
- Build observability and analytics tooling for LLM usage and cost tracking (expand token-lens style ingestion, parsers, and dashboards).
- Implement MLOps integrations and deployment workflows around LLM services - runtime persistence, service discovery and graceful recovery logic are clear strengths to operationalize.
- Avoid assigning experimental model training or SOTA research tasks - public artifacts do not show custom training loops, optimizers, or research reproducibility pipelines.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High API Engineer
A backend-focused engineer at a senior level who builds careful, well-tested Python services and local tooling. The strongest proven skill is data-layer and analytics engineering (hand-tuned SQL and time-bucketed aggregation) as shown in token_lens/app/storage/queries.py. Not evidenced are large-scale distributed production deployments, advanced authn/authz lifecycle management, or formal API versioning and rate-limiting strategies in production.
API Design
5/10
How well APIs are designed
Solid, pragmatic API surface with multiple HTTP handlers and schemas, clear error handling in places, but limited evidence of formal versioning, idempotency strategies, or API-level contracts for distributed deployments.
Evidence
token_lens/app/api/handlers.py
mini-orchestrator/mini_orchestrator/ui.py (HTTP handler endpoints and _json_response)
avito-bot/app/main.py (FastAPI router endpoints and pydantic schemas)
Data Layer & Database
7/10
Working with databases
Strong data-layer craftsmanship: hand-tuned SQL, careful aggregation queries, schema helpers, and explicit repository patterns for SQLite; clear attention to filling time buckets and correctness.
Evidence
token_lens/app/storage/queries.py (complex CTEs, bucket filling, hand-tuned aggregates)
mini-orchestrator/mini_orchestrator/runtime_store.py (sqlite runtime store management)
avito-bot/app/storage.py (sqlite/postgres import/export, schema awareness)
Scalability & Performance
5/10
Handling load and speed
Reasonable scalability considerations: background import threads, caching of external usage limits, tuned SQL and limits/scan caps; however there is little evidence of systematic connection pooling, distributed scaling or measured performance tuning.
Evidence
token_lens/app/services/data_refresh.py (auto_import_loop, background import logic)
token_lens/app/storage/queries.py (LIMIT and scan-multiplier tuning, raw-only scan caps)
token_lens/app/api/server.py (ThreadingHTTPServer and import thread management)
System Architecture
6/10
Overall system structure
Deliberate modular architecture across multiple projects - orchestrator, runtime store, flow compilation and UI boundaries show thoughtful decomposition and separation of responsibilities.
Evidence
mini-orchestrator/mini_orchestrator/orchestrator.py (Orchestrator class composing planner, router, executor)
mini-orchestrator/mini_orchestrator/agent_flows.py (flow validation, compilation, topological ordering)
mini-orchestrator/mini_orchestrator/runtime_store.py (centralized runtime persistence abstraction)
Security & Auth
4/10
Protecting data and access
Basic security hygiene is present - use of environment-based config, pydantic schemas, and some checks (e.g. avoiding WindowsApps alias). There is limited evidence of a comprehensive authn/authz lifecycle, token revocation, secrets management or dependency audit traces.
Evidence
avito-bot/app/config.py (Settings from environment using dotenv, masking helpers)
avito-bot/app/schemas.py (pydantic request schemas)
token_lens/app/services/codex_account_service.py (codex command validation and WindowsApps alias rejection)
Reliability & Observability
6/10
Stability and monitoring
Good reliability and observability practices: structured logging helpers, rotating file handlers, admin logging buffer, test coverage for failure modes, background job status tracking and local-recovery logic for the mini client.
Evidence
token_lens/app/core/logging_config.py (rotating file handler resolution)
avito-bot/app/admin_logging.py (AdminLogBuffer and JSONL plugins)
token_lens/desktop/mini_client.py (try_recover_local_server, wait_for_api, controlled recover/retry)
Expertise
Python• Senior
Backend AI & LLM• Middle
Industries
Artificial Intelligence• Middle
Commerce• Middle
Data & Analytics• Middle
Technologies
PHP• 7y+
Chroma
FastAPI
Pydantic
Uvicorn
Recommendations
- Develop analytics and observability backends - implement usage pipelines, hand-tuned SQL, and reliable background imports (e.g., further work on token_lens-style analytics).
- Build LLM orchestration and integration features - planner/agent flow, runtime store and dispatcher components (extend mini-orchestrator agent flows and orchestrator work).
- Integrate and harden production API services - add API versioning, idempotency keys, explicit rate limiting and connection pooling for scaled deployments.
- Implement secure secrets and token lifecycle management - centralize secrets, add refresh/revocation, and run dependency security audits.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Frontend Developer
Confidence: Medium UI Engineer
A senior-level UI engineer with strong practical experience building interactive, data-driven web interfaces and mapping UIs. The strongest proven skill is client-side async state and UI integration - evidenced by station-map.js (request debouncing, AbortController-based cancellation, incremental ndjson streaming, marker clustering) and server-side streaming/timeouts in server.js. There is limited public evidence of large-scale platform architecture, formal performance measurement (RUM/before-after metrics) or enterprise integration patterns in the code shown.
UI Component Architecture
6/10
How interface parts are built
Modular, component-like UI architecture and separation between UI rendering and data logic; uses composition patterns and custom hooks rather than a monolithic script.
Evidence
benz_ai/public/app.js: orchestrates UI, uses createStationMap() and separates map/list rendering
benz_ai/public/station-map.js: createStationMap factory returning an API (showStations, setFilters, locateUser, activate/deactivate) and mergeStationCache function
WorkNest/apps/web/src/hooks/useWorkNestUiState.ts: custom React hook for persisted UI state and project composition
Responsive & Cross-browser
5/10
Works on all screens and browsers
Responsive layout and cross-browser feature detection are present (media queries, geolocation checks, locale-aware formatting), but no advanced fluid type/container queries or explicit RTL tooling.
Evidence
WorkNest/apps/web/src/styles/base.css: media queries and responsive grid adjustments for multiple breakpoints
benz_ai/public/station-map.js: locateUser() checks navigator.geolocation and handles permission/timeouts
benz_ai/public/app.js: uses locale-aware formatting (toLocaleString, toLocaleLowerCase) for RU locale
Performance Optimization
6/10
Speed of the interface
Deliberate performance work with debouncing, request cancellation, streaming, caching and chunked marker loading; measurable instrumentation (timeouts) on server and client sides.
Evidence
benz_ai/public/station-map.js: VIEWPORT_DEBOUNCE_MS, VIEWPORT_REQUEST_TIMEOUT_MS, requestSequence and AbortController-based cancellation, fetchNdjson streaming handlers
benz_ai/server.js: withTimeout and boundedProviderCall implementing timeouts/AbortController, streamProviderSnapshots for incremental provider streaming
benz_ai/public/station-map.js: uses marker clustering with chunkedLoading and requestAnimationFrame to manage renders
Accessibility & Semantics
6/10
Usable for everyone
Solid accessibility and semantics for custom widgets - keyboard handling, focus management, aria attributes and focus-visible styles are implemented across UI surfaces.
Evidence
benz_ai/public/app.js: keyboard navigation for tabs and table section tabs, sets aria-selected and aria-sort attributes
benz_ai/public/station-map.js: marker elements set title/alt/aria-label, LocateControl button has aria-label and keyboard-friendly behavior
WorkNest/apps/web/src/styles/base.css: focus-visible outline styles and focus management helpers
State Management & Data Flow
6/10
Managing data in the app
Well-structured state management and server-state discipline - persistent client UI state, streaming server responses, cache TTLs, abortable provider calls and careful merge logic; race conditions are explicitly handled.
Evidence
benz_ai/server.js: readFreshCache/writeBoundedCache usage, searchStations merging multiple provider results, boundedProviderCall for cancelable provider requests
benz_ai/public/station-map.js: activeRequest abort logic, requestSequence to avoid stale responses, mergeStationCache for deterministic merges
WorkNest/apps/web/src/hooks/useWorkNestUiState.ts: persistent UI state (localStorage), debounced persistence and controlled derived state
UX & Visual Polish
6/10
Look and feel quality
Good UX coverage for edge states - loading, empty, and error states; clear messaging, disabled controls during operations and pagination handling; lacks explicit skeleton components and measured RUM data.
Evidence
benz_ai/public/app.js: loadSummary shows loading messages, disables controls during network operations, handles errors and empty results
benz_ai/public/station-map.js: showMessage, updateVisibleCount and targeted messages for timeouts and missing data
benz_ai/public/app.js: renderStations produces explicit empty-state rows and pagination summaries
Expertise
React• Middle
Technologies
TypeScript• Senior • 7y+
Node JS• Senior
Angular• 7y+
Bootstrap• 7y+
React.js
Vite
React Query
Zod• 3y+
Recommendations
- Lead development of interactive mapping and real-time data visualizations (map tiling, streaming updates, clustering and virtualization).
- Build and maintain a small design-system library and accessible component set (map popups, list/table patterns, keyboard-first widgets).
- Implement RUM-driven performance audits and bundle/split strategies (LCP/INP measurements, bundle-analyzer runs) for the public UI.
- Own complex client-server data flows - streaming endpoints, cache invalidation policies and robust cancellation/race handling.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: