Azat Alibayev
Backend Developer
14+ years exp
JavaScript
Java
Solidity
Kotlin
TypeScript
Python
SQL
API Design: 6/10
Scalability & Performance: 6/10
Reliability & Observability: 6/10
Active 17 days ago
+82 (10) 96215665 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A protocol-focused smart-contract engineer at a senior (mid-senior) level who designs and tests custom on-chain token economics. The strongest proven skill is DeFi protocol design - evidenced by Reserve.redemptionSignal/quoteRedeem, PrimeMarket emission math, and the extensive invariant and break tests in Solidus.t.sol. What is not evidenced publicly here is frontend UX, multi-repo production orchestration (CI/CD beyond scripts), or formal audit reports and on-chain governance controllers.
Technical skills
JavaScript
Java
Solidity• Senior
Kotlin• Middle • 14y+
TypeScript• Middle • 3y+
Python• Senior • 3y+
SQL
Java
Spring Boot• 12y+
Kotlin
Kotlin Coroutines
kotlinx.serialization
MockK
Python
Asyncio
Celery
Django• 3y+
FastAPI• 3y+
Databases
MongoDB
PostgreSQL• 3y+
Redis• 3y+
Mobile
Reactive Programming
JUnit
Repository Pattern
DevOps
Git
Prometheus
WebSockets
AWS• 3y+
CI/CD• 3y+
Docker• 3y+
GitHub Actions• 3y+
Rest API• 3y+
Web3
Foundry
Smart Contracts
DeFi
Ethereum
Frontend
Angular
Next.js• 3y+
React.js• 3y+
Timeline
Backend / Fullstack Developer
•
Middle
Freelance
•
Freelance
Developed web applications, integration platforms, and internal services end to end, covering architecture, databases, deployment, and production support. Built a messaging aggregation platform supporting Telegram and WhatsApp, designed multi-user REST APIs, and implemented commercial apps using Django/FastAPI with React and Next.js. Performed external API, payment system, and AI-service integrations, and set up containerization, CI/CD, and automated deployments.
Python
Django
FastAPI
PostgreSQL
Redis
React.js
Next.js
TypeScript
Docker
AWS
GitHub Actions
Kotlin
Spring Boot
CI/CD
Rest API
Automation Engineer
•
Middle
Schneider Electric
•
Full-Time
Implemented, configured, and maintained industrial automation systems, including integration of equipment. Conducted diagnosis of software and hardware complexes and supported industrial networks and related protocols. Worked on commissioning and ongoing technical support for automation and integration tasks in industrial environments.
Senior Backend Developer
Confidence: High API Engineer
A backend-focused engineer who designs and implements asynchronous, event-driven services with LLM and TTS integration at a solid mid/senior level. The strongest proven skill is building reliable concurrency-oriented pipelines (LLM -> TTS -> broadcast) as implemented in backend/runtime/builder.py and backend/runtime/dispatcher.py. Public code lacks deep database schema evolution artifacts, advanced auth lifecycle management, and multi-service production operationalization evidence.
API Design
6/10
How well APIs are designed
API surface shows deliberate design: auth via API token, idempotency support, rate limiting with Redis fallback, clear WebSocket contract and metrics endpoint. Error contracts use HTTPException and pydantic validation; idempotency and rate limiting are implemented rather than scaffolded.
Data Layer & Database
3/10
Working with databases
Minimal direct data-layer engineering is visible in the human-authored files - there is integration points and checks for Mongo/Celery, but no migration history or explicit transaction isolation handling in the analyzed human files.
Scalability & Performance
6/10
Handling load and speed
Concrete concurrency and scalability measures: worker pool, semaphores to limit concurrent LLM/TTS calls, buffers and backpressure, requeueing and retry/backoff strategies, and metrics hooks for latency observation.
System Architecture
5/10
Overall system structure
Reasonable modular decomposition within a single service - clear separation of event producers, LLM client, builder, dispatcher, buffers and transport; lifecycle management using a FastAPI lifespan. Not evidence of multi-service boundaries or cross-service contracts, but architectural choices are deliberate.
Security & Auth
4/10
Protecting data and access
Basic security practices are present - API token checks, token extraction for WebSocket, idempotency handling and environment-driven configuration. No advanced auth lifecycle (refresh/revocation) or security hardening artifacts in the human-authored files analyzed.
Reliability & Observability
6/10
Stability and monitoring
Good reliability and observability: structured logging helpers, Prometheus metrics endpoint, retries with exponential backoff, a circuit-breaker pattern for LLM failures, lifecycle shutdown handling and ack/timeouts for in-flight messages.
Verified artifacts
Expertise
Backend AI & LLM• Middle
Python• Middle
Industries
Media & Entertainment• Middle
Technologies
Python• Senior • 3y+
Java
MongoDB
PostgreSQL• 3y+
Redis• 3y+
Rest API• 3y+
Spring Boot• 12y+
GitHub Actions• 3y+
FastAPI• 3y+
Prometheus
WebSockets
CI/CD• 3y+
Django• 3y+
Git
AWS• 3y+
Docker• 3y+
Asyncio
Celery
MySQL• mentioned only
Rest API• mentioned only
Recommendations
- Develop real-time LLM-driven features and streaming endpoints (WebSocket-based) - e.g., live avatar voice/gesture pipelines.
- Implement and harden backend components that require concurrency control, rate limiting and idempotency (worker pools, semaphores, backlog management).
- Work on integrations between LLMs, TTS providers and persistence layers with observability and retry/circuit-breaker policies.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Blockchain Developer
Confidence: High Protocol Engineer
A protocol-focused smart-contract engineer at a senior (mid-senior) level who designs and tests custom on-chain token economics. The strongest proven skill is DeFi protocol design - evidenced by Reserve.redemptionSignal/quoteRedeem, PrimeMarket emission math, and the extensive invariant and break tests in Solidus.t.sol. What is not evidenced publicly here is frontend UX, multi-repo production orchestration (CI/CD beyond scripts), or formal audit reports and on-chain governance controllers.
Smart Contract Development
5/10
Writing smart contracts
Solid, custom smart-contract work: multiple upgradeable contracts, custom ERC20-like token, custom errors, and deliberate gas/logic choices beyond boilerplate. Evidence shows end-to-end protocol components (token, market, reserve) implemented with careful boundary checks and explicit invariants, but not a large multi-repo system-design footprint that would justify staff+ ratings.
Evidence
src/PrimeMarket.sol:_quotePrime and _emitPrime - custom emission/saturation math and cap gating
src/FlowToken.sol:_transferWithProtocolFee - protocol fee, service-wallet logic, activity tracking
src/Reserve.sol:_redeemPrime - block-budget accounting and pro-rata redemption burn logic
Security & Audit
6/10
Checking contracts for flaws
Clear security awareness and test-driven hardening: explicit reentrancy/mutex guards, protocol pause/freeze/ownership checks, and many unit/invariant tests exercising attacker-like edge cases. Not a substitute for a formal audit report, but demonstrates active adversarial testing and appropriate protections where needed.
Evidence
src/PrimeMarket.sol:nonReentrant modifier and settlingOrder flag in buyPrimeFromUser to avoid reentrancy during P2P settlement
src/FlowToken.sol:service-wallet protections, reserveTransfer guard and inactivity/pressure anti-grief checks
test/Solidus.t.sol:extensive invariant and break tests (e.g. testBreak_BlockBudgetCannotOverburnPrime, testFuzz_QuoteRedeemNeverExceedsBudget)
Blockchain Protocol Understanding
5/10
Knowing how blockchains work
Strong EVM/protocol understanding visible in block-vs-timestamp handling, per-block budgets, supply ratios, and gas-aware design choices. The code reasons about block.number vs timestamp, on-chain budgets and supply caps, showing a good practical grasp of EVM semantics.
Evidence
src/Reserve.sol:releaseBlock/releasedInBlock logic and quoteRedeem budget calculations
src/FlowToken.sol:use of block.timestamp for inactivity and lastPressureBlock to prevent same-block abuse
src/PrimeMarket.sol:_quotePrime saturation loop and emissionSupply calculations
DApp & Web3 Integration
3/10
Connecting apps to blockchain
Basic integration considerations for indexing and UX signals - events and enumerable orders are provided so a front-end/indexer can work reliably, but there is little user-facing/web3 UX code in this set. Transaction lifecycle handling (nonce/replacement/receipt) and wallet UX are not present here.
Evidence
src/PrimeMarket.sol:PrimeSellOrder/PrimeOrder structures and PrimeSellOrderPlaced/PrimeSellOrderCancelled events for on-chain indexing
src/FlowToken.sol:TransferFeePaid and ActivityRefreshed events to signal state changes to off-chain consumers
Tokenomics & DeFi Logic
7/10
Token and finance logic
Strong, original tokenomics and DeFi logic: dual-signal redemption, per-block release budgets, emission saturation curve with excluded supply, pro-rata floors, scarcity factor and many tests validating economic invariants and edge cases. This is the strongest area and shows deliberate economic design and extensive scenario testing.
Evidence
src/Reserve.sol:redemptionSignal, linearPayoutPerPrime, quoteRedeem and quoteRedeemBurn implement dual-signal (AR + scarcity) redemption and budget gating
src/PrimeMarket.sol:_quotePrime implements emission saturation, emissionExcludedSupply and availableCap guards
test/Solidus.t.sol:multiple BREAK tests (e.g. testBreak_EmissionRestartsAfterMintBurnCycle, testBreak_ProRataPowerReplacesHardPerPrimeCap, testBreak_ReserveHalfLifeUnderScarcity)
Decentralization & Trust Model
4/10
Designing trust without middlemen
Basic decentralization and governance primitives are present - ownership transfer/acceptance and pause/freeze upgrade gates exist - but the trust model is still centralized (owner-managed config, upgradeability) and there is limited on-chain governance or multisig automation shown in these human-authored files.
Evidence
src/FlowToken.sol:setServiceWallet and configureProtocol show owner-controlled configuration and permanent service-wallet protections
test/Solidus.t.sol:testOwnership demonstrates explicit ownership transfer and accept flow
Expertise
DeFi & Decentralized Finance• Senior
Ethereum & EVM Development• Senior
Technologies
DeFi
Solidity• Senior
Foundry
Smart Contracts
Ethereum
Base• mentioned only
Flow• mentioned only
Recommendations
- Lead development of on-chain monetary primitives and token-economy protocols (emission, redemption, reserve mechanics) where economic reasoning is central.
- Author and own formal audits and adversarial/fuzz testing suites (build Echidna/Slither CI and attacker contracts around the reserve and market flows).
- Design upgradeable protocol deployment and multisig/Timelock governance integrations (transfer ownership flows to multisig and document trust assumptions).
- Collaborate with front-end/indexer engineers to design event schemas and subgraph mappings for reliable UX and analytics.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Mobile Developer
Confidence: Medium Generalist
A Kotlin backend generalist at a competent middle level who reliably implements coroutine-based concurrency, native bindings and server APIs. The strongest proven skill is building coroutine-driven native integrations and real-time message handling as seen in the Telegram TDLib integration (integrations/telegram_user/TelegramTdlibClient.kt and TelegramUpdateHandler.kt). There is little to no evidence of mobile-platform work - no mobile UI, permission flows, background scheduling for mobile, offline-first sync engines with migrations, or release/store tooling are present in public code.
Platform Native Mastery
2/10
Knowing the mobile platform
Shows structured concurrency with Kotlin coroutines (CoroutineScope + SupervisorJob), explicit cancellation and coroutine-based workers in a native-integration backend - but no evidence of mobile lifecycle (process death / state restoration) handling.
Evidence
Wezzer42/message_aggregator/src/main/kotlin/integrations/telegram_user/TelegramUpdateHandler.kt: CoroutineScope(SupervisorJob() + Dispatchers.IO) and scope.cancel()
Wezzer42/message_aggregator/src/main/kotlin/integrations/telegram_user/TelegramSessionWorker.kt: usage of CoroutineScope, Job, Channel and launch (worker concurrency)
Wezzer42/message_aggregator/src/main/kotlin/integrations/telegram_user/TelegramTdlibClient.kt: suspend functions with suspendCoroutine and runBlockingSendRaw bridging async callbacks
Mobile UI/UX & Responsiveness
Smooth mobile experience
Not evidenced in public code
Performance & Battery
1/10
Speed and battery use
Basic performance-conscious patterns (local caches, bounds checking, limited file IO safeguards, synchronized access) are present, but no mobile-specific battery or measured performance work.
Evidence
Wezzer42/message_aggregator/src/main/kotlin/integrations/telegram_user/TelegramTdlibClient.kt: userNameCache/chatNameCache, bounds checks for list limits, ensureFileAvailable() with filesystem checks
Wezzer42/message_aggregator/src/main/kotlin/core/InboxMessageStore.kt: synchronized(lock) for thread-safe in-memory collections
Wezzer42/REST_service/src/main/kotlin/com/example/taskcatalog/repository/JdbcTaskRepository.kt: pagination SQL with LIMIT/OFFSET and use of GeneratedKeyHolder
Offline & Data Sync
Working offline and syncing
Not evidenced in public code
Device Integration
Using device features
Not evidenced in public code
Release & App Lifecycle
Building and publishing apps
Not evidenced in public code
Industries
Internet Services• Middle
Travel & Tourism• Middle
Technologies
Kotlin• Middle • 14y+
JUnit
Kotlin Coroutines
MockK
kotlinx.serialization
Repository Pattern
Reactive Programming
Spring Boot• mentioned only
Recommendations
- Use the developer to build backend services that integrate native libraries and real-time message pipelines (TDLib-style adapters, webhooks, worker systems).
- Assign them to implement server-side components that need coroutine-based concurrency, streaming or reactive adapters and robust integration tests.
- Have them lead migration from in-memory stores to persistent storage (Postgres/Flyway) and implement idempotent session/persistence with proper error handling and data migrations.
- Engage them to harden production-readiness: add observability (metrics/log correlation), resource lifecycle management, and safe native library loading/retry strategies.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: