Firdavs Fayzullaev
AI Engineer
7+ years exp
5+ projects
Python
TypeScript
JavaScript
SQL
Node JS
Rust
API Design: 4/10
Reliability & Observability: 4/10
Active 1 day ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
Frontend app engineer (mid-level) focused on building React-based web and mini-app interfaces with integrated backend access and polished UX. The strongest proven skill is building SPA data flows and UX for commerce-style product/catalog experiences, evidenced by the Supabase-backed cart hook (steel-forge-cart/src/hooks/use-cart.ts) and the rich product UI (vezir-catalog/src/App.js). There is limited evidence of advanced server-state discipline, formal accessibility audits, or measured performance optimization in public code.
Technical skills
Python• Senior • 7y+ • 5+ projects
TypeScript• Senior • 7y+ • 5+ projects
JavaScript• Senior • 7y+ • 5+ projects
SQL• Senior • 7y+ • 5+ projects
Node JS• Senior • 7y+ • 5+ projects
Rust• Middle • 1 project
Databases
PostgreSQL• 7y+ • 5+ projects
Redis• 7y+ • 5+ projects
Supabase• 4y+ • 5+ projects
Frontend
Tailwind CSS
Vite
Three.JS
React Query
Zustand
React Hook Form
Zod
Recharts
React.js• 5y+ • 5+ projects
Next.js• 4y+ • 5+ projects
DevOps
Rest API
Docker• 7y+ • 5+ projects
Git• 7y+ • 5+ projects
Vercel• 4y+ • 5+ projects
QA
Jest
QA
AI/ML
PyTorch• 3y+ • 5+ projects
Transformers• 3y+ • 5+ projects
LLM• 3y+ • 5+ projects
RAG• 3y+ • 5+ projects
AI Agents• 3y+ • 5+ projects
Prompt Engineering• 3y+ • 5+ projects
Fine-tuning• 3y+ • 5+ projects
Whisper• 3y+ • 3 projects
Computer Vision• 2 projects
Ollama• 5+ projects
LangGraph• 3 projects
Middle Backend Developer
Confidence: Medium API Engineer
A practical backend-focused engineer at a middle level specializing in building REST APIs and integrations with model inference and hosted DBs. The strongest proven skill is delivering an end-to-end transcription API and its integration with a Telegram bot, evidenced by the FastAPI service that loads a Whisper model and the async bot handlers that call /api/transcribe. What is not evidenced is production-grade operational hardening at scale - e.g., robust secret management, distributed tracing, queue-based job orchestration or migration histories for complex schema evolution.
API Design
4/10
How well APIs are designed
Practical, conventional REST API design with clear endpoints and JSON error responses, but no explicit versioning, idempotency keys, or advanced contracts; input validation is basic.
Data Layer & Database
3/10
Working with databases
Reasonable data layer artifacts and typed DB schema for Supabase-backed app, seed scripts and upserts exist, but no migration chain, transactional boundaries, or explicit isolation-level handling shown.
Evidence
Firdavs39/steel-forge-cart/src/integrations/supabase/types.ts: typed Database schema and relationships
Firdavs39/steel-forge-cart/scripts/seed.js: Supabase upsert and insert flows for categories, products and product_sizes
Firdavs39/steel-forge-cart/src/hooks/use-cart.ts: Supabase CRUD usage for carts and product lookups
Scalability & Performance
3/10
Handling load and speed
Some performance awareness (model inference tuning and client-side perf hooks) and temporary-file cleanup, but no system-level scalability patterns (caching strategies, queueing, connection pooling or load-tested optimizations).
System Architecture
3/10
Overall system structure
Clear separation between services (API, bot, frontend) and modular code, but architecture remains small-scale and synchronous; no strong evidence of service decomposition trade-offs, config/secret management practices or graceful degradation patterns beyond basic error handling.
Security & Auth
2/10
Protecting data and access
Some use of environment variables and input constraints, but hardcoded secrets and limited defensive controls reduce security posture; there is awareness of hiding service keys in other places but not consistently applied in the visible code.
Reliability & Observability
4/10
Stability and monitoring
Good pragmatic reliability practices at application level: structured logging, try/except with cleanup, health endpoint and size checks; limited advanced observability (metrics, tracing, timeouts across outbound calls) but solid baseline handling of error and cleanup paths.
Expertise
Node.js• Middle
Backend AI & LLM• Middle
Microservices & API Architecture• Middle
Messaging & Real-time• Middle
Industries
Artificial Intelligence• Middle
Commerce• Middle
Technologies
Supabase• 4y+ • 5+ projects
Rest API
Recommendations
- Develop inference-backed APIs and integration glue for AI services (model serving, request validation, ephemeral file handling and postprocessing).
- Implement Supabase/Postgres-backed features for small e-commerce systems (cart flows, seed/migration scripts, typed DB clients).
- Build messaging integrations and automation (Telegram bots, async handlers, request size and retry policies).
- Harden production readiness: move secrets out of code, add containerization/CI pipelines, add metrics/tracing and background job queueing for long-running tasks.
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
Frontend app engineer (mid-level) focused on building React-based web and mini-app interfaces with integrated backend access and polished UX. The strongest proven skill is building SPA data flows and UX for commerce-style product/catalog experiences, evidenced by the Supabase-backed cart hook (steel-forge-cart/src/hooks/use-cart.ts) and the rich product UI (vezir-catalog/src/App.js). There is limited evidence of advanced server-state discipline, formal accessibility audits, or measured performance optimization in public code.
UI Component Architecture
4/10
How interface parts are built
Component boundaries and composition are present but mostly at app/page level; some bespoke components exist alongside heavy styling in single-file components and Tailwind tokens.
Evidence
vezir-catalog/src/App.js: CategoriesScreen, ProductsScreen and PremiumImage components composed in-file
steel-forge-cart/src/hooks/use-cart.ts: encapsulated cart logic as a custom hook
tailwind.config.js: design tokens and theme extension used across UI
Responsive & Cross-browser
5/10
Works on all screens and browsers
Responsive layouts and breakpoints are implemented with explicit media queries and Tailwind config; there is platform-aware handling for Telegram WebApp and mobile fallbacks.
Evidence
vezir-catalog/src/App.js: responsive CSS media queries and grid templates
tailwind.config.js: container and responsive screens configuration
miniapp/app.js: Telegram WebApp detection and fallback behaviors
Performance Optimization
4/10
Speed of the interface
Basic performance awareness is present (image loading states, web-vitals hook, requestAnimationFrame for 3D render), but no evidence of measured before/after profiling, advanced code-splitting or virtualization.
Evidence
vezir-catalog/src/reportWebVitals.js: web-vitals integration
vezir-catalog/src/App.js: PremiumImage with onLoad/onError and skeleton/spinner
3D/index.html: requestAnimationFrame-driven render loop and OrbitControls.use
Accessibility & Semantics
2/10
Usable for everyone
Minimal accessibility work is visible; components use semantic tags and alt attributes but lack explicit ARIA, keyboard focus management, or automated a11y CI checks.
Evidence
vezir-catalog/src/App.js: PremiumImage passes alt text and fallback UI
miniapp/app.js: use of button elements and readable labels for interactions
State Management & Data Flow
3/10
Managing data in the app
App-level state and server-data flows are implemented with custom hooks and Supabase types; there is error handling but no advanced server-state discipline (cancellations, optimistic rollback, or state machines).
Evidence
steel-forge-cart/src/hooks/use-cart.ts: full Supabase-backed cart hook with init, add/update/clear and error handling
steel-forge-cart/src/integrations/supabase/types.ts: generated typed DB schema used for correctness
steel-forge-cart/src/hooks/use-toast.ts: centralized toast hook for UX feedback
UX & Visual Polish
5/10
Look and feel quality
Strong visual polish and UX attention: animated UI, skeletons/loaders, rich product detail UI and Telegram miniapp interactions improve perceived performance and product experience.
Evidence
vezir-catalog/src/App.js: extensive visual styling, animations, skeleton loader and product detail UI
miniapp/app.js: cart UX, add-to-cart feedback and Telegram WebApp haptics integration
steel-forge-cart/miniapp/telegram-web-app-stub.js: development stub to preserve UX expectations outside Telegram
Expertise
React• Middle
PWA & Web APIs• Middle
Industries
Commerce• Middle
Technologies
Zustand
Tailwind CSS
Three.JS
React.js• 5y+ • 5+ projects
Vite
React Query
Zod
Recharts
React Hook Form
Recommendations
- Implement explicit server-state patterns (React Query mutation cancellations, optimistic updates with rollback) around the use-cart flows to reduce race conditions and improve UX.
- Split large visual pages into smaller components and add Storybook or unit/visual tests for key components (PremiumImage, product-card, cart) to improve maintainability.
- Add ARIA attributes, keyboard focus management and automated a11y checks (axe/eslint-plugin-jsx-a11y) for custom widgets and interactive flows.
- Introduce lightweight performance measurement (Lighthouse reports, bundle-analysis) and document before/after improvements for any major optimization.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle QA Engineer
Confidence: Medium Generalist
Middle-level frontend engineer focused on TypeScript-based e-commerce and catalog UIs. The strongest proven skill is schema-driven integration with Supabase and typed database contracts, visible in src/integrations/supabase/types.ts and the SQL migrations under supabase/migrations. Public code does not demonstrate mature automated test infrastructure, CI test orchestration, contract testing, or performance/load testing.
Test Automation Frameworks
1/10
Building automated tests
Minimal test automation artifacts: a single trivial unit UI test and no evidence of fixtures, sharding, mock servers or dedicated test infrastructure.
Evidence
vezir-catalog/src/App.test.js
steel-forge-cart/src/test-cart-proof.ts
Test Coverage & Strategy
1/10
What and how to test
No visible risk-based test strategy, negative-path/property tests, or mutation/coverage tooling; only a small example unit test exists.
Evidence
vezir-catalog/src/App.test.js
steel-forge-cart/README.md
API & Integration Testing
2/10
Testing how parts work together
Some integration work and typed DB contracts are present but no contract testing or schema-driven API tests; Supabase types and seed scripts show integration awareness.
Evidence
steel-forge-cart/src/integrations/supabase/types.ts
steel-forge-cart/scripts/seed.js
Performance & Load Testing
1/10
Testing speed under load
No performance or load test scenarios; only a perf instrumentation helper is present for measuring web vitals.
Evidence
vezir-catalog/src/reportWebVitals.js
Bug Reporting & Analysis
1/10
Finding and describing bugs
Basic error handling and logging appear in scripts, but there are no reproducible bug reports, postmortems, or linked fixes visible in the analyzed source files.
Evidence
steel-forge-cart/scripts/seed.js
steel-forge-cart/miniapp/app.js
CI Test Integration
1/10
Running tests automatically
No CI workflow files or test-run integration artifacts were present in the analyzed code; only local npm scripts and build scripts are defined.
Evidence
steel-forge-cart/package.json
vezir-catalog/package.json
Expertise
Unit & Component Testing• Junior
Industries
Commerce• Middle
Technologies
QA
Jest
Recommendations
- Improve automated test coverage by adding focused unit and integration tests with clear negative-path cases (e.g., failing API responses, 4xx/5xx flows) and move the proof tests into a test runner like Jest or Vitest.
- Add contract and schema-driven API tests (e.g., simple OpenAPI or schema checks) for edge functions and Supabase endpoints to validate response shapes and error codes.
- Introduce a basic CI workflow that runs lint, typecheck, unit tests and seed verification, and records test artifacts to begin trend visibility.
- Build isolated test fixtures for Supabase-dependent flows (local dev sandbox or test database, or lightweight testcontainers) to make integration tests reliable and repeatable.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: