Bantis Petru
Backend Developer
10+ years exp
20+ projects
SQL
TypeScript
PHP
JavaScript
Python
Go
Node JS
API Design: 6/10
Scalability & Performance: 5/10
System Architecture: 5/10
Active 15 days ago
+7 (958) 6408171 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Backend engineer (senior) specializing in API-driven microservices and real-time trading components. The strongest proven skill is building resilient service fabrics and RPC/API surfaces, exemplified by the MCP Hub (manager/router/supervisor/plugin design) and a Go-based order book with Redis and Prometheus integration. Public code shows solid architecture and testing for microservices and fintech flows but lacks evidence of long migration chains, formal DB migration/versioning practices and enterprise-grade secret management.
Technical skills
SQL
TypeScript• Junior
PHP• Middle • 10y+
JavaScript• Junior • 10y+
Python• Junior • 7y+
Go• Senior • 3y+
Node JS• Middle • 3y+
PHP
Laravel• 10y+
Node JS
TypeORM
Nest.JS
Databases
ElasticSearch
RabbitMQ
MySQL• 10y+
Redis• 10y+
PostgreSQL• 7y+
Apache Kafka
Frontend
React.js
Vite
Next.js
Tailwind CSS
ESLint
Prettier
GraphQL
DevOps
Git
Docker Compose
Prometheus
CI/CD
Containers
Docker• 10y+
Rest API• 10y+
gRPC• 3y+
QA
Jest
AI/ML
LLM
Model Context Protocol
PyTorch
ChatGPT
Claude
Gemini
YOLO
Cursor• 20+ projects
Web3
Cosmos
Bitcoin• 10y+
Ethereum• 10y+
Polkadot• 6y+
Cosmos SDK• 3y+
TON
Timeline
Backend Developer (Freelance)
•
Middle
Freelance
•
Freelance
Developed and maintained backend services using NestJS and Go. Built integrations with LLM and AI APIs including ChatGPT, Claude, and Google Cloud AI services. Worked on blockchain-related systems using Cosmos SDK and implemented real-time transaction monitoring across multiple networks. Also developed an AI Telegram bot for crypto trading automation and applied YOLO-based computer vision for video analysis.
Nest.JS
Go
ChatGPT
Claude
Gemini
Cosmos SDK
Bitcoin
TON
Apache Kafka
WebSockets
GraphQL
YOLO
Senior Backend Developer
•
Senior
Crypto exchange
•
Full-Time
Developed and supported backend systems with Node.js and NestJS. Implemented new modules and services, improved system architecture, and optimized performance. Integrated exchange-related features with external services and payment providers. Contributed to API design, stability, security, and internal project infrastructure.
Node JS
Nest.JSsince 2024
Lead Backend Developer
•
Lead
Decimal Smart Chain
•
Full-Time
Designed and implemented a microservices architecture for console and explorer using Cosmos SDK. Developed and maintained blockchain backend in Go with focus on consensus and module optimization. Built backend services with Go and Node.js and integrated gRPC, REST APIs, and WebSocket communication between services. Led a team of three developers, managing tasks, code reviews, and delivery timelines.
Gosince 2023
Cosmos SDKsince 2023
Node JSsince 2023
gRPC
Rest API
WebSocketssince 2023
Software Developer
•
Middle
Spacebot LTD
•
Full-Time
Built and maintained REST APIs for a mobile application using PHP/Laravel and Python, ensuring stability under high load. Implemented integrations with multiple cryptocurrencies, including transaction and wallet handling. Optimized database performance on large datasets using MySQL and PostgreSQL, including indexing, query tuning, and caching. Added monitoring and logging to reduce incident response time, using Docker and Redis within a microservices setup.
PHP
Laravel
Python
Rest API
PostgreSQL
MySQL
Docker
Redis
Ethereum
Bitcoin
Polkadot
Software Developer
•
Middle
Bit.team P2P
•
Full-Time
Developed frontend and backend REST API functionality for a P2P crypto exchange platform. Implemented integrations with cryptocurrencies for transaction processing and wallet operations. Built high-load features using PHP (Laravel), JavaScript, MySQL, and Redis. Participated in the full development lifecycle from architecture design to release and ongoing product support, including authorization, data protection, and transaction monitoring.
Laravelsince 2016
PHPsince 2016
JavaScript
Rest APIsince 2016
MySQLsince 2016
Redissince 2016
Bitcoinsince 2016
Ethereumsince 2016
Web Developer (Front End / Back End)
•
Middle
Vistabrokers CIF Ltd
•
Full-Time
Worked as a web developer in the financial sector, supporting both front-end and back-end development. The CV does not specify the detailed technical stack for this role. Responsibilities appear to include development and maintenance activities related to the organization’s financial processes. Additional specifics are not provided in the resume text.
Middle Backend Developer
Confidence: High API Engineer
Backend engineer (senior) specializing in API-driven microservices and real-time trading components. The strongest proven skill is building resilient service fabrics and RPC/API surfaces, exemplified by the MCP Hub (manager/router/supervisor/plugin design) and a Go-based order book with Redis and Prometheus integration. Public code shows solid architecture and testing for microservices and fintech flows but lacks evidence of long migration chains, formal DB migration/versioning practices and enterprise-grade secret management.
API Design
6/10
How well APIs are designed
API design is deliberate and consistent across services: an API Gateway, JSON-RPC MCP interface, Swagger-enabled NestJS services, and explicit patterns for pagination and error responses. Idempotency and producer/consumer contracts appear in PR notes and tests, and JSON-RPC handling is implemented carefully for notifications vs requests.
Evidence
pblaravel/spot-test/api-gateway/package.json: includes @nestjs/swagger and throttler indicating API contract and rate limiting
pblaravel/java-app/internal/server/mcp.go: JSON-RPC handling (initialize, ping, tools/list, tools/call) with clear error/result contract
pblaravel/spot-test/wallet-service/src/wallet/wallet.service.ts: getTransactionHistory uses pagination via createQueryBuilder and DTO patterns used across controllers/tests
Data Layer & Database
4/10
Working with databases
Data layer uses TypeORM and relational DBs, plus Redis for ephemeral state; there is repository usage, DTOs and query-builder pagination, but no extensive migration history or explicit transactional isolation handling visible in human-authored files.
Evidence
pblaravel/spot-test/wallet-service/package.json: dependency on @nestjs/typeorm and pg indicates relational DB usage
pblaravel/spot-test/wallet-service/src/wallet/wallet.service.ts: repository usage, transactional-like flows updating wallet and transactions
pblaravel/spot-test/order-book-service/main.go: saveOrderToRedis persists orders into Redis for short-term state
Scalability & Performance
5/10
Handling load and speed
Scalability signals include Redis for shared state, Prometheus metrics, Kafka/RabbitMQ mentions and services that are split by responsibility. There are pragmatic real-time pieces (order book, market-maker) and graceful shutdown logic, though advanced caching invalidation or measured load optimizations are not shown.
Evidence
pblaravel/spot-test/order-book-service/main.go: Redis usage, Prometheus metrics endpoint and graceful shutdown
pblaravel/spot-test/market-maker-service/package.json: includes kafkajs indicating message-driven integration
pblaravel/spot-test/order-book-service/main.go: matching engine and in-memory order book design for real-time throughput
System Architecture
5/10
Overall system structure
System architecture shows deliberate module boundaries: a Hub with Manager/Registry/Router/Plugins, a separate API surface, multiple microservices for exchange functions and a supervisor pattern. Configuration via viper/YAML and plugin indexing shows design choices for extensibility and operational control.
Evidence
pblaravel/java-app/internal/hub/hub.go: central wiring of config, manager, router, metrics, plugins and API surface
pblaravel/java-app/internal/manager/manager.go: managedServer, supervisor callbacks and lifecycle control
pblaravel/java-app/internal/server/mcp.go: separation of JSON-RPC MCP surface and stdio/HTTP transport handling
Security & Auth
5/10
Protecting data and access
Security and auth are explicitly addressed: API keys, JWT issuance/validation, ACL roles, whitelisting and rate limiting are implemented and used at HTTP boundaries. Application-level secret checks and hashed key comparisons are present, but secret rotation and hardened secret storage are not visible.
Evidence
pblaravel/java-app/internal/security/security.go: Guard implementing API keys, JWT parsing, ACL checks, IP whitelist and rate limiting
pblaravel/spot-test/user-service/package.json: includes @nestjs/jwt indicating JWT-based auth in services
pblaravel/java-app/internal/server/mcp.go: handles notifications and enforces request/response boundaries for RPC calls
Reliability & Observability
5/10
Stability and monitoring
Reliability and observability are present: graceful shutdown, health/readiness endpoints, Prometheus metrics, structured logging and timeouts in transport clients. There are retries/fallbacks (SSE fallback to streamable HTTP) and unit/e2e tests for several services, though advanced patterns like circuit breakers with backoff or distributed tracing are not pervasive in the human-authored code.
Evidence
pblaravel/spot-test/order-book-service/main.go: graceful shutdown, health and ready endpoints, Prometheus metrics exposure
pblaravel/java-app/internal/clients/sse.go: timeouts, long-lived http client, SSE parsing with fallback and response timeouts
pblaravel/spot-test/wallet-service/src/wallet/wallet.service.spec.ts: unit tests and controller tests showing test coverage for core flows
Verified artifacts
Expertise
Go Development• Middle
Microservices & API Architecture• Middle
Messaging & Real-time• Middle
Industries
Financial Services• Middle
Technologies
Go• Senior • 3y+
PHP• Middle • 10y+
PostgreSQL• 7y+
Redis• 10y+
Laravel• 10y+
RabbitMQ
Prometheus
Apache Kafka
TypeORM
Recommendations
- Develop and operate API-first microservices in Go or Node/NestJS, especially gateways and service orchestration layers.
- Implement real-time systems such as trading/matching engines, market-makers or order-book services that require low-latency state management and Redis integration.
- Build integrations and message-driven pipelines (Kafka/RabbitMQ) and end-to-end test harnesses for event flows and idempotency guarantees.
- Harden security and operational practices: add DB migration histories, secret rotation, structured tracing and documented transactional boundaries for multi-step money flows.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior QA Engineer
Confidence: Medium SDET
SDET / Test engineer (mid-level) focused on backend integration and microservice pipelines with a strength in building integration test workflows for message-driven systems. The strongest proven skill is setting up integration and test orchestration around RabbitMQ and mock services as documented in pblaravel/test-netjs/AGENTS.md and the workspaces package.json scripts. Public files do not show systematic performance/load testing, mutation testing, or a long history of tracked bug reports and CI workflow definitions.
Test Automation Frameworks
6/10
Building automated tests
Test automation framework work is present: monorepo test scripts, Jest configs, and a documented local test/dev workflow with a mock Telegram server and Docker orchestration.
Test Coverage & Strategy
4/10
What and how to test
There is evidence of E2E/integration strategy (npm scripts, test:integration and test:e2e entries) but limited visible risk-based tagging, mutation testing, or many documented negative-path tests in the publicly available human-authored files.
API & Integration Testing
5/10
Testing how parts work together
API and integration testing infrastructure is present with Dockerized RabbitMQ, mock Telegram service and Jest/Supertest listed in service packages, indicating realistic integration tests are intended or run.
Performance & Load Testing
1/10
Testing speed under load
Very little or no explicit performance/load testing artifacts are present; only monitoring/analytics libraries appear as dependencies, not load test scenarios or SLO-driven performance suites.
Bug Reporting & Analysis
2/10
Finding and describing bugs
Some operational discipline is visible (scripts, docs, docker compose and startup notes) but I did not find reproducible public bug reports, root-cause analyses, or structured flaky-test investigations in the human-authored files provided.
CI Test Integration
4/10
Running tests automatically
CI/test integration is partially evidenced via workspace scripts, docker:up and test orchestration entries; there is documentation for dev-agent startup order and test verification but no visible CI workflows or per-test quarantine policies in the inspected human-authored files.
Expertise
SDET & Test Engineering• Junior
Industries
Financial Services• Middle
Technologies
Containers
TypeScript• Junior
Docker Compose
Jest
CI/CD
Recommendations
- Implement and expose CI pipeline definitions (GitHub Actions or GitLab CI) that run unit, integration and diff-based test selection so that test runs are reproducible in CI.
- Add explicit contract and negative-path API tests (Pact or schemathesis-style) and schema validation for critical endpoints to increase confidence in cross-service integration.
- Introduce structured flaky-test mitigation: replace sleeps with conditional waits, add per-test retry/quarantine metadata and preserve failure artifacts (logs/traces) in CI artifacts.
- Add a lightweight performance test suite (k6 or Gatling) with SLOs and a simple baseline report to detect regressions early.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Intern Frontend Developer
Confidence: Low Generalist
Junior fullstack/generalist engineer with front-end leaning and experience producing visually rich React + canvas experiences. The strongest proven skill is building interactive canvas scenes using Phaser and React as shown by src/game/CityScene.ts and src/game/cityLayout.ts in the Sandspire project. There is little verifiable human-authored evidence for advanced async state discipline, accessibility engineering, rigorous performance measurement, or comprehensive CI test coverage in the evaluated artifacts.
UI Component Architecture
How interface parts are built
Not evidenced in public code
Responsive & Cross-browser
Works on all screens and browsers
Not evidenced in public code
Performance Optimization
Speed of the interface
Not evidenced in public code
Accessibility & Semantics
Usable for everyone
Not evidenced in public code
State Management & Data Flow
Managing data in the app
Not evidenced in public code
UX & Visual Polish
Look and feel quality
Not evidenced in public code
Expertise
React• Intern
Frontend Architecture & Build Tools• Intern
Industries
Financial Services• Middle
Technologies
JavaScript• Junior • 10y+
Node JS• Middle • 3y+
Nest.JS
GraphQL
Tailwind CSS
Next.js
React.js
Vite
ESLint
Prettier
Recommendations
- Use this developer to build small-to-medium interactive front-end features and prototypes, including canvas-based visual experiences and UI demos.
- Assign tasks that integrate frontends with backend APIs for product-facing flows where shipping working features quickly is the priority.
- Have the developer add unit tests, end-to-end smoke tests, and CI linting to increase reliability before moving to larger system components.
- Pair them with a senior engineer to harden state management (cancellation, optimistic updates, race handling) and accessibility improvements.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: