Maks Travel
Python Developer
4+ years exp
Python
SQL
Data Wrangling & Cleaning: 6/10
Reproducibility & Notebook Hygiene: 5/10
Invite to interview
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.
Phone
Technical skills
Languages
2
Python
SQL
Python
7
Celery
Django
FastAPI
SQLAlchemy
Asyncio
aiogram
Pydantic
DevOps
8
Grafana
Docker
Git
GitLab CI
Kibana
Rest API
Docker Compose
CI/CD
AI/ML
3
LangChain
LlamaIndex
Ollama
Other
14
PostgreSQL
Redis
Pytest
Sentry
Alembic
Apache Kafka
Django REST Framework
ElasticSearch
Aiohttp
Prometheus
Uvicorn
RabbitMQ
Nginx
Containers
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
PostgreSQL
Redis
Celery
Docker
Docker Compose
Git
GitLab CI
CI/CD
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
Django
FastAPI
SQLAlchemy
aiogram
Docker
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• since 2022 • Middle
PostgreSQL• since 2022
Redis• since 2022
SQLAlchemy• since 2022
FastAPI• since 2022
Apache Kafka
Asyncio• since 2022
Celery• since 2022
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• since 2022
Prometheus
Django• since 2022
Grafana• since 2022
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: