Evdokimov Kirill
4+ years exp
JavaScript
Python
Data Layer & Database: 5/10
API Design: 4/10
System Architecture: 4/10
Active 1 day ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
Backend engineer (early career, Middle) focused on building REST APIs with clear modular structure and practical domain logic. The strongest proven skill is building a transactional async FastAPI app with DB migrations and repository patterns as shown in the controllers, repositories and alembic migration files in the salon booking project. Public code shows limited evidence of production-grade scalability, structured observability and advanced security lifecycle handling.
Technical skills
JavaScript• Junior • 4y+
Python• Middle • 4y+
Python
Alembic
FastAPI
SQLAlchemy
Pydantic
Asyncio
Uvicorn
Django
Requests
Beautiful Soup
Databases
SQLite
Frontend
JQuery
Bootstrap
DevOps
Docker Compose
Containers
Middle Backend Developer
Confidence: High API Engineer
Backend engineer (early career, Middle) focused on building REST APIs with clear modular structure and practical domain logic. The strongest proven skill is building a transactional async FastAPI app with DB migrations and repository patterns as shown in the controllers, repositories and alembic migration files in the salon booking project. Public code shows limited evidence of production-grade scalability, structured observability and advanced security lifecycle handling.
API Design
4/10
How well APIs are designed
API is clearly structured with FastAPI routers, dependency injection and role-based error handling but lacks formal versioning, idempotency keys and advanced pagination patterns.
Evidence
test_task_salon/controllers/queue.py: many REST endpoints with role checks and request/response models
test_task_salon/controllers/live_queue.py: router endpoints returning response_model and raising HTTPException for auth/edge cases
test_task_salon/test_main.py: integration tests exercising auth flows and endpoint contracts
Data Layer & Database
5/10
Working with databases
Data layer shows deliberate design - Alembic migrations with foreign keys and indexes, async SQLAlchemy sessions and repository abstractions - but no explicit transaction isolation tuning or complex query optimization.
Evidence
test_task_salon/alembic/versions/a5b2e6d8ac5e_init.py: migration creating user, masters, e_queue, feedback, live_queue with FKs and indices
test_task_salon/db/db.py: Async SQLAlchemy engine/session setup and User model
test_task_salon/repositories/queue.py: repository-level select/update patterns, commit and refresh usage
Scalability & Performance
2/10
Handling load and speed
Some async and testing practices are present but there is little evidence of deliberate scalability work such as caching strategies, connection-pool tuning, rate limiting or load-test results.
Evidence
test_task_salon/requirements.txt: async stack dependencies (aiosqlite, sqlalchemy[asyncio], fastapi, uvicorn) indicating async design
test_task_salon/repositories/*: repositories use async DB calls but there are no cache or queue-based decoupling artifacts in the production controllers
System Architecture
4/10
Overall system structure
Code is modular with clear controllers, repositories, schemas and models which reflects sensible separation of concerns but remains a monolith-style API without multi-service contracts or service mesh patterns.
Evidence
test_task_salon/controllers/: controllers separated by domain (queue, live_queue, masters, feedback, users)
test_task_salon/repositories/base.py and repositories/*: repository abstraction layer separate from controllers
test_task_salon/schemas/: pydantic schemas separated from models and controllers
Security & Auth
4/10
Protecting data and access
Authentication and authorization are integrated and enforced at endpoints and the DB migration enforces email uniqueness; however token lifecycle, refresh/revocation and advanced input-hardening patterns are not visible.
Evidence
test_task_salon/controllers/users.py: fastapi-users integration and user manager hooks
test_task_salon/alembic/versions/a5b2e6d8ac5e_init.py: user table with unique index on email and role column
test_task_salon/test_main.py: tests for register/login flows exercising auth behavior
Reliability & Observability
2/10
Stability and monitoring
There is basic test coverage and use of commits/refreshes to persist changes but little evidence of structured logging, timeouts, backoff strategies, graceful shutdown logic or metrics/alerts.
Evidence
test_task_salon/test_main.py: integration tests covering many happy and some error flows
test_task_salon/repositories/queue.py: commit/refresh patterns used to persist state but no retry/backoff or circuit-breaker logic
Expertise
Python• Middle
Microservices & API Architecture• Middle
Databases & Vector Storage• Middle
Industries
Lifestyle• Middle
Technologies
SQLAlchemy
SQLite
Asyncio
Recommendations
- Use for building REST APIs and CRUD-heavy services with async SQLAlchemy and Alembic-based schema management.
- Extend existing systems by adding integration tests, endpoint-level auth checks and repository-focused unit tests.
- Implement production hardening tasks such as structured logging, metrics (Prometheus/OpenTelemetry), request timeouts and retry/backoff strategies.
- Develop booking or appointment features and transactional workflows where repository patterns and DB migrations are central.
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
Backend web developer (Middle) focused on building API-driven web applications and integrations. The strongest proven skill is building and testing async Python web backends with FastAPI and SQL models demonstrated by the FastAPI controllers, repositories and tests (for example Evdak/test_task_salon/controllers and Evdak/test_task_salon/test_main.py). There is little to no evidence of infrastructure-as-code, CI/CD pipelines, observability, or cloud architecture practices in the human-authored artifacts.
CI/CD Pipelines
1/10
Automated build and deploy
Minimal CI/CD evidence; repository includes container build and compose artifacts but no reusable pipelines, gating, artifact signing or deploy/release automation.
Infrastructure as Code
Managing servers with code
Not evidenced in public code
Containerization & Orchestration
2/10
Working with containers
Basic containerization is present (Dockerfiles and docker-compose), but there is no orchestration (Kubernetes) manifests, no tuned probes, non-root user configuration, resource sizing, or Pod disruption controls.
Observability & Monitoring
Watching system health
Not evidenced in public code
Reliability & Incident Response
2/10
Keeping systems up
Some reliability hygiene is visible via unit/integration tests and a compose healthcheck, but there are no runbooks, incident postmortems, progressive delivery or explicit rollback criteria.
Cloud & Cost Optimization
Smart use of the cloud
Not evidenced in public code
Technologies
Containers
Python• Middle • 4y+
Docker Compose
FastAPI
Beautiful Soup
Django
Pydantic
Uvicorn
Requests
Alembic
Recommendations
- Develop REST/async APIs and small backend services using FastAPI with database migrations and test coverage, including endpoints and repository layers.
- Implement integrations with external APIs and ETL-style data refresh logic, such as Google Sheets syncing and HTML/XML parsing workflows.
- Hardening simple container deployments and adding CI/CD pipelines (reusable workflows, artifact publishing, basic deploy gates) to move projects towards production readiness.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium App Engineer
Frontend engineer (junior) focusing on interactive, server-rendered quiz interfaces for web-based education. The strongest proven skill is client-side state and persistence shown by the saveAnswer/get_answers flow and the quiz restoration logic in Evdak/speaking_club/speaking_club/templates/test.html and test2.html. There is little evidence of modern component frameworks, automated tests, build tooling, or advanced a11y and performance measurement in public code.
UI Component Architecture
2/10
How interface parts are built
Minimal component architecture: large, repeated server-rendered template blocks and global inline JS functions rather than reusable client components or well-scoped modules.
Responsive & Cross-browser
3/10
Works on all screens and browsers
Basic responsive rules are present (media queries) and some modern selectors are used, but cross-browser feature detection and internationalization/RTL considerations are not evident.
Evidence
Performance Optimization
2/10
Speed of the interface
Little evidence of deliberate performance engineering or measurement; some DOM shuffling and sorting are used but no instrumentation, virtualization, or bundle-splitting.
Accessibility & Semantics
3/10
Usable for everyone
Some accessibility-minded markup exists (aria attributes and modal semantics) but there is no clear focus management, keyboard handling for custom widgets, or automated a11y checks in CI.
State Management & Data Flow
4/10
Managing data in the app
Client-side state and persistence are implemented pragmatically: answers are POSTed to endpoints, saved answers are fetched and replayed into the UI, and there is guarding around reload flows; however there is no advanced request cancellation, optimistic rollback, or formal state machine.
Evidence
Evdak/speaking_club/speaking_club/templates/test.html: saveAnswer(quiz_id, answer) sends AJAX POST to /speaking_club/register_answer/
Evdak/speaking_club/speaking_club/templates/test2.html: $.post to /speaking_club/get_answers/ then programmatic clicks / input fills to restore user answers; use of is_reloading flag to avoid double-saving
Evdak/speaking_club/speaking_club/templates/test.html: quiz_ids collected from [quiz-uuid] custom attributes and used to request persisted answers
UX & Visual Polish
4/10
Look and feel quality
Good UX flows for this class of app: progress tracking, next-slide CTA, audio player UI, and progressive reveal of the next step. Visual polish is present, though advanced perceived-performance patterns (skeletons, transitions tuned for INP/LCP) and undo patterns are absent.
Expertise
HTML & CSS• Junior
Industries
Education• Junior
Technologies
JavaScript• Junior • 4y+
Bootstrap
JQuery
Recommendations
- Build and maintain interactive educational UIs (quizzes, audio lessons, progress flows) where server-rendered templates need client-side state and persistence.
- Refactor interactive areas into scoped components (e.g., migrate quiz widgets into a component framework or module pattern) and add focused accessibility improvements like keyboard/focus management and aria-live announcements.
- Introduce automated tests (unit and E2E) for quiz flows and add simple performance/observability (bundle analysis, Lighthouse snapshots, or RUM) to measure regressions.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: