Evgeniy Tihonenko
Python Developer
5+ years exp
Node JS
TypeScript
Python
SQL
API Design: 6/10
Data Layer & Database: 6/10
Security & Auth: 6/10
Active 15 days ago
+7 (901) 3816914 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic backend engineer at a senior level who repeatedly ships API services, LLM integrations and device-sync logic with substantial test coverage. The strongest proven skill is building resilient AI-backed service paths and integration guards (timeouts, hedges, retries, quota and streaming) evidenced by llm transport tests, hedge/timeouts in server code and background parse adoption logic (relo_dojo llm tests, Driftora backgroundParses and llm/transport tests). Code shows careful DB migration and encryption work but lacks public evidence of large-scale distributed systems (multi-region, service mesh) or infra-level SRE artifacts.
Technical skills
Node JS• Middle
TypeScript• Middle
Python• Senior • 5y+
SQL• Middle • 5y+
Node JS
Express
Python
Django
Django REST Framework
Alembic
Asyncio
HTTPX
Pydantic
Boto3
Flask• 5y+
FastAPI• 4y+
Celery• 3y+
SQLAlchemy• 3y+
Databases
Apache Kafka
ClickHouse
SQLite
MySQL• 5y+
PostgreSQL• 5y+
RabbitMQ• 4y+
Redis• 4y+
ElasticSearch• 3y+
AI/ML
OpenAI SDK
LLM
Frontend
React.js
i18next
DevOps
Docker
Kubernetes
Docker Compose
Rest API• 5y+
Jenkins• 4y+
Bitbucket• 3y+
QA
Pytest
Timeline
Python Backend Developer
•
Middle
AV Soft
•
Full-Time
Developed and maintained Python components for corporate email security. Implemented checks for incoming messages, including phishing URL detection, attachment analysis, and sender reputation control, while enforcing email security standards such as SPF, DKIM, DMARC, TLS and related policies. Integrated filtering with mail gateways and logging/monitoring, and tuned rules after incident analysis. Delivered improvements including LLM-based typosquatting detection and restored malicious link detection using regular expressions.
Python
LLM
Python Backend Developer
•
Middle
Stratosfera
•
Full-Time
Designed and developed backend services for a monolithic CRM in a microservices architecture using FastAPI. Integrated external systems via REST APIs and event-driven RabbitMQ, and optimized performance with PostgreSQL, Redis, and Elasticsearch while supporting the release cycle. Improved SQL query efficiency after upgrading SQLAlchemy and reduced response time with REST endpoint refactoring and caching. Built resilient async integrations, state-driven workflows, Elasticsearch indexing with Celery synchronization, and migrated heavy tasks into background jobs.
Python
FastAPI
Rest API
RabbitMQ
PostgreSQL
Redis
ElasticSearch
Celery
SQLAlchemy
Bitbucket
Jenkins
Python Developer
•
Middle
GeekBrains
•
Full-Time
Worked on a backend platform for online learning, building asynchronous REST APIs in FastAPI for student-teacher interactions. Optimized PostgreSQL queries using indexes and SQL rewrites, including removal of N+1 query patterns. Implemented background task processing with RabbitMQ to move long-running operations such as notifications and mailings out of the main request flow. Used Redis for session and token storage and contributed to PostgreSQL database schema design and migrations.
Python
FastAPIsince 2022
Rest API
PostgreSQLsince 2022
RabbitMQsince 2022
Redissince 2022
Python Developer (Backend)
•
Middle
Individual Entrepreneur
•
Full-Time
Developed and maintained a website backend in Python using Flask. Built a REST API covering authentication and authorization, content management features, and an administrative panel. Designed the backend architecture and MySQL database schema, then optimized SQL queries and server-side logic to improve application response times. Implemented core production features such as user authentication, article publishing, and admin content control without developer intervention.
Pythonsince 2021
Flask
Rest APIsince 2021
MySQL
Middle Backend Developer
Confidence: High API Engineer
A pragmatic backend engineer at a senior level who repeatedly ships API services, LLM integrations and device-sync logic with substantial test coverage. The strongest proven skill is building resilient AI-backed service paths and integration guards (timeouts, hedges, retries, quota and streaming) evidenced by llm transport tests, hedge/timeouts in server code and background parse adoption logic (relo_dojo llm tests, Driftora backgroundParses and llm/transport tests). Code shows careful DB migration and encryption work but lacks public evidence of large-scale distributed systems (multi-region, service mesh) or infra-level SRE artifacts.
API Design
6/10
How well APIs are designed
APIs are intentionally designed with dependency-injected auth/rate-limit guards, consistent router/endpoint structure, streaming endpoints and explicit error contracts; versioning/long-term compatibility is present in schemas and guarded by tests but explicit semantic-versioning of APIs is not visible. Idempotency and quota-driven behaviors are implemented for LLM/AI paths.
Evidence
relo_dojo/backend/app/main.py - endpoints (check, exercise, explain_stream, translate)
relo_dojo/backend/app/deps.py - auth, per-endpoint rate-limiters (llm_rate_limit, voice_rate_limit)
relo_dojo/backend/app/routers/*.py - modular router decomposition (auth.py, voice.py, billing.py)
Data Layer & Database
6/10
Working with databases
Substantial database work with an alembic migration history, idempotent on-device migrations, transactional backup/import, schema-consistency tests and conscious dedup/row-lock patterns; schema evolution is visible and tested. There are clear transaction boundaries and tests exercising migration/consistency, but explicit comments about isolation levels are absent.
Evidence
Driftora/lib/core/db/init.ts - MIGRATIONS (idempotent ALTERs) and INIT_SQL
relo_dojo/backend/alembic/versions/* - multi-file alembic migration chain (0001_initial .. 0018_miss_log)
Driftora/__tests__/schemaConsistency.test.ts - schema-consistency checks between DDL and drizzle schema
Scalability & Performance
5/10
Handling load and speed
Performance and scalability concerns are actively addressed: hedged LLM/photo hedging, explicit timeouts, retry tests and client pooling; caching and label-cache hits are implemented. There is solid engineering for reducing latency of expensive providers, though large-scale load-testing or multi-region architecture artifacts are not present.
Evidence
PR notes and code references for VISION_HEDGE_MS and REASONING_EFFORT_* (server perf/hedge adjustments described in commit messages and llm tests)
relo_dojo/backend/app/services/http_client.py - pooled httpx client and TIMEOUT constants
relo_dojo/backend/tests/test_llm_transport.py - retries, backoff and transport resilience tests
System Architecture
5/10
Overall system structure
Clear module boundaries (mobile/frontend, food-parse stateless service, sync-server, LLM service, lawdocs) and thoughtful decomposition; feature flags and opt-ins for device imports and AI consent show deliberate resilience and graceful degradation. It's not a large microservice mesh with service discovery or complex inter-service contracts, but the multi-repo modular split is meaningful and pragmatic.
Evidence
Driftora/server (stateless food-parse) - separate package.json and service description
Driftora/sync-server - separate FastAPI-based sync server and requirements
modules/platform-key-store and mobile vs server separation in project layout (package.json files)
Security & Auth
6/10
Protecting data and access
Security work is visible and concrete: E2EE primitives, master-key custody hooks, PRNG fix for backup, fail-closed DB open, token sealing with Fernet and tests for token expiry. Input validation and quota/consent gates are enforced. A full dependency-supply-chain audit is not present in the files, but the code shows active security hardening and thoughtful privacy opt-ins.
Evidence
Driftora/lib/core/crypto/e2ee.ts and lib/core/crypto/recovery.ts - E2EE and recovery flow (tweetnacl usage, installExpoCryptoRng)
relo_dojo/backend/app/core/fernet.py and app/services/tokens.py - Fernet-based sealing and token handling
Driftora PR notes and server/server fixes: 'fail-closed' DB fallback, multer limits, FatSecret timeout in security audit notes
Reliability & Observability
6/10
Stability and monitoring
Reliability practices are present: timeouts, hedged retries, explicit background adoption/retry for long-running parses, uptime check workflow, structured tests for transient LLM errors and retry clauses. Observability hooks and /metrics mentions exist, with test coverage for failure modes. Full SLO/alerting configuration is not visible, but engineering for graceful failure and retries is strong.
Evidence
Driftora PR notes: uptime-monitor GH Action (.github/workflows/uptime.yml) and /metrics stage additions
Driftora/lib/core/services/backgroundParses.ts - background adoption, retries and sweep logic
relo_dojo/backend/tests/test_llm_transport.py - explicit retry/timeout tests and transport resilience
Expertise
Backend AI & LLM• Middle
Python• Middle
Microservices & API Architecture• Middle
Node.js• Middle
Technologies
SQLite
HTTPX
Recommendations
- Develop LLM-backed stateless microservices that require robust provider hedging and quota enforcement (work on reasoning/vision hedging, retries and quota endpoints).
- Implement secure device-sync and E2EE features for consumer health apps - extend the keystore & background-sync patterns to server-side dedup and idempotent import pipelines.
- Lead API design and schema evolution efforts - own migration chains, idempotent DB migrations and schema-consistency testing for product-facing APIs.
- Improve observability by adding concrete SLI/SLO mappings and alerting playbooks to the existing /metrics and uptime checks (turn the observed metrics into operational runbooks).
Middle Frontend Developer
Confidence: High App Engineer
An experienced mobile/app engineer (senior-level by demonstrated system and domain work) who builds production-grade, stateful Expo/React Native applications with a strong focus on data integrity and device integrations. The strongest proven skill is designing robust client-server state flows and data hygiene - concrete artifacts include idempotent DB migrations (lib/core/db/init.ts), health/workout sync with dedupe and tombstone handling (lib/core/db/healthSync.ts + __tests__/healthSync.test.ts) and a background-parse lifecycle (lib/core/services/backgroundParses.ts). Public code shows limited evidence of a reusable cross-platform component library or formal CI a11y tooling and no large-scale backend system-design papers, so domain breadth (beyond mobile + nutrition/health + adaptive LLM paths) is not evidenced.
UI Component Architecture
4/10
How interface parts are built
Component boundaries and theming show deliberate composition (theme provider, token-driven visuals and isolated UI pieces), but much of the UI surface is standard Expo/React patterns rather than a bespoke component system or published design-system library.
Evidence
mobile/theme/theme.ts: ThemeProvider + makeTheme (theme tokens and provider abstraction)
components/WorkoutSection.tsx: separate workout chip strip + shared describeWorkout (mentioned in PR notes)
components/ui/waveformBuffer.ts: isolated UI utility for audio waveform rendering
Responsive & Cross-browser
4/10
Works on all screens and browsers
Mobile-first responsive decisions, platform-specific health integrations and explicit Reduce-Motion handling show attention to cross-device behavior; there is less evidence of advanced responsive web features (container queries / RTL testing) because this is an Expo mobile codebase.
Evidence
mobile/README.md: managed Expo workflow and platform guidance (iOS / Android specifics)
lib/theme/motion.ts: motion timing + prefers-reduced-motion handling referenced in design notes
lib/core/services/deviceHealthService.ts: platform-specific code paths for iOS (HealthKit) and Android (Health Connect)
Performance Optimization
6/10
Speed of the interface
Measured performance work is clearly present - hedged parallel calls, tuned timeouts, caching for label reads, server-side hedges and an uptime watcher indicate systematic performance engineering and cost-aware LLM usage.
Evidence
server/package.json + server code paths referenced in PRs: stateless food-parse service with timeouts and hedging (text/photo hedges)
.github/workflows/uptime.yml: uptime monitor introduced to measure visible wait time (mentioned in PRs)
lib/core/services/httpFoodParser.ts: explicit deriveEndpoint / quota capture / fallback logic (service-level request minimization patterns)
Accessibility & Semantics
4/10
Usable for everyone
Accessibility & semantics are considered (contrast fixes, hitSlop increases, reduced-motion in motion tokens and a11y roles in UI text), but there is limited evidence of automated a11y tooling in CI or deep custom aria-handling for complex custom widgets.
Evidence
lib/theme/motion.ts: Reduce Motion tokens and motion timing adjustments
design notes (design PR): contrast and hitSlop adjustments, a11y role notes and accessible touch targets
mobile/design_handoff_relo_dojo/README.md: mentions accessibility considerations as part of the redesign
State Management & Data Flow
6/10
Managing data in the app
Strong server-state and client-state discipline: idempotent DB migrations, explicit transactions for backups, background parse adoption/retry, device sync with dedup/tombstone rules and comprehensive unit tests showing careful race and edge-case handling.
Evidence
lib/core/db/init.ts: idempotent CREATEs + safe ALTER migrations and applySchema with duplicate-column handling
lib/core/services/backgroundParses.ts: registerInFlight / adoptOnUnmount / retryParse - background parse lifecycle
lib/core/db/healthSync.ts and __tests__/healthSync.test.ts: device workout import, merged-union window handling, tombstone dedupe and many coverage tests
UX & Visual Polish
5/10
Look and feel quality
UX details and visual polish are well thought-through (theme tokens, motion, refined strings, day/meal UX), and many edge states (pending parses, retry, offline fallbacks) are surfaced — good product polish without evidence of heavy design-system invention.
Evidence
lib/theme/motion.ts: motion system and reduce-motion control used for perceived performance
PR notes and app/food flow: background parse UX (“Разбирается…”, unconfirmed drafts with ≈ pill) and visible retry affordances
mobile/README.md & design handoff: new theme 'Millimeterka', typographic choices and working motion
Expertise
React• Middle
Industries
Education• Middle
Health Care• Middle
Technologies
TypeScript• Middle
Node JS• Middle
Express
React.js
i18next
Caddy• mentioned only
Recommendations
- Lead development of mobile apps that require reliable device-data sync and strong local-state integrity (device sensors, HealthKit/Health Connect integrations, offline-first sync).
- Implement and maintain LLM-assisted features where request hedging, quotaing and graceful fallbacks are required (photo/text parsing, server hedges, quota headers).
- Own the client-side nutrition/health calculations and UX: BMR/meal/workout pipelines and the day-budget flows, including tests and clinical-floor business rules.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior AI/ML Engineer
Confidence: Medium LLM Engineer
A pragmatic backend + LLM engineer at a solid middle level who builds FastAPI services, LLM inference/dispatch glue and document-generation pipelines. The strongest proven skill is building reliable LLM-integration and production backend plumbing, supported by app/services/llm.py and numerous integration tests (backend/tests/test_llm_dispatcher.py and backend/tests/test_generation.py). Little or no evidence exists of custom model training, formal ML experiment tracking, GPU/quantization optimizations, or novel research contributions in public code.
Model Architecture & Training
2/10
How well models are designed and trained
No evidence of custom model training or architecture work; the code provides LLM orchestration/dispatch, prompt handling and inference-time logic rather than training pipelines.
Evidence
backend/app/services/llm.py: LLMProvider.generate / _call_llm (provider abstraction, generate/review methods)
backend/scripts/test_gigachat_raw.py: raw LLM call script for exercising providers
Data Pipeline & Feature Engineering
3/10
How data is prepared for models
Reasonable data/feature engineering for form-driven legal flows - registry, field resolution and structured validation for many situation types, but not ML-centric data pipelines.
Evidence
backend/app/situations/registry.py: SituationRegistry.load (YAML-driven situation configs)
backend/app/services/field_resolve.py: resolve_field_value (field resolution logic used to build documents)
Experimentation & Evaluation
2/10
How results are measured and tested
Good unit and integration test coverage for backend flows and LLM dispatching, but no experiment tracking, run-history, or formal evaluation/ablation pipelines for ML experiments.
Evidence
backend/tests/test_llm_dispatcher.py: tests for provider selection and fallback
backend/tests/test_generation.py: integration tests around document generation and failure handling
MLOps & Deployment
3/10
How models are shipped to production
Production-minded backend deployment patterns - FastAPI app lifecycle, Alembic migrations, background loops and provider hedging/timeouts; solid engineering but no specialized MLOps infra (no model hosting, monitoring stacks or CI for models shown).
Evidence
backend/app/main.py: lifespan and background tasks (watchdog/refund/retention loops)
backend/alembic/versions/*.py: Alembic migrations present for schema management
Computational Efficiency
2/10
How efficiently computing resources are used
Some attention to efficiency at the infra level - async usage, async HTTP clients and provider orchestration/timeout logic - but no GPU/quantization/profiling or explicit inference-performance engineering.
Evidence
backend/app/services/llm.py: async code paths and provider orchestration leveraging asyncio / AsyncOpenAI/httpx
backend/app/main.py: async background tasks and non-blocking request handling
Research Depth & Innovation
1/10
Depth of research and new ideas
No visible original research, novel algorithms or paper implementations; the work is engineering-focused (legal templates, deterministic calculators and LLM glue) rather than research SOTA.
Evidence
backend/app/services/docgen.py: template-driven document generation (template selection and rendering)
backend/app/services/llm.py: prompt fill and templating helpers (fill_template)
Expertise
LLM• Junior
Legal AI & LegalTech• Junior
Industries
Artificial Intelligence• Junior
Professional Services• Junior
Software• Junior
Technologies
Python• Senior • 5y+
SQL• Middle • 5y+
MySQL• 5y+
PostgreSQL• 5y+
Redis• 4y+
Rest API• 5y+
ClickHouse
Docker Compose
Flask• 5y+
SQLAlchemy• 3y+
RabbitMQ• 4y+
FastAPI• 4y+
OpenAI SDK
Jenkins• 4y+
Django
Docker
Kubernetes
ElasticSearch• 3y+
Apache Kafka
LLM
Asyncio
Celery• 3y+
Pydantic
Django REST Framework
Boto3
Alembic
Bitbucket• 3y+
Recommendations
- Develop LLM-backed document generation and inference services - implement provider fallbacks, timeouts and structured template filling.
- Build secure backend APIs and document pipelines with FastAPI, Alembic migrations and robust async patterns (auth, background jobs and retries).
- Implement and harden E2EE and key-management flows (encrypt/decrypt, Fernet/Nacl) for applications requiring user-side privacy and secure backups.
- Integrate cloud storage and payment/document release flows (S3 via boto3, signed URLs, background generation pipelines) for production services.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: