Maks Travel
Python Developer
4+ years exp
SQL
Python
Data Wrangling & Cleaning: 6/10
Reproducibility & Notebook Hygiene: 5/10
Active 16 days ago
+7 (930) 7222662 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A backend API engineer at a solid middle level who builds modular FastAPI services with async database access and test coverage. The strongest proven skill is backend data modeling and queries - evidenced by the BaseDAO pattern, the CTE-based availability check in makstravel/bookings_app_fastapi/app/bookings/dao.py, and accompanying Alembic migrations. The codebase lacks advanced production-hardening details such as cache invalidation strategy, documented retry/backoff policies, and secret management practices in visible code.
Technical skills
SQL
Python• Middle • 4y+
Python
Aiohttp
Django REST Framework
Alembic
Pydantic
Uvicorn
aiogram• 4y+
Asyncio• 4y+
Celery• 4y+
Django• 4y+
FastAPI• 4y+
SQLAlchemy• 4y+
Databases
Apache Kafka
RabbitMQ
ElasticSearch
PostgreSQL• 4y+
Redis• 4y+
AI/ML
LangChain
LlamaIndex
Ollama
DevOps
Nginx
Prometheus
Containers
CI/CD• 4y+
Docker• 4y+
Docker Compose• 4y+
Git• 4y+
GitLab CI• 4y+
Grafana• 4y+
Kibana• 4y+
Rest API• 4y+
QA
Pytest• 4y+
Sentry
Timeline
Python Developer
•
Middle
Sogaz
•
Full-Time
Worked on an internal B2B application for automatic calculations in Excel, redesigning the calculation core and separating business logic from I/O. Built a FastAPI service for calculation and report/document generation backed by PostgreSQL, containerized with Docker, with monitoring via Sentry and pipelines in GitLab CI/CD. Implemented a RAG agent for corporate DMS using LangChain, LlamaIndex, and Ollama to answer with source-based citations and metadata.
FastAPI
PostgreSQL
Docker
SQLAlchemy
GitLab CI
CI/CD
Sentry
Git
LangChain
LlamaIndex
Ollama
Python Developer
•
Middle
AdSoft
•
Full-Time
Developed and maintained the ComboCards backend for issuing and managing virtual cards, including balance top-ups and service payments. Implemented backend services using a microservice architecture with FastAPI and Django, designing REST APIs and adding reliability features like Soft Delete for restoring deleted cards and transactions. Improved performance with Redis caching and PostgreSQL query optimization, and built observability via Grafana dashboards and Kibana-based logging; added automated tests with Pytest and collaborated with frontend, QA, and DevOps.
FastAPI
Django
SQLAlchemy
Asyncio
PostgreSQLsince 2022
Redis
Celery
Docker
Docker Compose
Gitsince 2022
GitLab CIsince 2022
CI/CDsince 2022
Pytest
Grafana
Kibana
Rest API
Python Developer
•
Middle
Freelance
•
Full-Time
Delivered backend solutions and Telegram bots for client tasks, handling architecture from requirements to deployment. Built bots with aiogram, including anti-spam systems, integrations with external APIs, and automation for user data recording. Used Docker for deployment and environment isolation, and implemented additional automation scripts related to Web3 token operations.
Python
Djangosince 2022
FastAPIsince 2022
SQLAlchemysince 2022
aiogram
Dockersince 2022
Middle Data Scientist
Confidence: Medium Data Engineer
A backend-focused data engineer at a mid-level who builds async Python services and ingestion pipelines. The strongest proven skill is implementing reliable data ingestion and backend business logic, shown by the BookingDAO add flow with CTE-based availability checks and the Kafka producer/consumer plus DatabaseService for PostgreSQL. Statistical analysis, predictive modeling, formal KPI-driven instrumentation and explicit data-versioning workflows are not evidenced in the human-authored code.
Statistical Rigor
Correct use of statistics
Not evidenced in public code
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Clear evidence of data ingestion and cleaning patterns: CSV conversion utilities, test-time date parsing and DAO-level validation to prevent leakage and overlapping bookings.
Exploratory Analysis & Visualization
Exploring and visualizing data
Not evidenced in public code
Predictive Modeling
Building models that predict
Not evidenced in public code
Business Insight & Impact
3/10
Turning analysis into business value
Domain rules and business logic are implemented (booking overlap checks, booking-duration limits), showing product awareness but there is no explicit business-metric framing, cost-of-error analysis or KPI-driven recommendations.
Reproducibility & Notebook Hygiene
5/10
Clean, repeatable analysis
Good reproducibility and hygiene signals: pinned requirements, pytest async fixtures for integration tests, and Alembic migrations exist; missing explicit data-versioning (DVC) or pinned runtime/container manifests for full reproducibility.
Expertise
Streaming• Middle
Industries
Data & Analytics• Middle
Travel & Tourism• Middle
Technologies
Python• Middle • 4y+
PostgreSQL• 4y+
Redis• 4y+
SQLAlchemy• 4y+
FastAPI• 4y+
Apache Kafka
Asyncio• 4y+
Celery• 4y+
Pydantic
Uvicorn
Alembic
Recommendations
- Develop and maintain async backend APIs and DB-backed services using FastAPI and SQLAlchemy (CRUD, transactional logic, migrations).
- Design and operate lightweight streaming ingestion pipelines and consumers (Kafka producers/consumers, PostgreSQL ingestion, monitoring hooks).
- Implement observability and reproducible pipelines - extend tests with CI, add data-versioning (DVC) and document SLOs/KPIs for business-impact tracking.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: High API Engineer
A backend API engineer at a solid middle level who builds modular FastAPI services with async database access and test coverage. The strongest proven skill is backend data modeling and queries - evidenced by the BaseDAO pattern, the CTE-based availability check in makstravel/bookings_app_fastapi/app/bookings/dao.py, and accompanying Alembic migrations. The codebase lacks advanced production-hardening details such as cache invalidation strategy, documented retry/backoff policies, and secret management practices in visible code.
API Design
5/10
How well APIs are designed
API is modular with versioning and dependency-based auth, but lacks advanced API-level patterns like idempotency keys, consistent pagination primitives, or a formal error contract beyond custom exceptions.
Evidence
makstravel/bookings_app_fastapi/app/main.py: VersionedFastAPI usage and router composition
makstravel/bookings_app_fastapi/app/users/dependencies.py: JWT token extraction and current-user dependency (auth boundary)
makstravel/bookings_app_fastapi/app/exceptions.py: custom HTTP exception classes used across controllers
Data Layer & Database
5/10
Working with databases
Data layer shows deliberate design - async SQLAlchemy usage, a BaseDAO, CTE-based availability check and Alembic migrations - but transaction/isolation rationale and schema evolution beyond initial migrations are limited.
Evidence
makstravel/bookings_app_fastapi/app/dao/base.py: BaseDAO with async session patterns and add/delete methods
makstravel/bookings_app_fastapi/app/bookings/dao.py: CTE-based availability query and explicit insert + commit flow
makstravel/bookings_app_fastapi/app/migrations/versions/923d6a1020a5_initial_migration.py: Alembic migration present
Scalability & Performance
4/10
Handling load and speed
The code integrates caching (Redis), background processing (Celery) and metrics (Prometheus), indicating attention to scalability, but lacks documented cache invalidation, rate limiting, connection/pool tuning and measured performance work.
Evidence
makstravel/bookings_app_fastapi/app/main.py: FastAPICache init with RedisBackend and Instrumentator for Prometheus
makstravel/bookings_app_fastapi/app/tasks/tasks.py: Celery-backed background tasks (email, image processing)
makstravel/bookings_app_fastapi/requirements.txt: celery, redis and prometheus-client listed
System Architecture
4/10
Overall system structure
Application is structured into clear modules (users, hotels, bookings, images, importer) with separate routers and admin views, showing intentional modularity; however it remains a single monolith without multi-service decomposition or advanced config/secret management.
Security & Auth
5/10
Protecting data and access
Authentication and token handling are implemented (password hashing, JWT creation/validation, token-related exceptions); some secrets handling and token lifecycle concerns are present but credential/secret hygiene and revocation flows are not fully addressed in the code analyzed.
Evidence
makstravel/bookings_app_fastapi/app/users/auth.py: password hashing, verify_password and create_access_token implementation
makstravel/bookings_app_fastapi/app/users/dependencies.py: JWT parsing and ExpiredSignatureError handling
makstravel/tron_generate_wallet/tron_wallet/services/encryption_service.py: use of Fernet for encrypting mnemonic data
Reliability & Observability
5/10
Stability and monitoring
Observability and basic reliability are present - Sentry initialization, structured logging and Prometheus metrics plus test fixtures - but advanced reliability patterns (retries with backoff, circuit breakers, graceful shutdown beyond basic startup) are not evident.
Evidence
makstravel/bookings_app_fastapi/app/main.py: Sentry init and logging of request process time via middleware
makstravel/bookings_app_fastapi/app/logger.py: CustomJsonFormatter (structured logging)
makstravel/bookings_app_fastapi/app/tests/conftest.py: test fixtures preparing test DB and integration test client
Verified artifacts
Expertise
Python• Middle
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Microservices & API Architecture• Middle
Industries
Blockchain & Crypto• Middle
Travel & Tourism• Middle
Recommendations
- Develop REST/async backends that require moderate domain logic and DB complexity - implement booking, inventory, or scheduling features (use the DAO, async sessions and CTE patterns).
- Build integration work that connects APIs to background processing and monitoring - add Celery tasks, Prometheus metrics, and Sentry instrumentation where needed.
- Work on database-heavy features including schema migrations and query tuning - expand migration history and add performance tests and indexes guided by queries.
- Harden production readiness: implement cache invalidation policies, structured retry/backoff for external calls, secrets management (do not commit SECRET_KEY), and rate limiting for public endpoints.
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
A backend-focused generalist at a solid middle level who builds end-to-end Python web services with tests and application instrumentation. The strongest proven skill is backend API and observability integration, demonstrated by Prometheus/Grafana entries in docker-compose and the Instrumentator setup plus Sentry initialization in app/main.py. There is limited evidence of production-grade CI/CD, IaC, cloud autoscaling or deployment strategies beyond docker-compose and container images.
CI/CD Pipelines
1/10
Automated build and deploy
Minimal CI/CD artefacts - no pipeline workflows, only local build/run artefacts (Dockerfiles / compose).
Infrastructure as Code
1/10
Managing servers with code
Infrastructure-as-code is limited to docker-compose and Dockerfiles; no remote state, Terraform/Pulumi, or environment-separated IaC modules are present.
Containerization & Orchestration
2/10
Working with containers
Basic containerization and local orchestration via docker-compose; Dockerfiles are single-stage and there is no Kubernetes/GitOps or tuned pod-level resilience settings.
Observability & Monitoring
3/10
Watching system health
Reasonable application-level observability: Prometheus + Grafana in compose, Prometheus instrumentation in the app and Sentry initialization; no alerting rules, SLOs or alert routing are present.
Reliability & Incident Response
2/10
Keeping systems up
Some reliability primitives (Sentry, request timing middleware, restart policies in compose) but no deploy strategies, runbooks, rollback criteria or chaos/DR evidence.
Cloud & Cost Optimization
1/10
Smart use of the cloud
Minimal cloud/cost work - the project uses standard service images and async clients but lacks autoscaling, spot/eviction strategies, IAM/workload-identity or rightsizing artifacts.
Expertise
Observability & Monitoring• Middle
Industries
Blockchain & Crypto• Middle
Travel & Tourism• Middle
Technologies
Containers
Docker Compose• 4y+
Prometheus
Django• 4y+
Grafana• 4y+
Recommendations
- Develop and own backend APIs, telemetry integration and observability (instrumentation, metrics, dashboards, and Sentry) for small-to-medium services.
- Harden and containerize services for production: add multi-stage Dockerfiles, non-root users, image scanning, and CI pipelines that build, test and push signed artifacts.
- Add deployment and infra-as-code ownership: implement Terraform/CloudFormation or CDK with remote state and basic environment separation for staging/production.
- Build on testing and release practices: extend integration tests into CI, add deploy gates, and codify rollback criteria and simple runbooks for incidents.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: