Gleb Kalashnikov
Freelance Developer
4+ years exp
2+ projects
JavaScript
Python
TypeScript
SQL
Data Pipeline & Feature Engineering: 4/10
Active 21 day ago
+7 (778) 9405226 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
I am a Middle Python Backend Developer with hands-on experience in designing, developing, and maintaining scalable backend applications. My primary expertise lies in Python, Django, Django REST Framework, and FastAPI, with a strong focus on building secure, reliable, and high-performance RESTful APIs.
I have experience working with PostgreSQL, Redis, Celery, Docker, Git, and Linux (WSL/Ubuntu). I am familiar with database design, API integration, asynchronous task processing, authentication and authorization, and deployment using containerized environments.
My background in Cybersecurity helps me write secure and maintainable code while following best practices for application architecture and data protection. I enjoy solving complex technical problems, optimizing backend performance, and continuously improving system reliability.
I have worked on projects involving:
REST API development using Django REST Framework and FastAPI.
Background task processing with Celery and Redis.
PostgreSQL database design, migrations, and optimization.
Dockerized development environments and deployment workflows.
Integration with third-party APIs and external services.
Authentication, authorization, and role-based access control.
Multi-language web applications and CMS functionality.
Backend architecture, debugging, testing, and performance optimization.
I am passionate about backend development, software architecture, and cybersecurity. I continuously expand my knowledge of modern technologies and strive to write clean, scalable, and production-ready code.
Technical skills
JavaScript
Python• Middle • 3y+
TypeScript
SQL
Python
FastAPI
Pydantic
Uvicorn
HTTPX
Celery
Django
Flask
Databases
SQLite
Redis
PostgreSQL• 4y+ • 2 projects
Google BigQuery
AI/ML
LangChain
OpenAI SDK
RAG
TF-Keras
Embeddings
huggingface_hub
Vertex AI
Claude Code
Anomaly Detection
Frontend
Bootstrap
React.js
Angular
DevOps
Git
Rest API
AWS Lambda
AWS
CI/CD
Kubernetes
Docker
Google Cloud Run
GCP
Google GKE
Azure DevOps
Azure
Helm
Cybersecurity
Nmap• 3y+
GDPR
Timeline
Full Stack Developer
•
Middle
Freelance
•
Freelance
Built web applications and Telegram bots for customer needs. Took responsibility for development from initial idea to implementation and delivery. Performed ongoing support and bug fixes for existing solutions.
Pythonsince 2022
Gitsince 2022
GitLab CI
GitHub Actions
Flask
FastAPI
PostgreSQL
Redis
Celery
RabbitMQ
Tailwind CSS
Bootstrap
Jira
КарТУ (бывш. КарГТУ, КарПИ)
Bachelor's Degree •
Системы информационной безопасности
Full Stack Developer
•
Middle
TOO Travel House
•
Full-Time
Python
python-telegram-bot
WordPress
JavaScript
Backend Developer (OFD project support)
•
Middle
IT Analytics
•
Full-Time
Supported an Fiscal Data Operator-related project by writing new features and fixing bugs. Worked on backend changes and maintenance tasks to keep the product functional and stable. Delivered updates based on reported issues and implementation needs.
Python
Django REST Framework
Git
CI/CD
Ubuntu
Nuxt.js
Middle AI/ML Engineer
Confidence: Medium LLM Engineer
A practical LLM-focused engineer at a middle level who builds applied RAG pipelines and small ML demos. The strongest proven skill is building RAG ingestion and indexing - demonstrated by rag_crawl.py which crawls pages, filters and chunks text, and persists embeddings into a Chroma collection. There is limited evidence of production-grade MLOps, large-scale training, quantization or research-level model engineering in the public code.
Model Architecture & Training
2/10
How well models are designed and trained
Minimal custom model engineering - a straightforward Keras/TensorFlow MNIST model is trained and evaluated but there are no custom losses, advanced tuning, distributed training or reproducible experiment scaffolding.
Evidence
digit_neural/main.py: keras.Sequential model definition and model.fit(...) / model.evaluate(...) usage
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Applied data ingestion and preprocessing for a RAG pipeline - web crawling with site-filtering, metadata handling, robust chunking and deduplication before embedding and indexing into a Chroma vector store.
Evidence
rag-model/rag_crawl.py: extract_profile_links, get_html, is_same_site and use of WebBaseLoader + RecursiveCharacterTextSplitter
rag-model/rag_data.py: WebBaseLoader -> split_documents -> embedding + Chroma persistence
Experimentation & Evaluation
2/10
How results are measured and tested
Basic evaluation is present (validation_split during training and model.evaluate) but there is no experiment tracking, run history, baselines, ablations or reproducible experiment infra (W&B/MLflow/Optuna etc.).
Evidence
digit_neural/main.py: model.fit(..., validation_split=0.2) and model.evaluate(...)
MLOps & Deployment
2/10
How models are shipped to production
Some operational steps are implemented (persisting Chroma embeddings, a Django app scaffold), but no evidence of deployment automation, monitoring, CI/CD, model versioning or drift detection.
Evidence
rag-model/rag_crawl.py: vs.persist() - vector store persisted to disk
hackathon/settings/base.py: Django ASGI/WSGI configuration and typical settings present
Computational Efficiency
1/10
How efficiently computing resources are used
No demonstrated computational-efficiency work - no quantization, GPU profiling, batching/throughput engineering or memory optimizations beyond default training batch size.
Evidence
digit_neural/main.py: model.fit(batch_size=32) (only basic batch parameter visible)
Research Depth & Innovation
1/10
Depth of research and new ideas
No research-level contributions or novel algorithmic work - projects implement standard libraries and patterns rather than new architectures or reproduced paper results.
Evidence
rag-model/query_rag.py: LangChain + Chroma retrieval and OpenAI LLM usage
digit_neural/main.py: standard MNIST example architecture
Expertise
RAG• Middle
Industries
Artificial Intelligence• Middle
Education• Middle
Technologies
Python• Middle • 3y+
LangChain
Embeddings
OpenAI SDK
huggingface_hub
Django
RAG
TF-Keras
Models• mentioned only
Recommendations
- Productionize the RAG pipeline - add robust retries/backoff, request rate control, logging, caching, schema for metadata and integration tests for retrieval correctness.
- Add experiment tracking and reproducibility - integrate W&B or MLflow, record seeds, hyperparameters, runs and evaluation scripts for the MNIST training and any future models.
- Harden deployments and security - remove hardcoded secrets, ensure DEBUG=False for production, and externalize credentials with proper env handling and secrets management.
- Work on efficiency and inference profiling - run GPU/CPU profiling, experiment with batching, quantization and smaller embedding models to reduce latency and cost.
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-focused engineer at a middle level who produces clean, tested REST endpoints and deliberate raw-SQL data handling. The strongest proven skill is building small, well-validated HTTP APIs with concrete artifacts in app/main.py, app/models.py and tests/test_api.py. The public code lacks advanced production patterns - no migration history beyond init for the small service, limited resilience patterns, and some insecure defaults (hardcoded secret/debug settings) are visible.
API Design
4/10
How well APIs are designed
Clear REST endpoints with typed request/response models and correct status codes; basic error contracts and some integration tests, but no versioning, pagination, or advanced idempotency design.
Evidence
url-shortener/app/main.py: /shorten and /{code} endpoints with response_model and explicit status codes
url-shortener/app/models.py: Pydantic ShortenRequest and ShortenResponse with validation (HttpUrl, pattern limits)
url-shortener/tests/test_api.py: integration tests covering shorten, custom_code conflict and redirect behavior
Data Layer & Database
5/10
Working with databases
Deliberate raw-SQL schema and connection handling with index and uniqueness, PRAGMA tuning and context-managed commits; no multi-step migration history or advanced query optimization beyond index/unique constraints.
Evidence
url-shortener/app/db.py: SCHEMA with index, connect() contextmanager, PRAGMA journal_mode=WAL and foreign_keys=ON
url-shortener/app/main.py: parameterized INSERT queries and sqlite3.IntegrityError handling for uniqueness
hackathon/apps/auths/migrations/0001_initial.py: presence of Django migration file (schema artifact)
Scalability & Performance
3/10
Handling load and speed
Some operational choices for concurrency (WAL, check_same_thread) and a retry loop to handle code collisions, but no caching strategy, connection pooling, queue-based decoupling, or measured performance work.
Evidence
url-shortener/app/db.py: PRAGMA journal_mode=WAL and sqlite3.connect(..., check_same_thread=False)
url-shortener/app/main.py: MAX_RETRIES loop to handle code collisions
System Architecture
4/10
Overall system structure
Small, sensible module separation (settings, db, models, logging, main) and explicit background tooling configuration (Celery) in other projects; overall monolithic apps without demonstrated cross-service contracts or elaborate decomposition.
Evidence
url-shortener/app/main.py, app/db.py, app/settings.py: modular structure separating concerns
security_hacathon/settings/base.py: Celery and Redis configuration indicating awareness of background work and system concerns
Security & Auth
5/10
Protecting data and access
Good input validation (Pydantic) and use of parameterized SQL to avoid injection; JWT usage in Django app shows auth awareness, but there are secrets-in-code and some config left in insecure defaults.
Evidence
url-shortener/app/models.py: HttpUrl and regex pattern to validate custom_code
url-shortener/app/main.py: parameterized queries (?,?,) instead of string interpolation
security_hacathon/apps/auths/views.py: use of rest_framework_simplejwt RefreshToken for authentication
Reliability & Observability
4/10
Stability and monitoring
Basic logging and test coverage for key flows are present, and error paths are handled; full resilience patterns (timeouts, retries with backoff, circuit breakers, structured correlation ids, graceful shutdown) are not implemented.
Evidence
url-shortener/app/logging_config.py: logging setup exists
url-shortener/app/main.py: logger calls on info/warning/error and explicit HTTPException usage
url-shortener/tests/test_api.py: pytest-based integration tests validating common and edge flows
Expertise
Python• Middle
Microservices & API Architecture• Middle
Backend AI & LLM• Junior
Industries
Cybersecurity• Middle
Technologies
Redis
Rest API
FastAPI
SQLite
Celery
Pydantic
HTTPX
Uvicorn
Recommendations
- Harden deployments: remove hardcoded secrets, ensure DEBUG is false in production, and add environment-based config validation.
- Introduce migrations and a real RDBMS for production (Postgres) and add schema migration tooling and tests for schema evolution.
- Add resilience and observability: timeouts on external calls, retries with exponential backoff where needed, structured logs with request ids and health/metrics endpoints.
- Expand background processing experience: implement Celery tasks with idempotency and backoff for long-running work and add end-to-end tests for those flows.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium UI Engineer
A junior frontend-focused developer who produces server-rendered UI using Django templates and Bootstrap. The strongest proven skill is building functional, responsive server-rendered pages - for example the product listing and product_page templates in olx_copy/apps/main/templates/main. There is limited evidence of client-side state management, performance engineering, automated tests or advanced accessibility work in public code.
UI Component Architecture
2/10
How interface parts are built
Mostly server-rendered templates with repeated markup and no component system or composition patterns; templates are functional but not architected as reusable UI components.
Evidence
olx_copy/apps/main/templates/main/all_products.html: repeated card markup for product items without partials/includes
utys.github.io/index.html: monolithic static page combining layout, header and content in one file
Responsive & Cross-browser
3/10
Works on all screens and browsers
Uses Bootstrap for responsive behavior with proper viewport and navbar toggler, but lacks advanced responsive techniques like container queries, RTL/i18n readiness, or feature detection.
Evidence
utys.github.io/index.html: <meta name="viewport"> and Bootstrap navbar with toggler
mirgovorit_test_task/apps/main/templates/add_product_to_recipe.html: Bootstrap navbar and responsive container usage
Performance Optimization
1/10
Speed of the interface
No measurable performance work or build-time optimization; assets are referenced directly and there is no evidence of lazy-loading, code-splitting or bundle analysis.
Evidence
utys.github.io/index.html: direct <img> tags for large images and CDN CSS/JS includes
olx_copy/apps/main/templates/main/product_page.html: image delivered via {{ product.photo.url }} without lazy-loading attributes
Accessibility & Semantics
3/10
Usable for everyone
Basic accessibility practices are present (aria attributes on toggler, labels for form fields, alt text), but no evidence of systematic a11y testing or custom widget focus management.
Evidence
utys.github.io/index.html: navbar toggler with aria-controls and aria-label
mirgovorit_test_task/apps/main/templates/add_product_to_recipe.html: <label> elements paired with form controls
State Management & Data Flow
2/10
Managing data in the app
Server-side form flows and simple GET/POST actions are used, but there is no evidence of advanced state management patterns, optimistic updates, request cancellation or state machines.
Evidence
olx_copy/apps/main/templates/main/add_product.html: {{ form.as_p }} and a multipart/form form submit
mirgovorit_test_task/apps/main/templates/recipes.html: form with hidden recipe_id and simple GET-based actions
UX & Visual Polish
3/10
Look and feel quality
Visual polish and basic UX (cards, hero section, custom fonts) are present; however edge states, skeletons, progressive enhancement and undo flows are not implemented.
Evidence
utys.github.io/static/css/style.css: custom font-face rules and header background image
utys.github.io/index.html and olx_copy/apps/main/templates/main/fail.html: explicit error page indicating handling of a failed add-product flow
Expertise
HTML & CSS• Junior
Modern Web Frameworks• Junior
Technologies
Bootstrap
Recommendations
- Work on server-rendered feature pages and small marketplace MVPs - implement modular template partials and reusable components for listings and cards.
- Build content-driven marketing sites and static landing pages using Bootstrap and semantic HTML, improving accessibility and responsive behavior.
- Contribute to simple CRUD admin tools (Django-based) where server-side forms and templating are primary, and iterate by adding progressive enhancement like lazy-loading images.
- Practice measurable performance and a11y improvements - add image optimization, lazy-loading, Lighthouse audits and ARIA best practices to existing templates.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: