Ivan Deyn
Python
Go
Node JS
TypeScript
Experimentation & Evaluation: 5/10
Data Pipeline & Feature Engineering: 4/10
MLOps & Deployment: 4/10
Active 13 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
Senior-level LLM engineer and backend developer specializing in async LLM benchmarking and production-ready analytics services. The strongest proven skill is designing robust async inference and benchmarking infrastructure with retries, metrics and comprehensive tests, demonstrated by promptum/src/promptum/providers/openrouter.py and the Runner/Session test-suite. There is no evidence of custom model training, GPU/quantization optimization, or full model lifecycle MLOps like drift monitoring or model serialization.
Technical skills
Python• Senior
Go• Senior
Node JS• Senior
TypeScript• Middle
Python
Asyncio
HTTPX
Pydantic
Go
Chi
Node JS
Bcrypt
Databases
Redis
PostgreSQL
AI/ML
LLM
Prompt Engineering
Frontend
React.js
React Query
Tailwind CSS
Vite
PostCSS
autoprefixer
React Router
Zustand
Senior AI/ML Engineer
Confidence: High LLM Engineer
Senior-level LLM engineer and backend developer specializing in async LLM benchmarking and production-ready analytics services. The strongest proven skill is designing robust async inference and benchmarking infrastructure with retries, metrics and comprehensive tests, demonstrated by promptum/src/promptum/providers/openrouter.py and the Runner/Session test-suite. There is no evidence of custom model training, GPU/quantization optimization, or full model lifecycle MLOps like drift monitoring or model serialization.
Model Architecture & Training
1/10
How well models are designed and trained
Little-to-no evidence of building or training ML models or custom architectures; project focuses on LLM API benchmarking and wrappers rather than model training or architecture engineering.
Evidence
promptum/src/promptum/providers/provider.py: LLMProvider abstract base for inference-only providers
promptum/src/promptum/providers/openrouter.py: OpenRouterClient implements API calls and metrics but not model training
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Solid data-processing and domain logic for analytics pipelines (submission filtering, deduplication, tag aggregation), evidenced by comprehensive unit tests and controller logic for stale/fresh caching.
Evidence
deyna256/betterforces/backend/tests/unit/tags_service/test_analysis.py: extensive tests covering tag aggregation, median/average calculations and deduplication
deyna256/betterforces/backend/api/routes/tags.py: route logic that filters by time period, handles stale data, and uses tags analysis results
Experimentation & Evaluation
5/10
How results are measured and tested
Good experimentation and evaluation engineering for LLMs: structured test-run/session/runner/report pipeline, metrics collection, and validators for automated benchmarking and reproducible reports.
Evidence
promptum/src/promptum/session/runner.py: concurrent runner executing prompts with callbacks and TestResult aggregation
deyna256/promptum/tests/benchmark/test_report_summary.py: tests validating report summarization and filtering behavior
MLOps & Deployment
4/10
How models are shipped to production
Operational inference engineering and service deployment patterns present (async clients, retry/backoff, worker process, Redis-backed task queue and caching) but not full model lifecycle features like serialization or drift monitoring.
Evidence
promptum/src/promptum/providers/openrouter.py: robust retry/backoff, error classes, and metrics for inference API calls
deyna256/betterforces/backend/worker/main.py: async worker with rate limiting, Redis caching and task-status updates
Computational Efficiency
4/10
How efficiently computing resources are used
Practical efficiency and concurrency engineering (async I/O, semaphores, token-bucket rate limiter, non-blocking background tasks) but no GPU/quantization or low-level performance tuning.
Evidence
deyna256/betterforces/backend/worker/main.py: RateLimiter token-bucket implementation and async BLPOP loop
promptum/src/promptum/session/runner.py: semaphore-based concurrency limiting for parallel prompt execution
Research Depth & Innovation
2/10
Depth of research and new ideas
Engineering shows thoughtful design and test coverage around inference and retry strategies, but there is no evidence of original research, custom model layers, or reproduction of published ML papers.
Evidence
promptum/src/promptum/providers/openrouter.py: careful error taxonomy and retry exhaustion handling
promptum/tests/providers/test_openrouter.py: tests validating retry behaviors and delay calculations
Verified artifacts
Expertise
LLM• Senior
Industries
Education• Middle
Software• Middle
Technologies
Prompt Engineering
LLM
HTTPX
Claude• mentioned only
Claude Code• mentioned only
Litestar• mentioned only
OpenRouter• mentioned only
Rich• mentioned only
Recommendations
- Build LLM inference and evaluation tooling - expand promptum-style providers, structured validators, and automated comparison reports for hosted LLMs.
- Implement backend analytics services - develop additional metrics endpoints, background workers, and Redis-backed caching for data-heavy products.
- Integrate production observability - add structured logging, tracing, SLI/SLOs and incident dashboards for the worker and API processes.
- Extend benchmarking to experiment tracking - add run metadata export and lightweight experiment tracking (W&B/MLflow/Neptune integration) for repeatable comparisons.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: Medium API Engineer
Senior backend engineer focused on API-driven services and reliable async tooling with an emphasis on practical correctness and test coverage. The strongest proven skill is building robust async clients and orchestration of background work with retries and rate limiting, evidenced by promptum/src/promptum/providers/openrouter.py and betterforces/backend/worker/main.py. There is limited public evidence of large-scale distributed-system design, formal secrets management or platform-level deployment automation.
API Design
6/10
How well APIs are designed
API design shows deliberate choices for stale-vs-fresh data handling, background refresh with 202/task pattern, cache headers and clear error handling, but lacks an explicit versioning strategy, idempotency key standardization and advanced pagination patterns.
Evidence
deyna256/betterforces: backend/api/routes/abandoned_problems.py - stale-vs-fresh branching, AsyncTaskResponse 202 pattern and background enqueue
deyna256/betterforces: backend/api/routes/tags.py - similar stale handling and cache header usage
deyna256/betterforces: backend/api/routes/base.py - _cache_headers and staleness helpers
Data Layer & Database
5/10
Working with databases
Data layer uses parameterized SQL, careful NULL scanning and result mapping plus Redis caching and a Redis-backed task queue, but there is no visible migration history or explicit transaction boundary/isolation tuning in the sampled files.
Evidence
deyna256/ccr: internal/task/storage.go - Postgres queries, scanTask null-handling and Rows iteration
deyna256/betterforces: backend/worker/main.py - Redis caching of submissions with TTL and BLPOP queue consumption
deyna256/betterforces: backend/infrastructure/task_queue.py - Redis-based enqueue/get_task_status patterns
Scalability & Performance
6/10
Handling load and speed
Scalability and performance patterns are present: token-bucket rate limiter, worker queue with blocking pop, concurrency limits and retry/backoff implementations, but no load-testing artifacts or measured benchmarks were found.
Evidence
deyna256/betterforces: backend/worker/main.py - RateLimiter token-bucket and BLPOP worker loop
deyna256/promptum: src/promptum/session/runner.py - asyncio.Semaphore based concurrency limiting
deyna256/promptum: src/promptum/providers/openrouter.py - retry loop with configurable backoff and retry recording
System Architecture
6/10
Overall system structure
System architecture demonstrates layered separation (api / domain / infrastructure), dependency injection and clear service boundaries, enabling maintainability; it is not, however, evidence of distributed-system trade-offs like service discovery, multi-region replication or complex inter-service contracts.
Evidence
deyna256/betterforces: backend/api/deps.py - DI providers wiring data, redis and task queue
deyna256/betterforces: backend/domain/services - multiple metric service implementations separated from controllers
deyna256/betterforces: backend/infrastructure/codeforces_client.py - external API client isolated in infrastructure layer
Security & Auth
6/10
Protecting data and access
Good security hygiene in several places: parameterized SQL, bcrypt password tests, token-family tests and explicit error handling; secrets management and token lifecycle are exercised in tests but there is limited evidence of centralized secrets/rotation or a formal authz model.
Evidence
deyna256/ccr: internal/auth/service_test.go - bcrypt verification and refresh-token family tests
deyna256/ccr: internal/auth/middleware.go - auth middleware signatures and token extraction (auth boundary)
deyna256/ccr: internal/task/handler.go - input validation for time parsing and consistent error responses
Reliability & Observability
6/10
Stability and monitoring
Reliability and observability patterns are present: structured logging, graceful shutdown and signal handling, retries with backoff and metrics capture, along with comprehensive unit tests; there is no explicit evidence of integrated metrics/export pipelines, alerting or SLOs.
Evidence
deyna256/betterforces: backend/worker/main.py - signal handlers, logging and cleanup for graceful shutdown
deyna256/promptum: src/promptum/providers/openrouter.py - retry metrics collection and retry delay recording
deyna256/promptum: tests/providers/test_openrouter.py - tests validating retry and delay behaviour
Expertise
Backend AI & LLM• Middle
Go Development• Senior
Messaging & Real-time• Middle
Microservices & API Architecture• Senior
Industries
Artificial Intelligence• Middle
Education• Middle
Technologies
Python• Senior
Go• Senior
Node JS• Senior
PostgreSQL
Redis
Bcrypt
Chi
Asyncio
Pydantic
Async• mentioned only
Litestar• mentioned only
Rich• mentioned only
Recommendations
- Develop RESTful async Python services with background workers and Redis-backed task queues
- Build LLM integration layers and resilient HTTP clients with retry/backoff and metrics collection
- Implement Postgres-backed APIs and storage adapters in Go, including secure auth and attachment handling
- Own medium-scale API design and service boundaries where careful staleness, caching and background refresh patterns are required
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium App Engineer
App-focused Frontend Engineer (middle level) who excels at building stateful single-page applications and integrating typed API flows. The strongest proven skill is server-state and async discipline, evidenced by the typed api layer with token refresh and retry in deyna256/echo/web/src/lib/api.ts together with react-query usage in the feature hooks. There is limited public evidence of a custom component library, automated a11y testing, measured performance audits or SSR/backend architecture.
UI Component Architecture
3/10
How interface parts are built
Design tokens and utility/component classes exist in CSS, but there is little evidence of a deliberate React component library or advanced composition patterns authored here.
Responsive & Cross-browser
4/10
Works on all screens and browsers
Cross-browser and responsive basics covered via CSS variables, custom scrollbars, focus styles and PostCSS/Tailwind build config; no advanced container queries or i18n/RTL evidence.
Performance Optimization
4/10
Speed of the interface
Shows concrete async-state and network discipline (timeouts, aborts, retry/refresh flows) and client-side caching via react-query, but lacks measured performance artifacts or advanced bundle/splitting analysis.
Accessibility & Semantics
3/10
Usable for everyone
Basic accessibility considerations are present (focus-visible outline, prefers-reduced-motion), but there is little evidence of ARIA on custom widgets, keyboard handling or automated a11y checks in CI.
State Management & Data Flow
5/10
Managing data in the app
Clear server-state discipline and typed API layer: token refresh with retry and redirect, typed fetch helpers, and react-query invalidation are implemented and tested, showing pragmatic state and data-flow design.
UX & Visual Polish
4/10
Look and feel quality
Design tokens, animations and component utility classes show attention to visual polish and consistent styling, though there is limited evidence of skeletons, empty-state flows or perceptual-performance work.
Expertise
React• Middle
Frontend Architecture & Build Tools• Middle
Technologies
TypeScript• Middle
Zustand
Tailwind CSS
React.js
Vite
React Query
PostCSS
React Router
autoprefixer
Design• mentioned only
Recommendations
- Develop complex SPA features that require robust server-state handling, offline/resume flows and token refresh logic.
- Implement client-side integrations with third-party APIs and build GitHub Actions or developer tooling similar to the automation code present.
- Own a component system and a11y improvements - convert utility classes into documented React components with ARIA and keyboard deltas.
- Lead efforts to add measured performance work (bundle analysis, RUM, LCP/INP before-and-after) and CI a11y checks
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: