Vladislav Tolstov
Python Developer
4+ years exp
Python
SQL
API Design: 5/10
Data Layer & Database: 5/10
Scalability & Performance: 5/10
Active 9 hours ago
Invite to interview
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
Backend API engineer (Senior level) focused on asynchronous realtime systems and agent tooling. The strongest proven skill is building end-to-end realtime messaging and WebRTC/WebSocket plumbing, demonstrated by app/services/websocket_service/ws_endpoint.py and frontend call_session.py plus audio_manager.py. There is limited public evidence of production-grade infra like CI/CD, observability/metrics, and a documented DB migration history with evolution scripts.
Phone
Technical skills
Languages
2
Python
SQL
Python
8
FastAPI
Asyncio
Requests
SQLAlchemy
Pydantic
Alembic
HTTPX
Rich
Other
27
PostgreSQL
FFmpeg
Redis
Selenium
Docker Compose
LLM
Docker
Pytest
Adobe Premiere Pro
Uvicorn
MySQL
Playwright
PyQt
WebSockets
GitHub
Postman
Linux
Rest API
Git
RabbitMQ
Model Context Protocol
Nginx
Containers
AI Agents
Machine Learning
Frida
Adobe After Effects
Projects
Machine learning study project
Worked on a broader machine learning study project to explore fundamentals beyond the perceptron exercise. Applied practical implementations to learn common workflow steps such as data preparation and model experimentation. Used the project as a practice ground for improving understanding of ML basics.
Digit recognition perceptron
Created a machine learning project using a perceptron for digit recognition. Implemented training and evaluation logic as part of learning experiments in basic ML modeling. Concentrated on understanding model behavior and accuracy on classification data.
MCP AI agent
Built an MCP-based AI agent that performs tool-calling with both local and external LLM providers. Implemented custom tooling integration to extend agent actions beyond plain text generation. Focused on connecting the agent to runnable capabilities through the MCP interface.
Microservice-based web messenger
Designed a web messenger using a microservice approach with WebSocket communication. Implemented authentication using JWT and added media upload capabilities for chat content. Focused on real-time updates and service separation for maintainable backend structure.
Desktop messenger
Graduation project implementing a client-server messenger with a FastAPI backend and a PyQt6 desktop UI. Supported media upload handling and persistent messaging storage using MongoDB, PostgreSQL, and Redis. Used Docker for containerized development and deployment.
Timeline
Co-founder and Developer
•
Head+
Zenith
•
Cofounder
Built an analytics service that predicts whether IT teams will meet project deadlines. Collected data from sources like GitHub, Jira, and Slack, then fed it into an AI module to assess schedule risk. Created internal charts and reports to track project status and used a FastAPI-based async backend with AI/LLM integration.
Python
FastAPI
Asyncio
LLM
Co-founder and Python Developer
•
Head+
ACM
•
Cofounder
Co-developed a platform for automated content management on video platforms, including channel connections and publishing workflows. Designed a scoring approach based on engagement metrics and reduced irrelevant content selection via improved ranking logic. Built an end-to-end video generation and publishing pipeline using async FastAPI services, Redis/PostgreSQL storage, Dockerized deployment, and AI API/local model processing with failover.
Python
FastAPI
Asyncio
Redis
PostgreSQL
Docker
FFmpeg
LLM
Python Developer
•
Middle
DPTube
•
Full-Time
Built and operated an automated management system for a network of YouTube channels controlled through a Telegram bot. Implemented scheduling, retries, and analytics workflows by integrating with the YouTube API. Automated template-based video generation using an Adobe Premiere API workflow and ffmpeg, and added Selenium-driven AI voice-over generation upon request, with production support and incident fixes.
Python
Telegram
YouTube
Adobe Premiere Pro
FFmpeg
Selenium
PostgreSQL
Redis
Docker Compose
Python Developer
•
Middle
MultiAction
•
Freelance
Developed a desktop automation tool for multi-threaded browser and mobile scenarios. Implemented the user interface and core business logic, and built automation flows using Playwright and Selenium. Added supporting integration work for emulator-based Android scenarios and used additional instrumentation during automation.
Python
Playwright
Selenium
Frida
Senior Backend Developer
Confidence: Medium API Engineer
Backend API engineer (Senior level) focused on asynchronous realtime systems and agent tooling. The strongest proven skill is building end-to-end realtime messaging and WebRTC/WebSocket plumbing, demonstrated by app/services/websocket_service/ws_endpoint.py and frontend call_session.py plus audio_manager.py. There is limited public evidence of production-grade infra like CI/CD, observability/metrics, and a documented DB migration history with evolution scripts.
API Design
5/10
How well APIs are designed
Solid, pragmatic API surface using FastAPI routers and a dedicated WebSocket endpoint with consistent handler dispatch and JWT verification; lacks explicit idempotency patterns, documented pagination contracts and no multi-versioning strategy beyond v1.
Evidence
app/api/v1/routers/auth/auth.py: FastAPI router signatures for register/login/refresh
app/api/v1/routers/account/profile_actions.py: APIRouter endpoints with UploadFile/FileResponse and OAuth2 usage
app/services/websocket_service/ws_endpoint.py: websocket receive loop, event_handlers dispatch and token verification
Data Layer & Database
5/10
Working with databases
Async Postgres and Mongo integration with repository/service layers and explicit commit/rollback handling; there is use of AsyncSession and motor but no visible migration history or multi-step schema evolution artifacts.
Evidence
app/db/postgres/session.py: create_async_engine / AsyncSession setup
app/repository/postgres/crud.py: typed repository functions using AsyncSession and select
app/db/mongo/db.py: motor AsyncIOMotorClient initialization
Scalability & Performance
5/10
Handling load and speed
Asynchronous design and non-blocking websockets are used end-to-end and the agent provider demonstrates robust HTTP retry/backoff and timeout handling; caching, explicit rate limiting and documented scaling strategies are not present.
Evidence
zamagent/providers.py:_post - retries, backoff and timeout handling for HTTP model calls
app/services/websocket_service/ws_endpoint.py: async websocket receive loop and ConnectionManager usage
app/db/postgres/session.py: async DB engine usage (create_async_engine)
System Architecture
5/10
Overall system structure
Clear module boundaries - routers, services, repository, DB and websocket handlers - plus a separate agent/provider architecture for LLM tooling, showing deliberate decomposition; absence of multi-service contracts, service mesh choices or infra tooling reduces the architecture score.
Evidence
app/api/v1/routers: separation of REST endpoints (auth, account, chat, ws)
app/services/*: dedicated service modules for auth, user actions and websocket handlers
zamagent/agent.py and zamagent/providers.py: provider abstraction and tool-execution separation
Security & Auth
5/10
Protecting data and access
Token-based auth and password hashing are implemented and tokens are verified at WebSocket and API boundaries; however token lifecycle details (revocation, refresh workflows) and finer-grained authz policies are not extensively documented in the code shown.
Evidence
app/core/security.py: create_token, verify_token, hash_password, verify_password
app/api/v1/routers/ws/ws.py: verify_token usage for websocket auth
app/services/auth_service/refresh.py: refresh access token handler
Reliability & Observability
5/10
Stability and monitoring
Good use of logging, try/except guards, explicit rollbacks and unit smoke tests for the agent; missing are structured tracing/correlation ids, metrics or documented alerting and explicit graceful shutdown across the whole service surface.
Evidence
app/services/websocket_service/ws_endpoint.py: logger usage and exception handling in the websocket loop
zamagent/providers.py:_post: heartbeat, timeouts and retry logging
zamagent/tests/test_smoke.py: offline smoke tests validating provider/tool flows
Expertise
Backend AI & LLM• Senior
Microservices & API Architecture• Senior
Industries
Internet Services• Middle
Technologies
Rest API
RabbitMQ
FastAPI• since 2025
HTTPX
Requests
Rich
Recommendations
- Build realtime chat and voice features - implement WebSocket hubs, call signaling and media handling for product-grade messaging systems.
- Develop FastAPI backend services that require async DB access and Mongo/Postgres synchronization, including repository/service patterns and unit tests.
- Extend LLM integration components and tooling - provider abstraction, streaming SSE parsing and robust retry/backoff for model API clients.
- Implement multimedia desktop clients in PyQt with WebRTC integration and native audio capture/playback pipelines.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior QA Engineer
Confidence: High Generalist
Full-stack Python developer (senior-level) specializing in real-time communication and WebRTC-focused desktop and backend systems. The strongest proven skill is building real-time audio/video and WebSocket systems, evidenced by zamk1d/ZetCordFrontend/backend/call_session.py and zamk1d/ZetCordBackend/app/services/websocket_service/ws_endpoint.py. Public code does not show CI-driven test orchestration, performance/load testing, or contract testing infrastructure.
Test Automation Frameworks
3/10
Building automated tests
Basic pytest-based unit tests and fixtures exist but no dedicated test infrastructure, parallelization, or complex fixture isolation.
Evidence
Zamk/Auth_service/tests/conftest.py
Zamk/Auth_service/tests/unit/test_auth.py
Test Coverage & Strategy
3/10
What and how to test
Tests include negative-path and schema validation cases and some edge-case assertions, but coverage appears focused on unit scenarios rather than a risk-based strategy or property-based tests.
Evidence
Zamk/Auth_service/tests/unit/test_security.py
Zamk/Auth_service/tests/unit/test_pydantic_schemas.py
API & Integration Testing
2/10
Testing how parts work together
API and integration logic is well structured (FastAPI routers, token checks, DB access), but public tests are unit-level with mocks rather than contract testing, schema fuzzing, or testcontainers-based integration tests.
Evidence
zamk1d/ZetCordBackend/app/services/websocket_service/ws_endpoint.py
zamk1d/ZetCordBackend/app/services/user_actions_service/avatar_upload.py
Zamk/Auth_service/src/routes/auth.py
Performance & Load Testing
Testing speed under load
Not evidenced in public code
Bug Reporting & Analysis
Finding and describing bugs
Not evidenced in public code
CI Test Integration
Running tests automatically
Not evidenced in public code
Expertise
Unit & Component Testing• Middle
Industries
Internet Services• Middle
Software• Middle
Telecommunications• Middle
Technologies
Selenium• since 2022
Playwright
SQLAlchemy
WebSockets
Postman
Pytest
Pydantic
Recommendations
- Develop real-time communication components and WebRTC integrations for desktop and backend services, including audio pipeline and ICE handling.
- Implement backend WebSocket event handlers and related Mongo/Postgres data flows for chat and presence features.
- Build authenticated API surfaces and token-based auth workflows (JWT) for microservices and mobile/desktop clients.
- Expand unit test suites into integration tests or contract tests (schemathesis/Pact) and introduce CI pipelines for automated verification.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle DevOps Engineer
Confidence: Medium Generalist
Middle-level backend engineer specializing in asynchronous Python services and realtime WebSocket messaging. The strongest proven skill is building async WebSocket endpoints and message handlers as demonstrated in app/services/websocket_service/ws_endpoint.py and the handlers under app/services/websocket_service/handlers. Public code does not evidence CI/CD pipelines, Kubernetes or production-grade observability and cost optimization practices.
CI/CD Pipelines
Automated build and deploy
Not evidenced in public code
Infrastructure as Code
2/10
Managing servers with code
Basic infrastructure artifacts exist (Dockerfiles, docker-compose, Alembic migrations) but there is no evidence of remote state, locking, environment-separated IaC modules, migration scripts, or infra tests.
Evidence
ZetCordBackend/docker-compose.yml
Zamk/Auth_service/alembic/versions/4ea57b20a199_add_index_to_uuid_column_in_clients_.py
zawork/docker-compose.yml
Containerization & Orchestration
2/10
Working with containers
Containerization is used via Dockerfiles and docker-compose but there are no Kubernetes manifests, no multi-stage build optimizations, no non-root user or resource/probe tuning beyond defaults.
Evidence
ZetCordBackend/Dockerfile
ZetCordBackend/docker-compose.yml
Zamk/Auth_service/Dockerfile
Observability & Monitoring
2/10
Watching system health
Application-level logging is present and used in handlers, but there is no evidence of SLOs, burn-rate alerts, alert routing/inhibition rules, dashboards-as-code, or structured tracing integration.
Evidence
ZetCordBackend/app/services/websocket_service/ws_endpoint.py
ZetCordBackend/app/services/websocket_service/handlers/private_msgs.py
Reliability & Incident Response
2/10
Keeping systems up
Code shows basic runtime error handling, transaction rollbacks and WebSocket disconnect handling, but no runbooks, postmortems, DR rehearsals, or documented deploy/rollback strategies.
Evidence
ZetCordBackend/app/services/websocket_service/ws_endpoint.py
ZetCordBackend/app/services/user_actions_service/avatar_upload.py
Zamk/Auth_service/src/repository/pg/crud.py
Cloud & Cost Optimization
1/10
Smart use of the cloud
Minimal cloud or cost-optimization evidence: configuration by env vars and docker-compose usage exist but no autoscaling, spot/eviction strategies, workload identity, or rightsizing metrics.
Evidence
zawork/src/zawork/core/config.py
ZetCordBackend/docker-compose.yml
Expertise
Observability & Monitoring• Junior
Platform Engineering & IDP• Junior
Industries
Internet Services• Middle
Software• Middle
Technologies
Containers
Python• since 2022 • Senior
Docker Compose• since 2022
Asyncio• since 2025
Uvicorn
Alembic
Recommendations
- Develop async realtime backend services and WebSocket subsystems for small-to-medium scale realtime products.
- Implement and own authentication/token services with unit and integration tests for security-critical flows.
- Migrate local Docker Compose setups to a tested deployment pipeline and add CI/CD workflows with gated deploys.
- Add observability: structured tracing, SLOs and alerting rules (with noise reduction) and document runbooks for common incidents.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: