Ivan Logvinov
Backend Developer
4+ years exp
4+ years ML exp
2+ projects
Java
Go
Node JS
PHP
TypeScript
Python
SQL
JavaScript
Kotlin
Data Layer & Database: 7/10
API Design: 6/10
Security & Auth: 6/10
Active 18 days ago
+7 (953) 4731944 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A backend API engineer at an early senior level who produces well-structured service code with deliberate transaction and concurrency controls. The strongest proven skill is data-layer design and concurrency control (row-level locking, skip_locked, migration history and transactional use-cases) as implemented in create_order.py, related infrastructure models and Alembic migrations. Public code does not show advanced operational artifacts like distributed queuing, caching/invalidation strategies or a multi-service production architecture.
Technical skills
Java
Go• Middle • 4y+
Node JS• Middle • 4y+
PHP• Junior • 4y+
TypeScript• Middle • 4y+
Python• Senior
SQL• Junior
JavaScript• Middle
Kotlin• Middle
Java
Testcontainers
Node JS
TypeORM
Express
Mongoose
Pino
PHP
Laravel• 4y+
Python
FastAPI
SQLAlchemy
Alembic
Asyncio
Pydantic
Kotlin
Ktor
Kotlin Coroutines
Kotlin Flow
Databases
Apache Kafka
MySQL
PostgreSQL• 4y+
RabbitMQ• 4y+
Redis• 4y+
MongoDB• 3y+ • 2 projects
Frontend
React.js
Mobile
Android
Android SDK
Jetpack Compose
Material Design
DataStore
Declarative UI
DevOps
CI/CD
Docker Compose
Git
Kubernetes
Rolling Update
Docker• 4y+
GitLab CI• 4y+
Rest API• 4y+
WebSockets• 4y+
Docker Swarm
GitHub Actions
Grafana
gRPC
Nginx
Prometheus
AI/ML
LLM
RAG• 4y+
Embeddings
QA
Jest
k6
Sentry
Vitest
Timeline
Backend Developer
•
Middle
Hermes LLC
•
Full-Time
Built and owned backend architecture and production processes for a platform with user/business accounts, chat, admin features, and LLM services. Organized a small backend team workflow (Jira, backlog, weekly sprints, prioritization, code reviews, onboarding, release rules) and led delivery through incidents and recovery. Delivered major performance and reliability improvements across gRPC migration, database query optimization, replica read consistency, websocket event delivery, background notifications, auth/RBAC, testing, and observability.
Go
JavaScript
TypeScript
Python
PostgreSQL
Redis
RabbitMQ
WebSockets
Rest API
gRPC
Docker
Docker Swarm
GitHub Actions
Testcontainers
Jest
Vitest
k6
Prometheus
Grafana
Sentry
Pino
Nginx
Jira
RAG
Embeddings
SQL
ВГУ
Bachelor's Degree •
Информатика и вычислительная техника
Backend Developer
•
Middle
iLink
•
Full-Time
Developed backend APIs, integrations, and background services for fintech, Web3, and corporate automation web and mobile platforms. Worked in multi-disciplinary teams with Scrum/Kanban, Jira, and GitLab merge requests, performing code reviews and collaborating with QA/PM/DevOps. Improved API throughput and response times, built async pipelines, redesigned webhook processing with idempotency and retries, migrated heavy report generation to a Go service, and reduced latency by replacing polling with websocket delivery.
Gosince 2022
PHP
Laravel
Node JS
TypeScriptsince 2022
PostgreSQLsince 2022
Redissince 2022
RabbitMQsince 2022
WebSocketssince 2022
Rest APIsince 2022
Dockersince 2022
GitLab CI
Jirasince 2022
Senior Backend Developer
Confidence: High API Engineer
A backend API engineer at an early senior level who produces well-structured service code with deliberate transaction and concurrency controls. The strongest proven skill is data-layer design and concurrency control (row-level locking, skip_locked, migration history and transactional use-cases) as implemented in create_order.py, related infrastructure models and Alembic migrations. Public code does not show advanced operational artifacts like distributed queuing, caching/invalidation strategies or a multi-service production architecture.
API Design
6/10
How well APIs are designed
API layer shows deliberate design with typed schemas, consistent error handling and non-trivial endpoints (filters, idempotent operation). Missing explicit API versioning strategy and documented idempotency key usage, but routes, pydantic schemas and error handlers are coherent.
Data Layer & Database
7/10
Working with databases
Strong data-layer evidence: Alembic migration history, explicit indexes/constraints, careful transaction boundaries, row-level locking (with_for_update + skip_locked) and tests checking SQL behavior.
Scalability & Performance
4/10
Handling load and speed
Some scalability-conscious decisions (DB indices, skip_locked ordering) and efficient queries, but no caching, no queue-based decoupling, nor documented rate-limiting or measured performance tuning artifacts.
System Architecture
5/10
Overall system structure
Clear module boundaries (domain/infrastructure/presentation/use-cases), config and logging middleware show deliberate structure. It's a single cohesive service - not a microservices landscape - but decomposition is purposeful and pragmatic.
Security & Auth
6/10
Protecting data and access
Authentication and input validation are implemented (Node.js chat app uses bcrypt + JWT, validation helpers). SQL usage and parameterization reduce injection risks; secrets appear handled via settings, though token lifecycle (refresh/revocation) is basic.
Reliability & Observability
6/10
Stability and monitoring
Reliability patterns are present: structured logging/middleware, explicit transaction handling with rollback on integrity errors, graceful shutdown hooks in the Node app, and idempotency tests. Missing are advanced retry/circuit-breaker implementations and full metrics/alerting artifacts.
Expertise
Python• Senior
Node.js• Middle
Messaging & Real-time• Senior
Microservices & API Architecture• Senior
Industries
Commerce• Senior
Manufacturing• Senior
Technologies
Python• Senior
Go• Middle • 4y+
Java
PHP• Junior • 4y+
SQL• Junior
MySQL
PostgreSQL• 4y+
Redis• 4y+
Rest API• 4y+
gRPC
Docker Compose
Laravel• 4y+
SQLAlchemy
RabbitMQ• 4y+
GitHub Actions
Docker Swarm
FastAPI
Prometheus
WebSockets• 4y+
GitLab CI• 4y+
CI/CD
Git
Docker• 4y+
Kubernetes
Nginx
Apache Kafka
Grafana
Asyncio
Testcontainers
Pydantic
TypeORM
Pino
Alembic
Rolling Update
Docker• mentioned only
Docker Compose• mentioned only
PHP• mentioned only
Rest API• mentioned only
Stack• mentioned only
WordPress• mentioned only
Recommendations
- Develop and own backend APIs that require strong DB consistency and concurrency control (inventory/reservation, financial ledgers).
- Implement real-time messaging features and WebSocket-based services, including end-to-end tests and auth flows.
- Build production-grade services with clear migration histories and transactional use-cases, including adding caching or async workers where appropriate.
- Expand observability and resilience work - add structured metrics, retries with jitter and documented SLA-aware timeouts.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium UI Engineer
A frontend-focused engineer at a solid junior-to-middle level who structures interactive browser modules and visualizations. The strongest proven skill is building interactive algorithm visualizations and deterministic UI state flows, evidenced by the modular renderer and model-normalizer (Algorithm-Visualizer/src/assets/js/renderers/flowchart-renderer.js and src/assets/js/engine/model-normalizer.js). The public code shows strong visual/CSS polish but lacks measurable performance work, comprehensive accessibility patterns, tests, and advanced server-state handling.
UI Component Architecture
4/10
How interface parts are built
Modular, purpose-driven UI code for a browser visualizer is present (separated renderer, model normalizer and renderers), but there is little evidence of a custom component library, design-token system or reusable framework-style components authored by the developer.
Evidence
Algorithm-Visualizer/src/assets/js/algorithm-renderer.js: createAlgorithmRenderer (separates render roots and frame rendering)
Algorithm-Visualizer/src/assets/js/engine/model-normalizer.js: normalizeUi/normalizeStep (centralized model normalization)
Algorithm-Visualizer/src/assets/js/renderers/flowchart-renderer.js: renderFlowchart/renderFlowchartNode (modular renderer functions)
Responsive & Cross-browser
3/10
Works on all screens and browsers
Uses modern CSS layout techniques (grid, clamp) and media queries for breakpoints, but there is no systematic feature-detection, RTL/i18n strategy, or evidence of advanced fluid typography/container-query usage.
Evidence
Algorithm-Visualizer/src/assets/css/algorithm-runtime.css: grid layouts, clamp() on .flowchart-svg height
GlowLang/styles/StartPage.css: media query @media (min-width: 0px) and (max-width: 1550px) and responsive rules
Performance Optimization
2/10
Speed of the interface
Some local perf-conscious choices (computing SVG bounds, mapping nodes to a Map) reduce wasted work, but there is no measured perf data, no bundle analysis, no code-splitting strategy or virtualization for large data shown.
Evidence
Algorithm-Visualizer/src/assets/js/renderers/flowchart-renderer.js: getFlowchartBounds and nodesById map usage (limits work to visible nodes)
Algorithm-Visualizer/src/assets/js/visualizer.js: single renderer instance and player subscription (minimizes re-init work)
Accessibility & Semantics
3/10
Usable for everyone
There are targeted accessibility touches - e.g., aria-label for the algorithm SVG and a normalized primaryAriaLabel - but accessibility coverage is sparse (no keyboard/focus handling of custom interactive widgets, and no CI/a11y tooling evident).
Evidence
Algorithm-Visualizer/src/assets/js/renderers/flowchart-renderer.js: <svg ... role="img" aria-label="Блок-схема алгоритма">
Algorithm-Visualizer/src/assets/js/engine/model-normalizer.js: normalizeUi includes primaryAriaLabel default
State Management & Data Flow
4/10
Managing data in the app
Clear client-side state discipline and deterministic flows - model normalization, explicit steps, and a subscribe-based player create predictable state transitions; there is no evidence of complex server-state handling (caching, optimistic updates, request cancellation).
Evidence
Algorithm-Visualizer/src/assets/js/visualizer.js: createAlgorithmModel + createAlgorithmRenderer + createPlayer and player.subscribe pattern
Algorithm-Visualizer/src/assets/js/algorithms/linear-search/linear-search-steps.js: buildLinearSearchSteps (produces deterministic step-by-step states)
Algorithm-Visualizer/src/assets/js/engine/model-normalizer.js: normalizeStep (explicit step shaping)
UX & Visual Polish
5/10
Look and feel quality
Strong visual polish and deliberate interaction design are visible - many CSS animations, hover/active states, and explicit empty-state content for the visualizer; however there is limited evidence of progressive loading skeletons, undo/rollback UX, or measured perceived-performance improvements.
Evidence
GlowLang/styles/mainMenuStyle.css: numerous animated states and interactive button styles
GlowLang/styles/level.css: animated decorations and task/answer UI states
Algorithm-Visualizer/src/assets/css/algorithm-runtime.css: well-structured runtime panels and runtime-empty placeholder
Verified artifacts
Expertise
HTML & CSS• Middle
Modern Web Frameworks• Middle
Frontend Architecture & Build Tools• Middle
Industries
Education• Middle
Technologies
JavaScript• Middle
Node JS• Middle • 4y+
Express
React.js
Mongoose
Recommendations
- Develop interactive, educational front-end features and visualizations (complex SVG/SVG-renderer work and deterministic UI timelines).
- Build SPA or static-site interactive modules where modular renderer + model normalization are needed (e.g., algorithm visualizers, interactive tutorials).
- Implement UI-heavy pages with rich animations and pixel-perfect CSS where close collaboration with designers is required.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Mobile Developer
Confidence: Medium Android Engineer
A pragmatic Android engineer at a lower-middle level who independently builds end-to-end Compose UIs and implements common device integrations. The strongest proven skill is Compose-based UI and adaptive layouts, evidenced by ScheduleApp (BoxWithConstraints adaptive layout, LazyColumn item implementations) and Theme/dynamic color usage. There is limited evidence of advanced platform resilience - no saved-state/process-death handling, no offline sync engine or measured performance work in public code.
Platform Native Mastery
3/10
Knowing the mobile platform
Solid practical use of Android lifecycle APIs and Compose primitives but no evidence of process-death handling, saved state restoration across kills, or structured concurrency patterns tied to lifecycle.
Mobile UI/UX & Responsiveness
4/10
Smooth mobile experience
Good Jetpack Compose UI and responsiveness - adaptive layout for wide screens, Material3 usage and dynamic color on Android 12+, LazyColumn for lists; mostly screen-level work without advanced accessibility or multi-window/foldable handling.
Evidence
TranquilDev/mobile-lab/app/src/main/java/com/example/task_tracker/MainActivity.kt:ScheduleApp (BoxWithConstraints adaptive layout, isWideScreen branch)
TranquilDev/mobile-lab/app/src/main/java/com/example/task_tracker/MainActivity.kt:LessonList / LazyColumn and LessonElement implementations
TranquilDev/mobile-lab/app/src/main/java/com/example/task_tracker/ui/theme/Theme.kt:dynamicDarkColorScheme / dynamicLightColorScheme usage
Performance & Battery
2/10
Speed and battery use
Some release-level build settings present (minify/shrinkResources) but no measured profiling, memory/jank fixes, or doze-aware background work; no evidence of performance benchmarking or targeted optimizations.
Offline & Data Sync
1/10
Working offline and syncing
Minimal offline/ sync work - a simple DataStore preference is used and a direct network request exists, but there is no local DB, migration history, queued offline operations, conflict resolution or idempotent retry logic.
Evidence
Device Integration
5/10
Using device features
Concrete device-integration work: runtime permission flows, sensor availability checks, launching other apps via package manager and an intent to accessibility settings - covers common edge paths but lacks full denial-rationale-dialog flows and testing for permission denial states.
Evidence
TranquilDev/mobile-lab/app/src/main/java/com/example/task_tracker/MainActivity.kt:PermissionsScreen (ActivityResultContracts, ContextCompat.checkSelfPermission)
TranquilDev/mobile-lab/app/src/main/java/com/example/task_tracker/MainActivity.kt:Sensor availability checks via SensorManager
TranquilDev/OzonAuto/app/src/main/java/com/example/ozonauto/MainActivity.kt:startActivity for external package + showAccessibilitySettings()
Release & App Lifecycle
3/10
Building and publishing apps
Basic release configuration and proguard usage are present but there is no CI/CD pipeline, automated rollout, crash reporting integration or signing/fastlane evidence.
Expertise
Android• Middle
Mobile UI/UX• Middle
Industries
Commerce• Junior
Technologies
Android
Kotlin• Middle
Jetpack Compose
Android SDK
Kotlin Coroutines
Ktor
Kotlin Flow
Declarative UI
DataStore
Material Design
Gradle• mentioned only
Recommendations
- Assign to build small-to-medium Android features using Jetpack Compose - screens, navigation, theming, and runtime permission flows.
- Have the developer implement simple networked features with retry/idempotency and local caching (DataStore -> Room or SQLDelight) to grow offline-first and sync skills.
- Avoid handing large-scale background sync, complex multi-process lifecycle bugs or release-ops ownership until experience with WorkManager/foreground services and CI/CD is demonstrated.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: