Pavel Ovchinnikov
Full Stack Developer
9+ years exp
4+ projects
SQL
JavaScript
Node JS
TypeScript
API Design: 5/10
Reliability & Observability: 5/10
Data Layer & Database: 4/10
Active 8 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Fullstack web developer at a Middle level with a strong focus on interactive, canvas- and WebGL-driven frontend experiences. The clearest proven strength is building performant, interactive visuals and UI modules as shown by MetaBalls Scene (src/components/MetaBallsCanvas/Scene.ts) and the custom Skill Grid (components/Skills/Grid/Grid.ts and Viewer.ts). There is limited public evidence of systematic accessibility work, advanced server-side blockchain integration, or large-scale architecture leadership.
Technical skills
SQL
JavaScript• Senior • 9y+ • 4 projects
Node JS• Senior • 8y+
TypeScript• Senior • 8y+ • 4 projects
PHP
WordPress
Databases
DynamoDB
PostGIS• 8y+
PostgreSQL• 8y+
Redis
Frontend
Angular
Material UI
npm
Sass
Tailwind CSS
Apollo Client
Vite
React Router
PostCSS• 11y+
Vuex• 11y+
Vue.js• 9y+
Redux• 8y+
React.js• 8y+
Next.js• 5y+
GraphQL
DevOps
Bitbucket
Rest API
AWS Lambda• 8y+
AWS CDK• 7y+
CI/CD• 4y+
Amazon EC2
AWS
Docker
QA
Swagger
Pytest
Vitest
Mocha• 8y+
Sentry• 8y+
Playwright
AI/ML
AI Agents
Claude
Mobile
PWA
React Native
Ionic• 8y+
IoT
AWS IoT SDK• 7y+
MQTT• 7y+
LoRaWAN• 7y+
Cybersecurity
Auth0• 5y+
Snyk• 3y+
AWS WAF• 3y+
Web3
TON
Tron
Viem
Timeline
Full-stack Web Developer
•
Middle
Meshintex, Inc.
•
Full-Time
Built an IoT dashboard that ingests live sensor data and renders real-time charts and map views with large marker counts. Implemented scalable ingestion by buffering burst traffic through an SQS queue and optimized map performance via marker clustering for smooth pan/zoom. Designed and secured RBAC for both UI and API and hardened the system against common web vulnerabilities. Engineered a crypto payment service architecture with per-chain watcher containers, Docker-based deployment, and reliable webhook delivery using a BullMQ/Redis worker.
Next.js
React.js
PostgreSQL
GraphQL
Docker
AWS Lambda
AWS
Amazon EC2
BullMQ
Redis
CI/CD
Full-stack Web Developer
•
Middle
Kupsilla LLC
•
Full-Time
Worked on client projects including a cloud lab automation platform and a genetics-focused research application. For the lab platform, improved scalability and release independence by restructuring the frontend into microfrontends and creating shared UI libraries published to a private npm registry. For the genetics app, optimized heavy data pages using SSR and compressed API responses, and built an interactive synchronized chart/table experience. Set up collaborative CI/CD workflows with AWS Amplify and Cognito plus linting, testing, and repository branching rules.
React.js
TypeScript
CI/CDsince 2022
Node JS
Next.js
AWSsince 2022
PostgreSQL
Software Developer
•
Middle
Strata K.K.
•
Full-Time
Contributed to video platforms gmb.io and Praxis for North American users. Improved playback quality across devices by selecting suitable codecs and resolution automatically to reduce buffering and format errors. Lowered operational effort for the video upload pipeline by simplifying microservice architecture and removing redundant processing steps. Also maintained an admin panel using a React-based admin framework.
Next.jssince 2021
PostgreSQL
TypeORM
Auth0
AWS Lambda
Full Stack Web Developer
•
Middle
Nwave Technologies Ltd.
•
Full-Time
Developed frontend and backend systems for smart parking sensors handling up to 20,000 IoT devices. Built and tested a REST API for device CRUD operations using AWS Lambda with Node.js/TypeScript, PostgreSQL/PostGIS, API Gateway, and Cognito-based authentication. Improved infrastructure stability by adopting AWS CDK to enable repeatable one-command environment provisioning. Enhanced a SPlace PWA map UI by optimizing Ionic/Angular rendering with marker clustering, and maintained an admin dashboard with a React/Redux-Saga stack and production monitoring.
AWS Lambdasince 2018
Node JSsince 2018
TypeScriptsince 2018
PostgreSQLsince 2018
PostGIS
Mocha
AWS CDK
Ionic
Vue.js
React.jssince 2018
Redux
Sentry
Web Developer
•
Middle
Adguard
•
Full-Time
Contributed to the AdGuard product and related browser extensions written in JavaScript. Worked on a codebase that helps users access content behind ad-blocker detection walls and contributed to the AdGuard Assistant project. Also worked on the AdGuard website frontend using Vue.js with state management and PostCSS-based styling workflows.
JavaScript
Vue.jssince 2017
Vuex
PostCSS
Moscow State Mining University
Bachelor's Degree •
Software Engineer
Junior Backend Developer
Confidence: Medium API Engineer
Full-stack web engineer (Middle) specializing in Node.js serverless APIs and GraphQL-backed services. The strongest proven skill is building and testing a serverless GraphQL API integrated with DynamoDB and AWS Lambda, demonstrated by lambda-digital-api/index.ts, src/resolvers/Items.ts and the integration tests in lambda-digital-api/tests/index.ts. There is little public evidence of production auth/token lifecycle, advanced schema migration history, or large-scale distributed-systems design.
API Design
5/10
How well APIs are designed
Well-structured GraphQL API design with schema/resolvers, argument-based filtering/pagination and explicit error contract; however no advanced versioning or idempotency system is present.
Evidence
lambda-digital-api/src/resolvers/Items.ts: items() implements range/limit/offset and returns consistent types
lambda-digital-api/src/resolvers/Items.ts: item() throws GraphQLError with extensions.code='BAD_USER_INPUT' for not-found cases
lambda-digital-api/index.ts: Apollo server construction and createLambdaHandler for Lambda integration
Data Layer & Database
4/10
Working with databases
Appropriate use of DynamoDB with the AWS SDK v3 and DynamoDBDocumentClient, seeding and batch writes, and tests exercising table lifecycle; lacks a visible migration history or multi-table transaction logic.
Evidence
lambda-digital-api/scripts/seed.ts: CreateTableCommand, BatchWriteCommand and clearTable implementation with Scan/Batch deletions
lambda-digital-api/tests/index.ts: test harness creates and deletes test DynamoDB table and seeds items
lambda-digital-api/src/resolvers/Items.ts: uses GetCommand and relies on scanAllItems from db layer
Scalability & Performance
4/10
Handling load and speed
Production-aware serverless deployment patterns and some performance-aware code (Lambda handler memoization, batch writes); no evidence of measured load testing, distributed throttling or sophisticated caching/invalidation strategies.
Evidence
lambda-digital-api/index.ts: handler memoization (handlerPromise) to reuse created Lambda handler
lambda-digital-api/scripts/seed.ts: BatchWriteCommand usage for efficient seeding
lambda-digital-api/package.json: SST-based dev/deploy scripts indicating serverless deployment intent
System Architecture
4/10
Overall system structure
Clear modular separation (entities, resolvers, db, scripts) and server/serverless boundary, with deployment scripts; service decomposition is modest and there is no multi-service orchestration evidence.
Evidence
lambda-digital-api/src/entities and src/resolvers: separation of schema/entities and resolver logic (Items.ts, Authors.ts)
lambda-digital-api/src/db.ts and lambda-digital-api/index.ts: distinct DB access layer and Lambda/Apollo integration
lambda-digital-api/scripts/serve.ts and package.json scripts: dev/serve/deploy orchestration using SST
Security & Auth
2/10
Protecting data and access
Minimal explicit security controls in code: basic input handling and disabling of Apollo landing page are present, but no auth/authz flows, token lifecycle, or hardened input validation for external interfaces are shown.
Evidence
lambda-digital-api/src/resolvers/Items.ts: explicit BAD_USER_INPUT GraphQLError for missing items
lambda-digital-api/index.ts: ApolloServerPluginLandingPageDisabled used (reduces exposure of interactive playground)
lambda-digital-api/scripts/seed.ts: resolveTableName checks env vars and falls back to SST Resource to avoid accidental secrets leakage
Reliability & Observability
5/10
Stability and monitoring
Good reliability and test hygiene for a small service: integration tests with DynamoDB local, retries for readiness, table lifecycle management, and sensible seed/cleanup scripts; lacks advanced observability (tracing/metrics) in code shown.
Evidence
lambda-digital-api/tests/index.ts: waitForDynamo retry loop and create/delete table in test lifecycle; server start/stop around tests
lambda-digital-api/scripts/seed.ts: try/catch for ResourceInUseException and clearTable implementation for idempotent seeding
lambda-digital-api/tests/index.ts: assertions verifying sorting, filtering and error conditions indicating test coverage of important behaviors
Expertise
Node.js• Junior
Microservices & API Architecture• Junior
Industries
Blockchain & Crypto• Junior
Technologies
SQL
PostgreSQL• 8y+
Redis
PostGIS• 8y+
DynamoDB
WordPress
Recommendations
- Lead development of serverless GraphQL/REST endpoints and backends using AWS Lambda and DynamoDB with comprehensive integration tests.
- Implement auth/authz (JWT/Cognito) and token lifecycle (refresh/revocation) for API endpoints to harden production security.
- Add schema evolution tooling and migration history for datastore changes, and introduce structured observability (tracing, metrics, SLOs).
- Expand load testing and caching strategies (measured optimizations) for high-read services and define rate-limiting thresholds
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium Fullstack
Fullstack web developer at a Middle level with a strong focus on interactive, canvas- and WebGL-driven frontend experiences. The clearest proven strength is building performant, interactive visuals and UI modules as shown by MetaBalls Scene (src/components/MetaBallsCanvas/Scene.ts) and the custom Skill Grid (components/Skills/Grid/Grid.ts and Viewer.ts). There is limited public evidence of systematic accessibility work, advanced server-side blockchain integration, or large-scale architecture leadership.
UI Component Architecture
5/10
How interface parts are built
Custom, well-separated canvas UI modules and domain model with reusable classes show deliberate component boundaries, but there is no evidence of a company-wide design system or extensive component-library design work.
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive layout handled with SCSS and CSS modules and explicit media queries; good practical responsiveness but no explicit RTL/i18n or advanced feature-detection strategies.
Performance Optimization
5/10
Speed of the interface
Measured-minded rendering performance and allocation avoidance in interactive canvas/WebGL code, plus use of requestAnimationFrame and preallocated buffers; lacks formal before/after metrics or bundle-analysis artifacts.
Accessibility & Semantics
2/10
Usable for everyone
Little explicit accessibility work visible; some signals that a11y tools are considered via dev deps, and print/semantic styles are present, but no ARIA, keyboard management, or documented accessibility tests for custom widgets.
State Management & Data Flow
4/10
Managing data in the app
Server-state and dataflow are implemented sensibly on the API side with GraphQL resolvers, argument parsing, sorting and tests; client-side server-state patterns are implied but client cache invalidation or optimistic update patterns are not visible in analyzed files.
UX & Visual Polish
5/10
Look and feel quality
High visual polish and animation work across canvas and CSS with thoughtful transitions and hover states; UX edge states like loading/error/undo are not consistently surfaced in the examined artifacts.
Verified artifacts
Expertise
React• Junior
Modern Web Frameworks• Junior
Web Performance & Optimization• Junior
HTML & CSS• Junior
Industries
Blockchain & Crypto• Junior
Commerce• Junior
Technologies
Rest API
Tailwind CSS
AWS CDK• 7y+
Angular
CI/CD• 4y+
AWS
Docker
Vite
Apollo Client
npm
Material UI
Sass
Bitbucket
AWS Lambda• 8y+
Amazon EC2
React Router
GraphQL• mentioned only
Recommendations
- Develop interactive, graphics-heavy frontends and WebGL experiences where custom rendering and performance matter.
- Build serverless GraphQL backends and small marketplace APIs using AWS Lambda + DynamoDB patterns already present in the API tests and seed scripts.
- Implement end-to-end product features for NFT or e-commerce frontends that combine the existing canvas visuals with Apollo GraphQL client flows.
- Work on component library consolidation and automated a11y testing to raise component architecture and accessibility maturity.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior QA Engineer
Confidence: Medium API QA Engineer
Full-stack TypeScript developer (mid-level) focused on API integration and interactive frontend components with a strong practical emphasis on integration testing and reliable runtime behavior. The strongest proven skill is API integration testing and end-to-end DynamoDB-backed GraphQL validation demonstrated by lambda-digital-api/tests/index.ts together with seed and lifecycle scripts. There is limited evidence of CI pipeline automation for tests, property-based or mutation testing, and no load/performance testing infrastructure visible in the public code.
Test Automation Frameworks
5/10
Building automated tests
Integration-focused test automation present (Mocha + local Dynamo lifecycle and seed scripts) with retry logic and test setup, but no full-featured fixture/factory framework, contract tooling, or dedicated test orchestration visible.
Evidence
lambda-digital-api/tests/index.ts: integration tests creating table, seeding data and executing GraphQL operations
lambda-digital-api/scripts/seed.ts: seed/clear table logic with BatchWrite and CreateTable handling
lambda-digital-api/package.json: test script and mocha usage
Test Coverage & Strategy
5/10
What and how to test
Tests include explicit negative-path and boundary checks (unknown id error, date-range boundaries, type assertions and sort-order checks), but there is no evidence of property-based tests, mutation testing, or a clear risk-based test tagging strategy.
Evidence
lambda-digital-api/tests/index.ts: checks for BAD_USER_INPUT on unknown id, range-based inclusion/exclusion, type assertions and sort order
API & Integration Testing
6/10
Testing how parts work together
Good API/integration testing practice: Apollo server started in tests, DynamoDB Local used with table lifecycle, AWS SDK lib used for Put/Get/Scan; demonstrates real end-to-end integration coverage though contract tools (Pact/Schemathesis) are not present.
Evidence
lambda-digital-api/index.ts: createServer/createLambdaHandler wiring Apollo + type-graphql
lambda-digital-api/tests/index.ts: uses DynamoDBClient/DynamoDBDocumentClient, creates table, seeds items and executes GraphQL operations
lambda-digital-api/scripts/seed.ts: table create/clear and PutCommand usage for seeding data
Performance & Load Testing
1/10
Testing speed under load
No load or performance testing artifacts; only client-side web-vitals instrumentation is present, which is for user-experience metrics rather than load testing or SLO checks.
Evidence
lambda-digital-client/src/reportWebVitals.ts: web-vitals instrumentation (no load/threshold tests)
Bug Reporting & Analysis
2/10
Finding and describing bugs
Some defensive and flaky-test mitigation patterns exist (wait-retry for Dynamo readiness, seed script handles ResourceInUseException), but there are no public bug reports, postmortems, or documented flaky-test investigations.
Evidence
lambda-digital-api/tests/index.ts: waitForDynamo with retries to avoid flakiness around local Dynamo startup
lambda-digital-api/scripts/seed.ts: try/catch handling ResourceInUseException and table-clear logic
CI Test Integration
2/10
Running tests automatically
Project contains test runner configs and test scripts (Mocha, Vitest) and setupFiles, but there is no visible CI workflow configuration, failure-artifact collection, flaky-test quarantine, or selective/changed-files test execution in the code examined.
Evidence
lambda-digital-client/vitest.config.ts: vitest test configuration with setupFiles
lambda-digital-api/package.json: test scripts invoking mocha with Dynamo local environment variables
Expertise
SDET & Test Engineering• Junior
Industries
Blockchain & Crypto• Junior
Technologies
Swagger
Pytest
Mocha• 8y+
Sentry• 8y+
Vitest
Recommendations
- Develop GraphQL microservices and serverless APIs with integrated integration tests and DynamoDB-backed local test harnesses.
- Build interactive frontend UIs and WebGL/canvas animation components where precise rendering and input handling are required.
- Expand test infrastructure work: add CI pipelines that run integration tests, collect artifacts, and run selective tests on diffs.
- Design contract testing and property-based checks for APIs and add basic load testing to validate performance and SLOs.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: