Ilia Ivanov
Python Developer
9+ years exp
9+ years ML exp
Solidity
SQL
TypeScript
Node JS
Python
Go
Lua
Rust
Data Layer & Database: 6/10
Security & Auth: 6/10
API Design: 5/10
Active 23 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic backend API engineer at a solid middle-to-senior level with repeated evidence of building and testing production HTTP services. The strongest proven skill is backend API and data-layer engineering, demonstrated by layered handlers → services code, sqlx-based queries with batched lookups and transactional flows (examples: services/listing.rs, services/user.rs and replace_profile_links/delete_account tests). The public code shows limited evidence of large-scale distributed architecture, sophisticated caching or formal runtime resilience frameworks beyond pragmatic rate limiting and background tasks.
Technical skills
Solidity
SQL
TypeScript• Junior
Node JS• Junior
Python• Senior • 9y+
Go• Senior • 8y+
Lua• Senior • 6y+
Rust• Senior • 3y+
Solidity
Infura
Node JS
Axios
Python
Asyncio
Flask• 9y+
Celery• 6y+
Django• 6y+
FastAPI• 6y+
Rust
Axum
SQLx
Tokio
Tracing
Serde
Reqwest
Anyhow
Databases
MySQL
SQLite
MariaDB• 9y+
RabbitMQ• 9y+
PostgreSQL• 7y+
ClickHouse• 6y+
ElasticSearch• 6y+
Redis• 6y+
Frontend
React.js
Vite
Tailwind CSS
Zustand
i18next
React Query
DevOps
CI/CD
Docker Compose
GitHub Actions
Docker• 9y+
Kubernetes• 7y+
Rest API• 7y+
AWS• 6y+
Nginx• 6y+
Web3
Arbitrum
Ethereum
QA
Pytest• 9y+
AI/ML
TensorFlow• 9y+
Timeline
Senior Backend Engineer (Python)
•
Senior
Product company
•
Contractor
Sole Python engineer for billing, subscriptions, authentication, and core payment/service logic for a social-media analytics product. Built a Redis+Lua sliding-window rate limiter tied to metering of paid requests. Implemented subscription and background autocharge flows using Stripe, and integrated PayPal and Doku. Migrated API authentication to rotating keys and contributed to search and database/service decomposition.
Python
FastAPI
Django
Celery
Redis
MariaDB
ElasticSearch
ClickHouse
AWS
Nginx
Lua
Docker
Kubernetes
Python Developer
•
Middle
Sber / SberDevices
•
Contractor
Worked on the Salyut voice-assistant team on configuration and maintenance of dialog scenarios for an ML engine. Delivered backend and internal tooling tasks and supported data workflows used for model training. Used Python to build and maintain services and integrations for the assistant platform.
Python
Docker
Rest API
PostgreSQL
Backend Developer (Python)
•
Middle
Terminal Solutions / CheckU
•
Full-Time
Developed backend microservices for an identity-verification product, focusing on REST APIs and database logic. Built document-image processing capabilities and created a custom E2E/integration test framework spanning many microservices to reduce manual verification effort. Trained and deployed an initial TensorFlow model for document classification and expanded the dataset.
Pythonsince 2017
Flask
MariaDBsince 2017
RabbitMQ
Pytest
TensorFlow
Dockersince 2017
Senior Backend Developer
Confidence: High API Engineer
A pragmatic backend API engineer at a solid middle-to-senior level with repeated evidence of building and testing production HTTP services. The strongest proven skill is backend API and data-layer engineering, demonstrated by layered handlers → services code, sqlx-based queries with batched lookups and transactional flows (examples: services/listing.rs, services/user.rs and replace_profile_links/delete_account tests). The public code shows limited evidence of large-scale distributed architecture, sophisticated caching or formal runtime resilience frameworks beyond pragmatic rate limiting and background tasks.
API Design
5/10
How well APIs are designed
API design shows consistent error mapping, pagination and filtering choices, and visibility/auth checks, but lacks an explicit versioning strategy or idempotency key framework.
Evidence
ku113p/pay-intern/backend/src/routes.rs: build_router + health endpoint wiring (handlers → services pattern)
ku113p/pay-intern/backend/src/error.rs: AppError → into_response mapping for consistent error contracts
ku113p/pay-intern/backend/src/services/listing.rs: get_feed implements pagination, filtering, search and visibility semantics
Data Layer & Database
6/10
Working with databases
Clear, repeated database care: parameterized queries, migrations in tests, use of transactions for multi-step updates, and hand-tuned SQL (json_each, ON CONFLICT) to avoid N+1 and enforce constraints.
Evidence
ku113p/pay-intern/backend/src/services/user.rs: replace_profile_links and delete_account use explicit transactions (begin/commit) and multi-table updates
ku113p/pay-intern/backend/src/services/listing.rs: complex queries using json_each, COUNT pagination and batched IN lookups to avoid N+1
ku113p/my-go-comeback/chapterts/02practice/03cryptoplatform/db/postgres.go: UpdatePrices uses NamedExec with ON CONFLICT upsert pattern
Scalability & Performance
4/10
Handling load and speed
Some scaling and performance attention is evident - batched lookups, tokio background tasks and pagination - but there is little evidence of caching strategies with invalidation, queue-based decoupling beyond basic background tasks, or measured tuning artifacts.
Evidence
ku113p/pay-intern/backend/src/services/listing.rs: batch-loading saved/interested state using single IN query to reduce N+1
ku113p/pay-intern/backend/src/services/application.rs: tokio::spawn used for fire-and-forget email sending
ku113p/pay-intern/backend/src/middleware/rate_limit.rs: global_rate_limiter middleware (tower_governor) present
System Architecture
5/10
Overall system structure
Code follows a deliberate layered architecture (handlers → services → models), environment-driven config parsing and migration-aware test harnesses, indicating pragmatic service decomposition and deploy-minded ops; full service mesh or multi-service contracts are not evidenced.
Evidence
ku113p/pay-intern backend structure in files under src/ (handlers, services, models) — e.g. services/listing.rs and handlers/*
ku113p/pay-intern/backend/src/config.rs: from_env helpers for env-driven configuration
ku113p/pay-intern/backend/src/services/* and sqlx::migrate!() calls in tests: migration-aware test setup
Security & Auth
6/10
Protecting data and access
Strong security-oriented choices: JWT handling with tests, refresh token lifecycle, input validation and SQL parameterization; shows token hashing and revocation flows plus rate limiting.
Evidence
ku113p/pay-intern/backend/src/auth/jwt.rs: encode/decode and tests for access/refresh tokens and hashing
ku113p/pay-intern/backend/src/auth/middleware.rs: request parts extraction for auth context (bearer token middleware)
ku113p/pay-intern/backend/src/services/user.rs: sanitization and link validation (reject javascript:), and deletion of refresh_tokens during delete_account
Reliability & Observability
5/10
Stability and monitoring
Reliability practices are present: structured tests (unit + integration using sqlite migrations), transactional operations, graceful shutdown hooks and tracing; retry/backoff patterns are used in test tooling but full-blown resilience patterns (circuit breakers, jittered backoff frameworks) are not widely present in service code.
Evidence
ku113p/pay-intern/backend/src/main.rs: graceful shutdown / shutdown_signal (server lifecycle)
ku113p/pay-intern/backend/src/services/*: numerous #[cfg(test)] integration tests using sqlx::migrate!() and ephemeral sqlite DBs
ku113p/pay-intern/tools/api-tests/test_jwt_session.py: request retry on 429 and timeout usage (operational test harness)
Expertise
Go Development• Middle
Databases & Vector Storage• Middle
Microservices & API Architecture• Middle
Industries
Professional Services• Middle
Technologies
Python• Senior • 9y+
Go• Senior • 8y+
SQL
MySQL
PostgreSQL• 7y+
Redis• 6y+
Rest API• 7y+
ClickHouse• 6y+
Docker Compose
Flask• 9y+
RabbitMQ• 9y+
GitHub Actions
FastAPI• 6y+
Tracing
CI/CD
Django• 6y+
SQLite
MariaDB• 9y+
AWS• 6y+
Docker• 9y+
Kubernetes• 7y+
ElasticSearch• 6y+
Nginx• 6y+
Asyncio
Celery• 6y+
Recommendations
- Lead development of Rust-based HTTP APIs that require careful DB transactions, auth, and pagination (work on handlers/services and sqlx migrations).
- Implement authentication/session lifecycle features such as refresh token rotation, token revocation and secure storage (work on auth/jwt.rs and auth middleware).
- Build and harden integration test suites and migration-driven CI pipelines that run ephemeral sqlite/postgres migrations (expand the existing sqlx::migrate!() patterns).
- Work on backend features that need careful DB queries and N+1 elimination (search, feeds, and batched JOINs), and implement caching strategies with invalidation where needed.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Game Developer
Confidence: Medium Generalist
A systems-focused generalist at a Middle level who independently ships cross-platform desktop utilities and small backend services in Rust. The strongest proven skill is native audio capture and processing with safe cross-thread handing and STT integration, evidenced by voicewedge's Recorder, downsampling and transcription handling (ku113p/voicewedge/src/audio.rs and src/main.rs). There is limited evidence of game-specific rendering/physics, large-scale engine design, profiler-driven optimizations or CI/build pipelines in the human-authored code.
Gameplay Systems & Mechanics
How game logic works
Not evidenced in public code
Graphics & Rendering
2/10
Drawing game visuals
Basic custom rendering for tray icons (pixel-level anti-aliased shapes and a 7-segment digit) implemented in Rust; not advanced GPU/shader work.
Physics & Math
2/10
Game physics and math
Simple DSP/math utilities - mono downmix and a window-averaging downsampler plus geometric helpers for icon rendering; no physics integrators or spatial partitioning.
Engine Proficiency
4/10
Skill with the game engine
Shows practical engine/framework proficiency - cross-platform platform-specific code paths, custom config resolution, system integration (hotkeys, tray), and server-side Axum + SQLx usage beyond default templates.
Performance & Frame Budget
3/10
Keeping the game smooth
Conscious concurrency and performance decisions - atomic flags, channels and background tasks are used; however there are no profiler-driven optimizations, zero-alloc hot paths, or advanced frame-budget analysis.
Content Pipeline & Tooling
3/10
Tools for game content
Basic content/tooling practices: TOML config with sensible defaults and OS-aware paths, database migrations run at startup; limited evidence of CI, import automation or complex pipeline tooling.
Expertise
Game Audio & Middleware• Middle
Technologies
Rust• Senior • 3y+
Tokio
Axum
Serde
Reqwest
Anyhow
SQLx
Recommendations
- Develop desktop audio tools and middleware - capture, processing, small DAW-style utilities or STT-assisted text tools (use existing voicewedge codebase).
- Build small-to-medium Rust backend services/APIs (Axum + SQLx) - contact forms, webhooks, message-forwarding microservices.
- Implement platform integration utilities that require careful OS handling - hotkeys, tray apps, clipboard/keyboard injection and single-instance guards.
- Work on audio pipeline tooling (CLI/daemon) integrating capture, lossless archiving and batch transcription where threading and I/O robustness matter.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium App Engineer
A pragmatic middle-level frontend/app engineer focused on API integration and SPA state flows rather than bespoke component systems. The strongest, proven skill is server-state and async discipline - specifically the axios client and refresh-token single-flight logic (ku113p/pay-intern/frontend/src/api/client.ts) and the useAuth hook that wires profile loading and logout behavior (ku113p/pay-intern/frontend/src/hooks/useAuth.ts). There is little public evidence of dedicated component-system design, automated a11y testing, performance benchmarking, or broad test coverage for frontend UI code.
UI Component Architecture
2/10
How interface parts are built
Minimal evidence of deliberate UI component architecture; mostly API/hooks and a template-based UI.
Responsive & Cross-browser
1/10
Works on all screens and browsers
Responsive/cross-browser work is only implied by tooling and templates (viewport/meta plus Tailwind in deps) rather than bespoke responsive architecture.
Performance Optimization
3/10
Speed of the interface
Some measured-minded optimizations at the request/state level (deduplicated token refresh) but no evidence of broader performance measurement or advanced bundling tuning.
Accessibility & Semantics
2/10
Usable for everyone
Basic a11y/semantics appear in template pages (lang, skip-link), but no evidence of active accessibility engineering on custom widgets or automated a11y tooling in CI.
State Management & Data Flow
4/10
Managing data in the app
Strongest area — server-state discipline and async flow handling are deliberate (axios interceptors, single-flight refresh, logout fallback); shows awareness of race conditions and shared state coordination.
UX & Visual Polish
2/10
Look and feel quality
Visual polish comes mainly from templates; there are reasonable skeleton/styles in shared CSS files but few custom UX patterns, undo/rollback flows, or measured perceived-performance improvements in human-authored code.
Expertise
React• Junior
Modern Web Frameworks• Junior
HTML & CSS• Junior
Industries
Education• Junior
Software• Junior
Technologies
TypeScript• Junior
Node JS• Junior
Zustand
Tailwind CSS
React.js
Vite
React Query
Axios
i18next
Tooling• mentioned only
Recommendations
- Use this developer to implement and harden SPA auth flows and API clients (token refresh, retry, request queuing, request cancellation).
- Assign them to build or extend data-driven pages and hooks where server-state consistency and race handling matter (feeds, listings, profile sync).
- Pair them with a dedicated UI/component designer to convert template-driven pages into a composable component library and add accessible custom widgets.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: