Smirnov Anton

Backend • Middle
Python
Security & Auth: 6/10
API Design: 5/10
Data Layer & Database: 5/10
Active 17 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles

Overview

A practical backend engineer at a middle level who delivers full-stack backend features (APIs, async DB access, background jobs and basic real-time). The strongest proven skill is building REST/real-time services with async SQLAlchemy and auth flows, evidenced by the FastAPI-based booking service (app/auth.py, app/db/crud.py, app/api/bookings.py). There is limited evidence of production-grade operational hardening such as advanced resiliency patterns, rate limiting, or detailed infrastructure / deployment automation.

Technical skills

Python• Middle
Python
FastAPI
Uvicorn
SQLAlchemy
Asyncio
Alembic
Celery
Pydantic
Databases
Redis
PostgreSQL
Frontend
Chart.js
DevOps
WebSockets
Docker Compose
Containers
Middle Backend Developer Confidence: High API Engineer
A practical backend engineer at a middle level who delivers full-stack backend features (APIs, async DB access, background jobs and basic real-time). The strongest proven skill is building REST/real-time services with async SQLAlchemy and auth flows, evidenced by the FastAPI-based booking service (app/auth.py, app/db/crud.py, app/api/bookings.py). There is limited evidence of production-grade operational hardening such as advanced resiliency patterns, rate limiting, or detailed infrastructure / deployment automation.
API Design
5/10
How well APIs are designed
Clean REST/real-time API surface using FastAPI/Flask with dependency injection and basic pagination; lacks explicit versioning, idempotency keys, or documented error contract beyond HTTPException usage.
Evidence
my-backend-project/app/api/bookings.py
my-backend-project/app/api/users.py
my-backend-project/app/api/rooms.py
Data Layer & Database
5/10
Working with databases
Asynchronous SQLAlchemy models and well-structured CRUD layer with alembic migration files present; shows awareness of transactional flows and query patterns (exists subquery) but no evidence of advanced tuning, explicit isolation-level handling, or a long migration history.
Evidence
my-backend-project/app/db/crud.py
my-backend-project/app/db/models.py
my-backend-project/alembic/versions/2026_04_07_06_05_31_initial_schema.py
Scalability & Performance
4/10
Handling load and speed
Async stack (asyncpg/sqlalchemy asyncio, uvicorn), Celery + Redis listed as dependencies, and a WebSocket manager indicate attention to concurrency and background work; however no documented rate-limiting, cache invalidation, or measured performance optimizations are present.
Evidence
my-backend-project/pyproject.toml
my-backend-project/app/api/websocket.py
my-backend-project/app/clients.py
System Architecture
5/10
Overall system structure
Modular service layout (api/services/db/tasks), use of background workers and migration tooling shows deliberate decomposition; architecture is a monolith with reasonable boundaries rather than a multi-service ecosystem, and config/secret management is via pydantic settings.
Evidence
my-backend-project/app/main.py
my-backend-project/app/services/booking_service.py
my-backend-project/alembic/env.py
Security & Auth
6/10
Protecting data and access
Concrete authentication flows including JWTs, refresh tokens, password hashing, and Pydantic validation demonstrate solid security awareness at the API boundary; missing visible hardened items such as token revocation lists in production or multi-factor flows, but core best practices are present.
Evidence
my-backend-project/app/auth.py
my-backend-project/app/schemas.py
my-backend-project/pyproject.toml
Reliability & Observability
4/10
Stability and monitoring
Logging and a timing middleware plus unit/async tests provide basic observability and reliability practices; no extensive retry/backoff strategies, circuit breakers, or documented SLO/alerting artifacts were found.
Evidence
my-backend-project/app/logger.py
my-backend-project/app/main.py
my-backend-project/tests/test_booking_service.py
Expertise
Python• Middle
Microservices & API Architecture• Middle
Messaging & Real-time• Middle
Databases & Vector Storage• Middle
Backend AI & LLM• Middle
Industries
Software• Middle
Farming & Agriculture• Middle
Technologies
PostgreSQL
Redis
SQLAlchemy
Pydantic
Uvicorn
Recommendations
  • Own and extend REST + WebSocket services that require async DB access, background jobs (Celery) and JWT-based auth - implement new endpoints and business logic.
  • Implement and harden production concerns: connection pooling, retries with backoff, circuit breakers, rate limiting and observability (traces/metrics/alerts).
  • Build small ML-backed backend features such as embedding-based search or document ingestion pipelines using the existing DocMind embedding/search code.
  • Work on database schema evolution and migrations (Alembic) and hand-tuned queries/indexes for performance-sensitive features.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Scales_bee my-backend-project DocMind
Middle DevOps Engineer Confidence: Medium Generalist
A backend-focused generalist at a Middle level who builds Python/FastAPI services and small-scale deployments. The strongest proven skill is building async backend systems and application-level integration (e.g., FastAPI endpoints, Async SQLAlchemy CRUD, Alembic migrations, Celery tasks) as shown by app/api/*, app/db/crud_async.py and alembic/versions/2026_04_07_06_05_31_initial_schema.py. There is limited evidence of production-grade DevOps practices such as CI/CD pipelines, Kubernetes/GitOps, secrets management, SLOs, or cloud architecture in the public code.
CI/CD Pipelines
1/10
Automated build and deploy
No CI/CD pipeline definitions found (no GitHub Actions, GitLab CI, Buildkite, etc.). Test suite exists which is a necessary precondition for CI but pipeline engineering (gates, reusable workflows, artifact signing) is not present.
Evidence
smir0181-code/my-backend-project/tests/test_booking_service.py smir0181-code/my-backend-project/tests/test_crud.py
Infrastructure as Code
2/10
Managing servers with code
Infrastructure-as-code is minimal: a Dockerfile and docker-compose.yml are present and include a Postgres healthcheck, but there are no versioned Terraform/Pulumi modules, remote state locking, environment-separated IaC, or state migration artifacts.
Evidence
smir0181-code/my-backend-project/Dockerfile smir0181-code/my-backend-project/docker-compose.yml
Containerization & Orchestration
2/10
Working with containers
Containerization is basic and correct for small deployments (multi-service docker-compose, Dockerfile), but lacks production-grade orchestration, tuned probes, non-root container user, resource tuning, PodDisruptionBudget/anti-affinity, or Kubernetes manifests/GitOps patterns.
Evidence
smir0181-code/my-backend-project/Dockerfile smir0181-code/my-backend-project/docker-compose.yml
Observability & Monitoring
2/10
Watching system health
Observability is limited to structured application logging and a rotating file handler; there are no SLOs, Prometheus/Alertmanager, tracing, alert routing, or dashboards-as-code present.
Evidence
smir0181-code/Vk-bot-parser/logger.py smir0181-code/my-backend-project/app/logger.py
Reliability & Incident Response
2/10
Keeping systems up
Some basic reliability practices appear (DB healthcheck in docker-compose, try/except and graceful KeyboardInterrupt handling in bot/demo scripts), but no runbooks, postmortems, progressive delivery (canary/blue-green), or explicit rollback criteria are present.
Evidence
smir0181-code/my-backend-project/docker-compose.yml smir0181-code/Vk-bot-parser/bot.py
Cloud & Cost Optimization
1/10
Smart use of the cloud
Cloud and cost-optimization practices are not evidenced. The stack uses standard services (Postgres, Redis) in docker-compose but shows no cloud IAM, autoscaling, spot/eviction handling, or rightsizing analysis.
Evidence
smir0181-code/my-backend-project/docker-compose.yml
Expertise
Observability & Monitoring• Middle
Industries
Software• Middle
Technologies
Containers
Python• Middle
Docker Compose
FastAPI
WebSockets
Asyncio
Celery
Alembic
Recommendations
  • Use the developer to build and maintain Python FastAPI backend services with async DB access and background jobs (Celery) including unit and integration tests.
  • Assign work to extend deployment maturity: add CI/CD pipelines, automated tests in pipeline, and secure secrets handling (Vault/SOPS) for staging/production.
  • Have the developer implement observability improvements - structured logs, metrics export (Prometheus/OpenTelemetry) and basic SLOs/alerts tied to tests and runbooks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
my-backend-project Vk-bot-parser
Intern Frontend Developer Confidence: Medium UI Engineer
A frontend-focused developer at a junior level who delivers small, pragmatic UI work and simple telemetry visualizations. The strongest proven skill is building straightforward data visualizations and UI glue - for example, the Scales_bee static/chart.js implements polling, stale-data handling and two Chart.js visualizations with daily aggregation. The public code does not show advanced state management, testing, accessibility engineering, or measured performance work.
UI Component Architecture
2/10
How interface parts are built
Minimal componentization - mostly imperative DOM and small modular functions (no frameworks, no custom design system or component library).
Evidence
smir0181-code/Scales_bee/static/chart.js: renderChart / fetchData functions encapsulate chart creation but no component boundaries smir0181-code/Website_portfolio-/script/script.js: Swiper initialization is performed directly in a script (imperative integration)
Responsive & Cross-browser
3/10
Works on all screens and browsers
Basic responsive design via CSS media queries and fluid percentage widths, but no advanced techniques (no container queries or RTL handling).
Evidence
smir0181-code/Website_portfolio-/css/style.css: @media (max-width: 768px) rules and responsive hero/title adjustments smir0181-code/Scales_bee/static/style.css: percentage-based #chartContainer and width adjustments
Performance Optimization
2/10
Speed of the interface
Lightweight performance awareness - prevents Chart.js leakage by destroying instances and uses infrequent polling, but no measured or advanced optimizations or code-splitting.
Evidence
smir0181-code/Scales_bee/static/chart.js: if (chartInstance) chartInstance.destroy() before creating new Chart smir0181-code/Scales_bee/static/chart.js: setInterval(renderChart, 60000) - simple polling strategy
Accessibility & Semantics
2/10
Usable for everyone
Basic semantic HTML and alt text on images, but no ARIA for custom widgets, no focus management, and no a11y tooling evidence in CI.
Evidence
smir0181-code/Website_portfolio-/index.html: use of semantic header, alt attributes on images smir0181-code/Scales_bee/static/index.html: clear textual fallbacks for missing data but no ARIA or keyboard handling for interactive controls
State Management & Data Flow
3/10
Managing data in the app
Simple client-side state and server-state handling - fetch with cache-busting and a stale-data check; no cancellation, optimistic updates, or state machines.
Evidence
smir0181-code/Scales_bee/static/chart.js: fetch('/api/weight/history?hours=24&_=' + Date.now()) in fetchData smir0181-code/Scales_bee/static/chart.js: MAX_AGE_MINUTES check to detect stale sensor data and update UI accordingly; clear history POST handler
UX & Visual Polish
3/10
Look and feel quality
Solid basic UX touches - shows empty/stale states, battery display, and daily aggregation; lacks skeletons, transition polish or undo patterns.
Evidence
smir0181-code/Scales_bee/static/chart.js: sets '— (нет актуальных данных, датчик вероятно отключён)' when data is stale and displays battery_percent smir0181-code/Scales_bee/static/chart.js: aggregation into dailyMap and rendering of line and bar charts for different views
Expertise
HTML & CSS• Intern
Industries
Farming & Agriculture• Middle
Technologies
Chart.js
Recommendations
  • Maintain and extend dashboards or simple monitoring UIs (IoT telemetry panels) - build additional charts, aggregate views, and refine polling/caching.
  • Convert the imperative chart logic into small reusable components (e.g., a Chart component module) and add request cancellation and unit tests.
  • Polish accessibility and responsive robustness - add ARIA to interactive elements, keyboard focus flows, and audit with axe/eslint-a11y.
  • Migrate vendor scripts into a build flow (bundle + code-splitting) and add basic performance measurement (bundle size, LCP) before optimizing further.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Scales_bee Website_portfolio-