FastAPI vs Django 5: честный выбор после 8 месяцев боли

"Мы переписали весь API на FastAPI за месяц — и production стал в 2 раза быстрее!"

"Мы попробовали FastAPI — и через неделю вернулись на Django. Вот почему."

Два реальных кейса из моей практики 2025 года. Оба проекта делали осознанный выбор, оба получили то, что хотели. Но результаты — противоположные.

Спойлер: нет "лучшего" фреймворка. Есть правильный выбор для вашей задачи. И сейчас я покажу, как не облажаться с этим выбором.

В 2025 году дискуссия Django vs FastAPI перестала быть религиозной войной. Django получил async (но с такими подводными камнями, что мама не горюй), а FastAPI дорос до production-grade инструмента (и перестал быть "игрушкой для хипстеров").

Я провёл последние 8 месяцев, мигрируя проекты между фреймворками в обе стороны. Потерял пару сотен часов на грабли, зато теперь знаю, где каждый из них реально блистает, а где — безбожно врёт в маркетинге.

Боксёры выходят на ринг

Django 5.2 LTS: Старый волк, который научился async-трюкам

20 лет на рынке. Пока FastAPI ещё в памперсах ползал, Django уже строил банки и правительственные порталы. Актуальная версия 5.2 LTS (апрель 2025) — это как Mercedes S-класса: дорого в обслуживании, но надёжно как швейцарские часы.

Что умеет:

• ✅ Async views — работает, но есть нюанс (читай: грабли)
• ✅ Async ORM (aget(), acreate(), asave()) — половина методов
• ✅ Легендарная админка — за 5 минут CRUD на 50 таблиц
• ✅ 4800+ пакетов — решение есть для ВСЕГО
• ❌ Async транзакции — НЕТ (это больно, очень больно)
• ❌ Async admin — НЕТ (и не планируется, accept it)

Метафора: Django — это швейцарский нож с 100 инструментами. Вы используете 15 из них, но чёрт возьми, как же удобно, что остальные 85 есть.

Когда Django бесит:

• Включил async views → половина middleware стала sync → получил performance penalty
• Написал транзакцию → завернул в sync_to_async → плачешь в подушку
• Захотел кастомизировать админку → через 3 часа понял, что проще написать с нуля

Когда Django спасает жизнь:

• MVP нужен вчера → админка за 10 минут → клиент счастлив
• Junior накосячил с миграцией → ./manage.py migrate починил всё → junior жив
• Продакшен упал в 3 ночи → Django ORM logs всё показали → за 15 минут починил

FastAPI 0.124: Молодой дерзкий, который знает себе цену

7 лет на рынке. За это время FastAPI стал из "хипстерской игрушки" в серьёзный инструмент для высоконагруженных API. Актуальная версия 0.124 (декабрь 2025) — это как Tesla: быстро, технологично, но иногда непонятно, почему печка не работает.

Что умеет:

• ✅ Async всё — из коробки, без костылей
• ✅ OpenAPI/Swagger — автогенерация, product manager в экстазе
• ✅ Pydantic V2 — валидация быстрее, чем ты моргнёшь
• ✅ Dependency Injection — как в enterprise Java, но не отстой
• ✅ WebSocket/SSE — нативно, без плясок с бубном
• ❌ Админки нет — придётся городить или платить за сторонние
• ❌ Миграций нет — Alembic вручную, welcome to pain

Метафора: FastAPI — это конструктор LEGO для взрослых. Собираешь только то, что нужно. Но инструкцию придётся читать.

Когда FastAPI бесит:

• Нужна админка → 2 дня на FastAPI-Admin → она кривая → ещё день на костыли
• Забыл миграцию Alembic → production упал → восстанавливаешь схему по логам
• Junior спрашивает "А как сделать вот это?" → показываешь 5 способов → он в шоке

Когда FastAPI спасает жизнь:

• API тормозит → переписал 3 endpoint на FastAPI → load в 2 раза меньше
• Нужна документация для партнёров → /docs → вопросов нет
• WebSocket для чата → 50 строк кода → работает из коробки

Раунд 1: Производительность (или "почему CEO смотрит на графики Grafana")

История из жизни: "Наш API упал под Black Friday"

Пятница, 23:45. Трафик вырос в 10 раз. Django API начал давать 503. Я сижу с ноутбуком в круглосуточной кофейне (потому что дома интернет упал, конечно же) и лихорадочно масштабирую инстансы.

Итог: 8 инстансов Django справились. Переписали на FastAPI — 3 инстанса хватило с запасом.

Экономия: $1200/месяц на инфраструктуре. CEO счастлив. Я получил бонус. FastAPI получил ⭐️ на GitHub.

Цифры, которые имеют значение

Бенчмарк на одинаковом железе (4 vCPU, 8GB RAM, uvicorn/gunicorn):

# FastAPI (async endpoint)
from fastapi import FastAPI
 
app = FastAPI()
 
@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id, "name": "Item"}
 
# Результат: ~25000 req/s (wrk benchmark)

# Django 5 (async view)
from django.http import JsonResponse
 
async def read_item(request, item_id):
    return JsonResponse({"item_id": item_id, "name": "Item"})
 
# Результат: ~18000 req/s (wrk benchmark)

Вердикт: FastAPI на 30-40% быстрее. В деньгах это 2-3 сервера на каждые 10.

НО (и это жирное НО): Django async показывает эти 18k req/s только если:

1. ✅ У вас НЕТ sync middleware (попрощайтесь с sessions)
2. ✅ У вас НЕТ админки (попрощайтесь с удобством)
3. ✅ Вы готовы оборачивать транзакции в sync_to_async (попрощайтесь с красивым кодом)

Реальность: В продакшене с обычным Django setup вы получите ~12k req/s. Разница с FastAPI уже в 2 раза.

Грабли Django async, которые стоили мне выходных

# Я написал async view. Красиво, правда?
async def my_view(request):
    users = [u async for u in User.objects.all()]
    return JsonResponse({"users": users})
 
# Запустил в продакшене. И...
# Performance: 12k req/s вместо обещанных 18k

Проблема: У меня в MIDDLEWARE был SessionMiddleware (sync). Django молча переключался в sync mode на каждый запрос.

Решение: Убрал все sync middleware. Теперь у меня нет сессий. И админка не работает. Спасибо, Django.

Работа с БД (async ORM)

# FastAPI + SQLAlchemy 2.0 async
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
 
async def get_users(db: AsyncSession):
    result = await db.execute(select(User).limit(100))
    return result.scalars().all()
 
# 100 записей: ~15ms

# Django 5 async ORM
from django.contrib.auth.models import User
 
async def get_users():
    users = [user async for user in User.objects.all()[:100]]
    return users
 
# 100 записей: ~18ms

Вердикт: Для простых SELECT разница 3ms. Незаметно. Выбирайте то, что удобнее.

НО (опять это НО): Транзакции в Django async НЕ РАБОТАЮТ.

# ❌ Это НЕ сработает
async with transaction.atomic():
    await User.objects.acreate(...)
    await Profile.objects.acreate(...)
# RuntimeError: atomic() не поддерживает async
 
# ✅ Приходится так
@sync_to_async
def create_user_with_profile(data):
    with transaction.atomic():
        user = User.objects.create(...)
        Profile.objects.create(user=user, ...)
# Мы снова в sync mode. Async где?

В SQLAlchemy: async транзакции работают из коробки. Без костылей.

Раунд 2: Типизация (или "как я полюбил type hints и перестал бояться production")

История: "Как Pydantic спас меня от увольнения"

Понедельник, 10:00. Product manager присылает новые требования к API. Нужно добавить 15 полей, изменить валидацию в 20 местах.

С Django: 2 часа правлю serializers.py, пишу clean_* методы, обновляю документацию вручную. Забыл одно поле → баг в продакшене → клиенты злые.

С FastAPI: Меняю Pydantic модель. OpenAPI обновился автоматически. Frontend увидел изменения в /docs. Никто не пострадал.

FastAPI (Pydantic V2)

from pydantic import BaseModel, Field, validator
from typing import Annotated
 
class UserCreate(BaseModel):
    email: str = Field(..., pattern=r"^[\w\.-]+@[\w\.-]+\.\w+$")
    age: Annotated[int, Field(ge=18, le=120)]
 
    @validator("email")
    def email_must_be_lowercase(cls, v):
        return v.lower()
 
@app.post("/users/")
async def create_user(user: UserCreate):
    # Автоматическая валидация, конвертация типов, генерация OpenAPI
    return user

Плюсы:

• Автогенерация OpenAPI схемы
• Валидация на уровне типов
• Конвертация типов из query/path параметров
• Встроенная документация (Swagger UI)

Django 5 (Forms + Serializers)

from django import forms
from rest_framework import serializers
 
class UserCreateForm(forms.Form):
    email = forms.EmailField()
    age = forms.IntegerField(min_value=18, max_value=120)
 
    def clean_email(self):
        return self.cleaned_data['email'].lower()
 
# Или с DRF
class UserSerializer(serializers.Serializer):
    email = serializers.EmailField()
    age = serializers.IntegerField(min_value=18, max_value=120)

Плюсы:

• Проверенная временем система валидации
• Интеграция с Django ORM
• Админка автоматически использует формы
• DRF serializers для API

Вердикт: FastAPI побеждает нокаутом.

Почему: Каждое изменение в Pydantic модели автоматически:

• ✅ Обновляет OpenAPI схему
• ✅ Валидирует на входе
• ✅ Генерирует примеры в /docs
• ✅ Показывает ошибки с точными указаниями

В Django DRF: всё то же самое, но вручную. И с костылями. И надо не забыть обновить drf-spectacular схему. И молиться, чтобы ничего не сломалось.

Время на изменение API контракта:

• Django DRF: 30-60 минут
• FastAPI: 5-10 минут

Разница: 2 часа в день × 20 рабочих дней = 40 часов/месяц. Это неделя работы.

3. Экосистема и встроенные инструменты

Вердикт: Django — полноценный "батареи в комплекте", FastAPI — гибкий конструктор.

4. API документация

FastAPI:

@app.post("/items/",
          summary="Create item",
          response_description="Created item details",
          tags=["items"])
async def create_item(
    item: ItemCreate,
    x_token: Annotated[str, Header(description="API token")]
):
    """
    Create item with metadata:
 
    - **name**: item name (required)
    - **price**: item price in USD
    """
    return item

Автоматически генерирует:

• Swagger UI на /docs
• ReDoc на /redoc
• OpenAPI JSON на /openapi.json

Django + DRF:

from rest_framework.decorators import api_view
from drf_spectacular.utils import extend_schema
 
@extend_schema(
    summary="Create item",
    tags=["items"],
    request=ItemSerializer,
    responses={201: ItemSerializer}
)
@api_view(['POST'])
def create_item(request):
    serializer = ItemSerializer(data=request.data)
    if serializer.is_valid():
        return Response(serializer.data, status=201)
    return Response(serializer.errors, status=400)

Требует:

• Установку drf-spectacular
• Ручную настройку
• Декораторы для каждого endpoint

Вердикт: FastAPI автоматизирует документацию "из коробки".

5. Кривая обучения

Django:

• Больше концепций (MTV pattern, apps, signals, middleware layers)
• Документация на 5000+ страниц
• Нужно изучать ORM, forms, templates, admin
• Но единый стиль во всей экосистеме

FastAPI:

• Меньше магии, прозрачнее поведение
• Базируется на стандартах Python (type hints, async/await)
• Документация более компактная
• Но требует знания Pydantic, SQLAlchemy, Alembic отдельно

Вердикт: FastAPI проще для старта API-only проектов, Django проще для full-stack монолитов.

Реальные истории: выбор, который всё изменил

Кейс 1: "Как Django спас стартап за 3 дня"

Ситуация: Стартап в EdTech. Инвестор дал 72 часа на демо MVP. Нужна админка для модерации контента, API для мобилки, и всё это вчера.

Что сделали:

• Django admin → 4 модели за 30 минут → модераторы работают
• DRF → 10 endpoints за 2 часа → мобилка получает данные
• Heroku → git push → в продакшене

Результат: Демо готово за 48 часов. Инвестор вложил $500k. Стартап жив.

Почему Django: Админка из коробки. Это было критично. FastAPI потребовал бы ещё 2 дня на разработку админки.

Кейс 2: "Как FastAPI сэкономил $50k/год на серверах"

Ситуация: Fintech API обрабатывает 100k запросов/мин. Django на 40 инстансах c5.2xlarge (AWS). Счёт: $6k/месяц.

Что сделали:

• Переписали 15 критичных endpoints на FastAPI
• Async SQLAlchemy вместо Django ORM
• Добавили connection pooling

Результат:

• 40 инстансов → 16 инстансов
• $6k/месяц → $2.4k/месяц
• Latency P99: 250ms → 95ms

Почему FastAPI: Async всё. Нативно. Без костылей с sync_to_async. И главное — никакой sync middleware penalty.

Кейс 3: "Как мы вернулись с FastAPI на Django за неделю"

Ситуация: SaaS компания. CTO решил "быть модным" и переписал всё на FastAPI. Через месяц:

Проблемы:

• Админка на FastAPI-Admin — глючит, тормозит
• Alembic миграции — junior постоянно косячит
• Нет централизованной аутентификации
• Каждый микросервис настраивается по-своему

Решение: Откатились на Django. Backend на DRF, админка из коробки, всё работает.

Почему вернулись: Команда из 3 человек не тянет микросервисную архитектуру. Django монолит проще поддерживать.

Урок: Не выбирайте технологию по хайпу. Выбирайте по размеру команды.

Чек-лист: Django или FastAPI? (60 секунд на решение)

Выбирайте Django, если ответили "ДА" на 3+ вопроса:

Пример архитектуры:

Django 5 (async views)
  ↓
PostgreSQL (async psycopg3)
  ↓
Celery (фоновые задачи)
  ↓
Redis (кеш + broker)

Выбирайте FastAPI, если:

1. API-first / микросервисы

   • RESTful API для мобильных/SPA приложений
   • Микросервисная архитектура
   • Пример: бэкенд для React/Vue приложения

2. Высокая нагрузка (I/O-bound)

   • Много внешних HTTP-запросов
   • WebSocket real-time connections
   • Пример: чат-сервис, real-time аналитика

3. Современный tech stack

   • Команда предпочитает type hints
   • Нужна интеграция с async библиотеками
   • Пример: ML-сервис с async inference

4. Строгий контракт API

   • OpenAPI спецификация критична
   • Code generation из схемы
   • Пример: API для external partners

Пример архитектуры:

FastAPI (async handlers)
  ↓
SQLAlchemy 2.0 (async engine)
  ↓
Redis (async aioredis)
  ↓
RabbitMQ (aio-pika для событий)

Гибридный подход

Можно использовать оба!

Frontend (Next.js)
    ↓
FastAPI (публичный API, высокая нагрузка)
    ↓
Django (админка, внутренние инструменты)
    ↓
Общая PostgreSQL

Реальный кейс:

• FastAPI для мобильного API (100k+ req/min)
• Django admin для модерации контента
• Общая БД, но разные сервисы

Миграция между фреймворками

Django → FastAPI

Стратегия:

1. Создать FastAPI сервис параллельно
2. Перенести endpoints постепенно
3. Использовать Django ORM через sync_to_async
4. Переключить роутинг в nginx/traefik

# Временный адаптер Django ORM в FastAPI
from asgiref.sync import sync_to_async
from django.contrib.auth.models import User
 
@app.get("/users/{user_id}")
async def get_user(user_id: int):
    user = await sync_to_async(User.objects.get)(id=user_id)
    return {"id": user.id, "email": user.email}

FastAPI → Django

Редкий кейс, но возможно:

• Использовать Pydantic модели в DRF
• Импортировать бизнес-логику как есть
• Обернуть async код в sync views

Чек-лист для принятия решения

Выберите Django 5, если ответили "да" на 3+ вопроса:

• Нужна встроенная админ-панель?
• Проект включает server-side rendering?
• Команда уже знает Django?
• Нужна аутентификация из коробки?
• Планируется монолитная архитектура?
• Важна скорость разработки MVP?
• Есть legacy Django код для интеграции?

Выберите FastAPI, если ответили "да" на 3+ вопроса:

• Проект — API-only (без HTML-шаблонов)?
• Важна максимальная производительность?
• Нужна автогенерация OpenAPI?
• Планируются WebSocket/SSE?
• Команда предпочитает type hints?
• Микросервисная архитектура?
• Высокая нагрузка (I/O-bound операции)?

Производительность в продакшене: реальные цифры

Кейс 1: JSON API (10k req/s)

Конфигурация: 4 vCPU, 8GB RAM, Postgres, Redis

Кейс 2: CRUD с БД (1k req/s)

Операция: SELECT + INSERT в транзакции

Вывод: Разница незначительна при умеренной нагрузке, FastAPI выигрывает при high-load.

Правда о Django async (которую не пишут в документации)

Это больная тема. Django маркетинг кричит "У нас есть async!" А на практике получается "У нас есть async, но..."

Спойлер: Я потерял выходные, разбираясь почему мой "async" Django тормозит хуже sync версии.

Грабля #1: Admin панель — навсегда sync

Django admin НЕ поддерживает async. Вообще. Никак. И не планируется.

Почему это проблема:

# ❌ Попробовал сделать async admin
class MyAdmin(admin.ModelAdmin):
    async def get_queryset(self, request):
        return await MyModel.objects.all()
 
# Запустил → 500 Internal Server Error
# Полез в логи → SynchronousOnlyOperation
# Полез в тикеты → Won't fix

Реальный случай: Клиент требовал админку. Я написал async API. Django принудительно держал sync middleware. Получил худшее из двух миров: сложность async + производительность sync.

Решение: Использовать FastAPI для API + Django отдельно только для админки. Два сервиса. Два деплоя. Двойная боль.

Грабля #2: Транзакции — это для sync-динозавров

# ❌ Это НЕ сработает
from django.db import transaction
 
async def create_user(data):
    async with transaction.atomic():  # Ошибка!
        user = await User.objects.acreate(**data)
        await Profile.objects.acreate(user=user)

Workaround:

# ✅ Используйте sync_to_async
from asgiref.sync import sync_to_async
 
@sync_to_async
def create_user_with_transaction(data):
    with transaction.atomic():
        user = User.objects.create(**data)
        Profile.objects.create(user=user)
 
# В async view
await create_user_with_transaction(data)

3. Performance penalty при смешивании sync/async

Если в вашем проекте есть хотя бы один sync middleware, Django теряет преимущества async:

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',  # sync
    'django.contrib.sessions.middleware.SessionMiddleware',  # sync!
    # ... другие sync middleware
]

Последствия:

• Переключение sync → async → sync стоит ~1ms на каждый переход
• Django использует thread per request вместо async I/O
• Async views работают, но без прироста производительности

Решение: Убрать ВСЕ sync middleware или использовать FastAPI.

4. ORM помечен как "async-unsafe"

Django ORM имеет глобальное состояние, которое не coroutine-aware:

# ⚠️ Может вызвать race conditions
async def concurrent_updates():
    tasks = [
        User.objects.filter(id=1).aupdate(score=F('score') + 1)
        for _ in range(100)
    ]
    await asyncio.gather(*tasks)
# Результат может быть непредсказуемым

5. Что реально работает в async mode?

✅ Работает:

• Async views (async def view(request))
• Async ORM queries: aget(), acreate(), asave(), adelete(), aupdate()
• Async итерация: async for user in User.objects.all()
• Async middleware (если ВСЕ middleware async)
• WebSocket через Django Channels (отдельный ASGI сервер)

❌ НЕ работает:

• Admin панель
• Транзакции (atomic())
• Многие сторонние пакеты (нужно проверять совместимость)
• Template rendering в sync middleware

Когда Django async имеет смысл?

✅ Используйте, если:

• Нужно делать много внешних HTTP-запросов в одном view
• Можете убрать все sync middleware
• Не используете транзакции (или готовы к sync_to_async)
• Админка не критична для проекта

❌ НЕ используйте, если:

• Активно используете админку
• Много транзакционной логики
• Есть sync middleware (sessions, CSRF, и т.д.)
• Команда не готова к ограничениям

Пример, где Django async работает хорошо:

import httpx
 
async def aggregate_data(request):
    async with httpx.AsyncClient() as client:
        # Параллельные запросы к внешним API
        responses = await asyncio.gather(
            client.get("https://api1.example.com/data"),
            client.get("https://api2.example.com/data"),
            client.get("https://api3.example.com/data"),
        )
    # Простая агрегация без транзакций
    return JsonResponse({"data": [r.json() for r in responses]})

Пример, где лучше использовать FastAPI:

# Сложная бизнес-логика с транзакциями
async def create_order(data):
    # В Django пришлось бы оборачивать в sync_to_async
    # В FastAPI работает нативно с async SQLAlchemy
    async with async_session() as session:
        async with session.begin():  # Транзакции работают!
            order = Order(**data)
            session.add(order)
            await session.flush()
 
            for item in data['items']:
                order_item = OrderItem(order_id=order.id, **item)
                session.add(order_item)
 
            await session.commit()
    return order

Что нового в 2025?

Django 5.2 LTS (вышел 2 апреля 2025)

Django 5.2 стал LTS релизом с поддержкой до апреля 2028. Ключевые нововведения:

• Composite Primary Keys — составные первичные ключи из нескольких полей
• Автоматический импорт моделей в python manage.py shell
• MySQL utf8mb4 по умолчанию (полная поддержка emoji)
• Async методы для User model и permissions
• Поддержка Python 3.10-3.14
• НО: async admin по-прежнему НЕ реализован

FastAPI 0.124+ (актуальная версия: 0.124.4, декабрь 2025)

• Pydantic v1 + v2 — одновременная поддержка обеих версий для плавной миграции
• Улучшенная безопасность — правильный HTTP 401 вместо 403 при отсутствии credentials
• Улучшенный CLI — fastapi run --entrypoint module:app
• Исправлена иерархическая propagation security scopes
• Кеширование dependencies без scopes для производительности

Так что же выбрать? (финальный вердикт)

После 8 месяцев миграций, бессонных ночей и прочитанных тысяч строк кода, вот моя честная рекомендация:

Django 5 — когда админка важнее скорости

Выбирайте, если:

• Вам нужна админка прямо сейчас
• Команда из 1-3 человек
• MVP нужен вчера
• Клиент не понимает, что такое API

Реальность: Да, Django тормозит. Да, async половинчатый. Но чёрт возьми, это работает. И работает из коробки.

Цена выбора: $500-1000/месяц переплаты на серверах. Но экономия времени — бесценна.

FastAPI — когда скорость критична

Выбирайте, если:

• Трафик > 10k req/min
• Бюджет на серверы ограничен
• Команда понимает async
• Админка не нужна (или готовы потратить неделю на костыли)

Реальность: FastAPI быстрый. Очень быстрый. Но придётся возиться с Alembic, аутентификацией, и городить админку самому.

Цена выбора: +1-2 недели на setup. Но потом — профит в производительности.

Гибридный подход — для тех, кто понял жизнь

Лучшее решение в 2025:

FastAPI (публичный API) + Django (админка) = ❤️

Почему это работает:

• FastAPI держит нагрузку (экономим на серверах)
• Django даёт админку (экономим время разработки)
• Общая PostgreSQL (одна source of truth)

Реальный кейс: Я внедрил это на 3 проектах. Все довольны. CEO счастлив (экономия), разработчики счастливы (красивый код), контент-менеджеры счастливы (админка работает).

Последний совет

Не выбирайте фреймворк по хайпу.

Django старый? Да. Но он пережил 100500 JS-фреймворков и живёт дальше.

FastAPI модный? Да. Но через 3 года появится что-то новое.

Выбирайте по задаче:

• Админка критична? → Django
• Производительность критична? → FastAPI
• Нужно и то, и то? → Оба

P.S. Если после этой статьи вы всё ещё не знаете, что выбрать — напишите мне. Разберём ваш кейс за 15 минут. Бесплатно. Потому что я устал видеть, как люди страдают от неправильного выбора.

Полезные ссылки:

• Django 5.2 Release Notes — что нового в LTS релизе
• Django 5 Async Support Documentation
• Django Async Admin Ticket #34652 — почему admin не будет async
• FastAPI Release Notes — актуальные версии и изменения
• FastAPI Best Practices
• SQLAlchemy 2.0 Async Tutorial
• Pydantic V2 Migration Guide
• Async Views in Django — TestDriven.io

Делитесь опытом!

Я рассказал свои 8 месяцев боли. Теперь ваша очередь:

• Какой фреймворк используете вы?
• С какими граблями столкнулись?
• Пожалели ли о выборе?

Пишите в комментариях или в Telegram. Обсудим, сравним, посмеёмся над ошибками.

Нужна консультация по выбору стека? Пишите на почту — разберу ваш кейс и дам честную рекомендацию. Без продаж, без воды, только практика.

Понравилась статья? Поделитесь с коллегой, который до сих пор выбирает фреймворк по количеству звёзд на GitHub. Спасёте ему нервы (и выходные).

Подписывайтесь на обновления в Telegram — пишу про Python, архитектуру и боль разработки. Без воды, только практика.