Sofya Sunko
Backend Developer
SQL
TypeScript
Python
Data Layer & Database: 6/10
API Design: 5/10
Security & Auth: 5/10
Active 16 days ago
+7 (904) 5397250 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A backend-focused engineer who produces production-grade, API-first services with strong transactional and concurrency handling, operating at a conservative senior level. The strongest proven skill is building correct, tested transactional APIs - evidenced by the wallet payment service, Alembic migrations, and concurrent integration tests (Wallet-api/app/services/wallet.py and Wallet-api/tests/test_wallets.py). There is limited public evidence of large-scale distributed systems design, advanced observability (metrics/alerts), or formal load testing documentation.
Technical skills
SQL
TypeScript• Senior
Python• Senior
Python
Alembic
Asyncio
FastAPI
Sanic
SQLAlchemy
aiogram
Requests
Pydantic
HTTPX
Databases
PostgreSQL
Supabase
AI/ML
Computer Vision
DevOps
Docker
Docker Compose
Git
Containers
Rest API
QA
Pytest
Playwright
Timeline
Backend / Integration Engineer
•
Middle
Aitelier
•
Full-Time
Developed a Python integration layer for AI agents, including REST API calls, data transformation/normalization, and structured JSON/CSV outputs for agent scenarios. Implemented webhook handling from event intake through parsing, mapping, and workflow routing. Built outbound automation using Python scripts to orchestrate call flows and keep execution within platform limits. Added end-to-end integration testing and debugging with fixes supported through stabilization in production.
Pythonsince 2025
Rest API
ВГПУ
Bachelor's Degree •
Учитель Английского
Backend Developer
•
Middle
Nutritsiologiya
•
Full-Time
Built a Python backend for client automation via Telegram, including message/data collection, processing, and producing per-client final results. Implemented an AI chatbot connected to a database to generate personalized answers based on client-specific rules and prepared data. Created a food diary processing algorithm to produce recommendations and responses. Deployed and operated a self-hosted server for the project.
Python
Senior Backend Developer
Confidence: High API Engineer
A backend-focused engineer who produces production-grade, API-first services with strong transactional and concurrency handling, operating at a conservative senior level. The strongest proven skill is building correct, tested transactional APIs - evidenced by the wallet payment service, Alembic migrations, and concurrent integration tests (Wallet-api/app/services/wallet.py and Wallet-api/tests/test_wallets.py). There is limited public evidence of large-scale distributed systems design, advanced observability (metrics/alerts), or formal load testing documentation.
API Design
5/10
How well APIs are designed
Clear REST API contracts, consistent error types and status codes, and explicit idempotency handling for payment webhooks; versioned endpoint paths and extensive endpoint tests are present.
Evidence
Wallet-api/tests/test_wallets.py
Wallet-api/app/core/exceptions.py
Dashboard-/src/app/api/webhooks/retailcrm/route.ts
Data Layer & Database
6/10
Working with databases
Deliberate relational schema and migration management with Alembic, model constraints and indexes, and explicit transactional boundaries and FOR UPDATE locking to avoid lost updates.
Evidence
Wallet/alembic/versions/0001_initial_schema.py
Wallet-api/app/services/wallet.py
Wallet-api/tests/conftest.py
Scalability & Performance
4/10
Handling load and speed
Concurrency and consistency were tested and handled (SELECT FOR UPDATE, transactional sessions), but there is little evidence of broader performance engineering such as caching, sharding, or documented load testing.
Evidence
Wallet-api/tests/test_wallets.py
Wallet-api/app/services/wallet.py
Wallet-api/tests/conftest.py
System Architecture
4/10
Overall system structure
Reasonable modular boundaries (api/services/repositories/schemas), repository and service layers and explicit migration management; architecture is well structured for a single-service deployment but not a multi-service distributed system.
Evidence
Wallet/app/services/payment_service.py
Wallet/app/repositories/account_repository.py
Dashboard-/src/lib/sync/backfill.ts
Security & Auth
5/10
Protecting data and access
Security-aware design: HMAC/signature verification for webhooks, JWT-based auth and role checks, idempotency via transaction_id and integrity-constraint handling; input validation uses Pydantic.
Evidence
Wallet/app/services/payment_service.py
Wallet/tests/test_webhook.py
Wallet/tests/test_auth.py
Reliability & Observability
4/10
Stability and monitoring
Good reliability patterns at the application level - explicit error types, centralized unhandled-exception handling, and nested transactions to enforce idempotency - but limited evidence of observability, retries with backoff, or SLI/SLO instrumentation.
Evidence
Wallet-api/app/core/exceptions.py
Wallet/app/services/payment_service.py
Wallet-api/tests/test_wallets.py
Expertise
Python• Senior
Node.js• Middle
Microservices & API Architecture• Middle
Industries
Commerce• Middle
Financial Services• Senior
Technologies
Python• Senior
PostgreSQL
Supabase
SQLAlchemy
FastAPI
Asyncio
Pydantic
HTTPX
Alembic
Recommendations
- Develop transactional payment and accounting microservices - idempotent webhooks and strict transaction boundaries are a good fit.
- Build API-first backend services that require strong consistency (wallets, ledgers, billing) and include integration tests and migration histories.
- Lead implementation of idempotent webhook processors and retry-safe payment ingestion pipelines.
- Integrate observability and SLO-driven alerts for production services (Prometheus/OpenTelemetry tracing and metrics).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior DevOps Engineer
Confidence: Medium Generalist
A pragmatic generalist developer operating at a low senior level (tier 4.0) with repeatable, well-tested backend and integration work across small services. The strongest proven skill is building reliable transactional backends and concurrency-safe logic, supported by WalletService.apply_operation (SELECT ... FOR UPDATE), concurrent integration tests, and retry/backoff logic in sheets._exec. There is limited evidence of CI/CD engineering, cloud architecture, orchestration (Kubernetes), SLO-driven alerting, or infrastructure-as-code beyond docker-compose.
CI/CD Pipelines
2/10
Automated build and deploy
Minimal CI/CD evidence: no reusable workflows, no caching/keys, no deploy gates or artifact signing. Only basic Dockerfile and docker-compose are present, but no pipeline engineering artifacts.
Evidence
Wallet-api/Dockerfile: application Docker image and runtime entrypoint
Wallet-api/docker-compose.yml: service composition, healthcheck and ports
Infrastructure as Code
1/10
Managing servers with code
Infrastructure-as-code is not evidenced beyond a docker-compose file; no Terraform/remote state/modules/lifecycle rules or infra tests are present.
Evidence
Wallet-api/docker-compose.yml: compose file used to run services
Containerization & Orchestration
3/10
Working with containers
Basic containerization practices present (Dockerfile, docker-compose, healthcheck). No orchestration manifests (Kubernetes), no tuned resource requests/limits, no PodDisruptionBudget or operators.
Evidence
Wallet-api/Dockerfile: image build for app
Wallet-api/docker-compose.yml: db healthcheck and depends_on service_healthy
Observability & Monitoring
2/10
Watching system health
Light observability: application logging configuration and numerous in-code debug/log calls and debug payload saving, but no SLOs, alerting, tracing, or structured observability as code.
Evidence
Wallet-api/app/core/logging.py: logging configuration helpers
WB-Parser/clients/wb_http_client.py: saving unexpected responses and debug payloads
Reliability & Incident Response
5/10
Keeping systems up
Clear reliability focus in application code: retry/backoff for flaky Google API calls, transactional locking to avoid race conditions, scheduled jobs with misfire grace and staggered times, and test coverage for concurrent operations.
Evidence
NutritionBot/src/sheets.py:_exec - retry/backoff for Google API (429/500/503) and SSL errors
Wallet-api/app/services/wallet.py:apply_operation - transaction with SELECT ... FOR UPDATE and correctness checks
NutritionBot/src/NutritionBot.py: scheduler jobs with misfire_grace_time and staggered_daily_time
Cloud & Cost Optimization
1/10
Smart use of the cloud
Almost no cloud/cost optimization artifacts - basic Docker Compose for local/dev run only; there is no autoscaling, spot/eviction strategies, K8s autoscaling or IAM work visible.
Evidence
Wallet-api/docker-compose.yml: local service composition (db + app)
Expertise
Site Reliability Engineering• Middle
Observability & Monitoring• Middle
Industries
Commerce• Middle
Financial Services• Middle
Technologies
Containers
aiogram
Recommendations
- Develop transactional backend services and payment / wallet APIs where concurrency correctness and DB transactional behavior is critical.
- Implement and operate chatbots and integration tooling (Telegram bot + Google Sheets integration) including scheduled reporting and offline debug flows.
- Build web-scraping and ETL pipelines with robust parsing, debug payload capture and export formats (JSON/CSV/XLSX).
- Raise platform maturity by adding CI pipelines (reusable workflows), deployment manifests (Kubernetes/GitOps), and SLO-driven alerting/observability instrumentation.
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 SDET-level engineer who builds reliable async APIs and integration test infrastructure and demonstrates solid boundary and concurrency testing. The strongest proven skill is integration-quality testing and transactional service design as shown by the alembic-driven test fixtures, ASGI AsyncClient usage and concurrent wallet tests asserting exact success/conflict outcomes. Public code lacks formal CI test orchestration, mutation/contract testing tools, and dedicated performance/load test artifacts.
Test Automation Frameworks
7/10
Building automated tests
Well-constructed test fixtures and session management for integration tests: session/engine fixtures, alembic-driven test migrations, ASGI test client and database-clean fixtures enable reliable isolated test runs and concurrency checks.
Evidence
AmeliaVicar/Wallet-api/tests/conftest.py: engine and session_factory fixtures that run Alembic migrations and reset public tables
AmeliaVicar/Wallet-api/tests/conftest.py: client fixture using LifespanManager + httpx.AsyncClient (ASGITransport)
AmeliaVicar/Wallet-api/tests/conftest.py: wallet_factory and autouse clean_wallets fixture for test data isolation
Test Coverage & Strategy
7/10
What and how to test
Tests encode negative paths and boundary conditions with precise expected failure codes and explicit concurrency assertions (counts of successes vs conflicts); there is deliberate edge-case coverage (overflow, invalid types, zero/negative amounts).
Evidence
AmeliaVicar/Wallet-api/tests/test_wallets.py: test_withdraw_insufficient_funds expects 409
AmeliaVicar/Wallet-api/tests/test_wallets.py: test_zero_amount_returns_400, test_negative_amount_returns_400, test_too_large_amount_returns_422
AmeliaVicar/Wallet-api/tests/test_wallets.py: test_deposit_overflow_returns_409 and parallel operation tests check exact success/conflict counts
API & Integration Testing
6/10
Testing how parts work together
Integration-level API testing against the actual FastAPI app with a real async SQLAlchemy engine and migrations provides strong integration confidence; response content assertions are used but explicit contract/schema tooling is not present.
Performance & Load Testing
2/10
Testing speed under load
Some concurrent operation tests simulate simultaneous client requests and validate correctness under concurrency, but there is no formal load or performance tooling, thresholds, or percentile analysis.
Bug Reporting & Analysis
Finding and describing bugs
Not evidenced in public code
CI Test Integration
Running tests automatically
Not evidenced in public code
Expertise
SDET & Test Engineering• Senior
Unit & Component Testing• Middle
Industries
Commerce• Middle
Financial Services• Middle
Technologies
TypeScript• Senior
Playwright
Docker Compose
Pytest
Requests
Recommendations
- Develop transactional backend services and API endpoints that require concurrency correctness and strong integration tests (wallets, payments, ledgers).
- Build and maintain integration test infrastructure - database-backed CI jobs with alembic migrations, isolated fixtures, and deterministic test data factories.
- Implement API contract testing and automated CI workflows (schema validation, selective test runs, artifact collection) to raise reliability for cross-team integrations.
- Extend performance testing (k6/Locust) and add guardrails (SLOs, threshold checks) for workloads identified via concurrency tests.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: