Semen Prokhorov
CTO
9+ years exp
20+ projects
Python
JavaScript
Node JS
TypeScript
API Design: 6/10
Data Layer & Database: 5/10
System Architecture: 5/10
Active 12 days ago
+7 (999) 6396183 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Career analytics
Roles
Overview
A backend-focused engineer at a senior (lower-mid) level who consistently delivers well-structured prototypes and production-adjacent services across Node.js and Python stacks. The strongest proven skill is building robust API-backed tools with clear domain logic and test coverage - for example the bank-statement parsing + normalization pipeline (server/import/parseStatement.ts and server/import/normalize.ts) and the FastAPI LLM run/save/validate flow (backend/app/main.py + backend/app/models.py). Public code shows limited operational tooling and monitoring, and there is little evidence of multi-service production operations, advanced DB migration history, or formal secrets-management beyond environment variables.
Technical skills
Python• Senior
JavaScript• Architect • 9y+ • 20+ projects
Node JS• Principal • 8y+ • 20+ projects
TypeScript• Senior • 7y+
Python
Pydantic
FastAPI
Databases
SQLite
MongoDB• 6y+ • 5+ projects
PostgreSQL
Qdrant
Frontend
Lighthouse
Vuex
PostCSS
Pinia
Zod
Sass• 8y+ • 20+ projects
Vue.js• 8y+ • 10+ projects
Vuetify• 8y+ • 5+ projects
Next.js• 5y+ • 5+ projects
React.js• 5y+ • 10+ projects
Storybook• 5y+ • 4 projects
Tailwind CSS• 5y+ • 10+ projects
Vite• 5y+
DevOps
AWS
Azure
Docker Compose
Git
Gitflow• 9y+ • 20+ projects
Rest API• 7y+
GitLab CI• 6y+ • 10+ projects
Docker• 5y+ • 10+ projects
WebSockets• 5y+
CI/CD• 3y+ • 4 projects
Grafana
QA
QA
Vitest
Swagger• 6y+ • 10+ projects
Playwright
AI/ML
Cursor
LLM• 10+ projects
RAG• 4 projects
Claude Code• 5+ projects
Claude
Mobile
Material Design
Timeline
Founder
•
Executive
Crabsistent
•
Cofounder
Confirmed by code
69%
Built and deployed a multi-agent AI automation system to streamline business processes across multiple industries. Collected requirements from stakeholders, translated them into technical solutions, and designed an agent architecture with peer-to-peer communication and a RAG pipeline. Implemented integrations with ERP, Google Sheets, Telegram and CRM, then supported rollout and onboarding for users at client companies.
Node JS
FastAPI
PostgreSQL
Qdrant
Claude
Docker
Grafana
RAG
AI Agents
Software Architect (Part-time)
•
Lead
Esprit Games
•
Part-Time
Confirmed by code
69%
Owned the architecture for a monorepo powering a mobile game, covering authorization and an overlay bridge. Defined service boundaries, selected the stack, and set up CI/CD. Implemented all layers from client logic to containerization and deployment, partnering with PM and designer to convert requirements into technical solutions.
Vue.js
Node JSsince 2025
Dockersince 2025
GitLab CI
PostgreSQLsince 2025
Leading Frontend Developer (Part-time)
•
Lead
X5
•
Part-Time
Confirmed by code
69%
Developed and maintained a production web application, focusing on fixes, optimizations and performance reviews. Improved reliability by debugging issues and iterating on the application architecture while supporting production operations. Delivered changes end-to-end and worked closely with a project manager in a small part-time setup.
Development Group Lead
•
Lead
7tours
•
Full-Time
Partially confirmed
61%
Led a cross-functional team of 8 people across frontend, backend, design, QA, DevOps, SEO and product roles. Managed the full lifecycle of a high-load web platform for the tourism market and improved development processes (planning, standups, reviews and retrospectives). Delivered SSR and SEO performance improvements, introduced Playwright end-to-end tests, and implemented GitLab CI/CD to stabilize staging and production deployments.
Vue.js
JavaScript
Sass
Vuetify
GitLab CIsince 2025
Jira
Gitflow
Playwright
CI/CD
Senior Frontend Developer
•
Senior
Solargroup
•
Full-Time
Partially confirmed
44%
Migrated a large client project from Nuxt 2 to Nuxt 3, focusing on performance and smoother developer workflows. Optimized bundle size and improved caching using browser- and CDN-level strategies. Implemented PWA capabilities to enhance offline experience and onboarding, and mentored junior developers through reviews and onboarding support.
Vue.js
Senior Frontend Developer
•
Senior
Rusagrogroup
•
Full-Time
Partially confirmed
47%
Developed a marketplace and supporting web applications, handling both feature work and architecture improvements. Built real-time chat and notification functionality using WebSockets and added PWA capabilities to improve user experience. Refactored a monolith toward microservices and created reusable UI components with Storybook while developing admin interfaces with a TypeScript-based frontend stack.
Next.js
React.js
TypeScript
Vite
Tailwind CSS
Storybook
WebSockets
Middle Frontend Developer
•
Middle
LANIT
•
Full-Time
Partially confirmed
54%
Implemented the client part for a large international banking project using Vue.js and TypeScript. Integrated REST API endpoints, created complex reusable UI components and participated in code reviews and architectural discussions. Worked in Scrum across the full project lifecycle, including planning and iterative delivery of feature modules.
Vue.js
TypeScriptsince 2019
Rest API
Peter the Great Saint Petersburg Polytechnic University
Bachelor's Degree •
Software Engineering
Junior Frontend Developer
•
Junior
Megacom
•
Full-Time
Partially confirmed
27%
Built a SPA for a classifieds/social product using Vue.js and Vuetify, covering core modules like authentication and user profiles. Integrated frontend with backend services via REST and Axios and implemented chat and payment-related flows. Created a responsive cross-browser UI library and developed supporting admin functionality while consuming third-party services including maps.
Vue.jssince 2018
Vuetifysince 2018
Axios
Career analytics
Verified work history and code activity in one view - open-source impact, work rhythm, trust signals and a forecast of when this candidate is likely to move.
8
Years active
129
Commits analyzed
Work rhythm
UTC+3
12 AM6 AM12 PM6 PM12 AM
Code activity
Low
Peak
Last activity
Jul 2026 · 13 Days
Active days (90d)
8
Typical work hours
8 AM - 4 PM
Open source & impact
2
Merged pull requests
Collaboration Quality
Co-authored commits
2
Senior Backend Developer
Confidence: Medium API Engineer
A backend-focused engineer at a senior (lower-mid) level who consistently delivers well-structured prototypes and production-adjacent services across Node.js and Python stacks. The strongest proven skill is building robust API-backed tools with clear domain logic and test coverage - for example the bank-statement parsing + normalization pipeline (server/import/parseStatement.ts and server/import/normalize.ts) and the FastAPI LLM run/save/validate flow (backend/app/main.py + backend/app/models.py). Public code shows limited operational tooling and monitoring, and there is little evidence of multi-service production operations, advanced DB migration history, or formal secrets-management beyond environment variables.
API Design
6/10
How well APIs are designed
Clear API boundaries, validation and consistent HTTP error handling (FastAPI + Pydantic; NestJS service uses exceptions), but limited evidence of versioning strategy, idempotency keys or advanced API stability patterns.
Evidence
AI-Brief-Decoder-Lite-Extension/backend/app/main.py
AI-Brief-Decoder-Lite-Extension/backend/app/models.py
Test3205/backend/src/jobs/jobs.service.ts
Data Layer & Database
5/10
Working with databases
Practical data-layer work: raw SQL migrations with sqlite/asyncpg, Prisma upserts and an idempotent seed with tests; limited evidence of multi-step migration history or explicit transaction/isolation tuning.
Evidence
AI-Brief-Decoder-Lite-Extension/backend/app/db.py
Oksnard/B-UP-test/prisma/seed.ts
Oksnard/B-UP-test/tests/db/seed.test.ts
Scalability & Performance
4/10
Handling load and speed
Thoughtful concurrency controls and cancellation (p-limit, AbortController, controlled streaming ticks) but no evidence of system-wide rate limiting, cache invalidation strategies or load-tested optimizations.
Evidence
Test3205/backend/src/jobs/jobs.service.ts
Test3205/backend/src/jobs/url-checker.service.ts
streaming-chat-prototype/backend/src/chat-stream.service.ts
System Architecture
5/10
Overall system structure
Deliberate modular layout and abstractions (provider factory for LLMs, domain/import separation for parsing, repository pattern); mostly monoliths / prototypes rather than multi-service orchestration.
Evidence
AI-Brief-Decoder-Lite-Extension/backend/app/provider.py
Oksnard/B-UP-test/server/import/normalize.ts
Test3205/backend/src/jobs/jobs.repository.ts
Security & Auth
4/10
Protecting data and access
Good input validation at API boundary (Pydantic, TypeScript checks), environment-driven config for secrets, and parameterized DB queries; limited evidence of token lifecycle management, secrets rotation or dependency-audit artifacts.
Evidence
AI-Brief-Decoder-Lite-Extension/backend/app/models.py
AI-Brief-Decoder-Lite-Extension/backend/app/config.py
AI-Brief-Decoder-Lite-Extension/backend/app/db.py
Reliability & Observability
4/10
Stability and monitoring
Reliable patterns present: unit/integration tests, idempotent seed, graceful cancellation and error branches; lack of structured logging, metrics, circuit-breakers or explicit retry-with-backoff configs.
Evidence
Oksnard/B-UP-test/tests/import/normalize.test.ts
Oksnard/B-UP-test/tests/db/seed.test.ts
Test3205/backend/test/url-checker.service.spec.ts
Expertise
Backend AI & LLM• Middle
Node.js• Middle
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Industries
Financial Services• Middle
Technologies
Python• Senior
PostgreSQL
FastAPI
WebSockets• 5y+
SQLite
Pydantic
Recommendations
- Develop backend APIs and ETL pipelines that ingest and normalise financial or transactional documents (use the parseStatement.ts and normalize.ts patterns).
- Build LLM-backed microservices or prototypes where provider abstraction, validation and result persistence are needed (extend provider.py and app/main.py patterns).
- Implement real-time features or PoC streaming services that require session recovery and chunked delivery (follow chat-stream.service.ts and chat.gateway.ts design).
- Work on data-layer hardening: multi-step migrations, explicit transactions, and performance tuning for larger datasets (leverage Prisma seed and db.py patterns).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior QA Engineer
Confidence: High SDET
A pragmatic engineer who builds full-stack TypeScript applications with a strong focus on testability and deterministic behavior; the work sits around an early senior / solid middle level. The strongest proven skill is backend reliability and test design, demonstrated by the JobsService concurrency logic with p-limit and AbortController plus focused tests covering aborts, error paths and boundary cases (Oksnard/Test3205/backend/src/jobs and tests). There is limited or no public evidence of formal contract testing, load testing, CI artifact retention or linked bug-tracking / RCA records.
Test Automation Frameworks
6/10
Building automated tests
Own test framework pieces and mocks are present - mock fetchers, custom test helpers and vitest configs exist, but there is no large-scale E2E framework glue or heavy selector discipline evidence. Evidence of isolated mocks and request-level fakes shows deliberate testability design.
Test Coverage & Strategy
7/10
What and how to test
Tests include negative paths, boundary checks and idempotency assertions rather than only happy-paths - there are focused unit tests for edge cases and deterministic behavior (act status cycling, stale boundary, seed idempotency). Test structure demonstrates risk-oriented cases and clear expectations.
API & Integration Testing
6/10
Testing how parts work together
API-level testing and integration fakes are implemented with in-process mock fetchers and schema-validated client tests; error paths such as 401-refresh, 204 handling and fetch failures are covered. There is no evidence of contract tooling like Pact or Schemathesis nor of containerized integration tests.
Performance & Load Testing
2/10
Testing speed under load
There is awareness of concurrency and limits (p-limit, randomized delay) inside application code, but there are no dedicated performance/load testing artifacts (k6/locust/ramp/SLO assertions) or results analysis. Concurrency is application-level rather than load-test engineering.
Bug Reporting & Analysis
2/10
Finding and describing bugs
Some tests show defensive thinking and reproducibility (seed idempotency, deterministic act states), but there are no public bug tracker reports, root-cause analyses or linked fixes that demonstrate a formal bug triage workflow.
CI Test Integration
4/10
Running tests automatically
Project includes test configs and scripts (vitest/jest/playwright configs and package scripts) and Playwright webServer settings that show CI-awareness, but there is no visible advanced CI test orchestration (matrix, selective runs, quarantine mechanics, artifact retention) in the provided artifacts.
Expertise
SDET & Test Engineering• Middle
API Testing & Contract Validation• Middle
Industries
Financial Services• Middle
Technologies
QA
TypeScript• Senior • 7y+
Rest API• 7y+
Playwright
Docker Compose
CI/CD• 3y+ • 4 projects
Vitest
Recommendations
- Develop backend services and test infrastructure that require robust concurrency control and cancellation - e.g., queue workers, URL crawlers or ETL pipelines (jobs.service + url-checker.service).
- Build and maintain ETL/parsing components that process messy inputs (bank statement PDF parsing and normalization) and associated normalization/seed pipelines (server/import/parseStatement.ts, server/import/normalize.ts, prisma/seed.ts).
- Design API testing and mocking layers for teams - create contract tests and expand mocks into contract/consumer tests to raise integration confidence (httpClient, core mocks).
- Implement CI test orchestration and artifact retention (matrix, per-test retry/granular quarantine, traces/screenshots) to harden E2E pipelines already referenced by Playwright config.
Middle Frontend Developer
Confidence: Medium Fullstack
A mid-level fullstack engineer focused on Vue/Nuxt frontends who also implements backend data ingestion and domain logic; the code shows independent feature ownership and cross-stack work but not large-scale system design. The strongest proven skill is robust data ingestion and normalization for fintech workflows, demonstrated by server/import/parseStatement.ts and server/import/normalize.ts plus idempotent seeding in prisma/seed.ts and related tests. The public code does not show measured performance tuning, an accessibility audit pipeline, or production deployment manifests for the README's deployment claims.
UI Component Architecture
5/10
How interface parts are built
Clean component structure and a small in-repo design system (packages/ui + custom SummaryCards) with stories/tests; not evidence of a bespoke design-system rollout or deep composition patterns across many apps so rated middle.
Responsive & Cross-browser
6/10
Works on all screens and browsers
Real responsive strategy and thoughtful CSS tokens, fluid type and small-screen table->card transforms plus prefers-reduced-motion handling in a human-authored main stylesheet.
Performance Optimization
2/10
Speed of the interface
Tooling is modern (Vite, Nuxt, PNPM, Turbo) and there are pagination/load-more patterns, but no measured before/after performance work, RUM, bundle analysis or advanced optimizations in the public code.
Accessibility & Semantics
4/10
Usable for everyone
Some a11y-conscious touches (focus-visible outline, focus-related logic in components and dialog/backdrop handling) but no explicit ARIA patterns, axe/CI enforcement or an accessibility audit present in the code.
State Management & Data Flow
5/10
Managing data in the app
Server-state and SPA discipline are visible - polling, cancellation and stores for active jobs, Pinia stores and composables are used; there is deterministic domain logic and tests. There are no advanced optimistic/rollback examples in the front-end code examined, so rated middle.
UX & Visual Polish
6/10
Look and feel quality
High visual polish and UX attention - custom tokens, skeleton/metric cards, motion, responsive transitions and explicit edge-state tests on domain logic; loading/error handling exists but is not exhaustively applied everywhere.
Expertise
Modern Web Frameworks• Middle
Frontend Architecture & Build Tools• Middle
Vue• Middle
HTML & CSS• Middle
Technologies
Azure
Git
AWS
Grafana
Pinia
Vite• 5y+
PostCSS
Zod
Vuex
Lighthouse
Socket.IO• mentioned only
Recommendations
- Develop small-to-medium fintech dashboards and internal tools that require PDF ingestion, normalization and reconciliation (use the parseStatement.ts and normalize.ts patterns).
- Implement fullstack features in Nuxt 3 apps where tight type-safety with Prisma and Zod is valuable (APIs + Vue frontends + seedable demo data).
- Build or extend a component library and Storybook-driven UI system (packages/ui) with focused a11y and performance improvements.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: