Django vs Django REST Framework

Django is a full web framework: ORM, migrations, admin, auth, forms, templates. It has no API layer: a Django view returns whatever you build, and turning models into JSON, validating input, and handling auth for API clients is left to you. Django REST Framework (DRF) is that layer, built on Django’s request cycle, ORM and auth. The interview question is usually “what does DRF add?”, and the senior part is knowing where it costs you.

What DRF adds

The same endpoint, both ways:

# Plain Django: you parse, validate and serialise by hand
def order_detail(request, pk):
    order = get_object_or_404(Order, pk=pk, customer=request.user)
    return JsonResponse({"id": order.pk, "total": str(order.total)})

# DRF: the serializer and viewset do it, with auth and permissions declared
class OrderViewSet(viewsets.ReadOnlyModelViewSet):
    serializer_class = OrderSerializer
    permission_classes = [IsAuthenticated]

    def get_queryset(self):
        return Order.objects.filter(customer=self.request.user)

get_queryset scoped to the user is the authorization: a viewset that returns Order.objects.all() lets any authenticated user read any order.

What DRF costs

• Serialisation is slow on large lists. ModelSerializer builds field objects and validates per instance; rendering thousands of rows can cost more than the query. Paginate, use flatter serializers, or .values() for hot read paths (drf/12).
• Nested serializers hide N+1 queries until select_related / prefetch_related are applied in get_queryset (N+1 in Django: select_related, prefetch_related, fetch modes).
• It is synchronous at heart. Django runs async views, but DRF’s view and serializer layer is sync; an async API in a Django codebase means Django Ninja or plain async views instead.

DRF, Django Ninja or FastAPI

• DRF when the codebase is already Django and you want its ecosystem (admin, auth, permissions, browsable API) with the most mature tooling.
• Django Ninja when you are in Django but want Pydantic schemas, type hints and async views.
• FastAPI for a new standalone service with type-driven validation, native async and generated OpenAPI; you bring your own ORM and admin.

The deciding factor is almost always the existing codebase, not benchmarks.

Related

• Django and DRF: the request path - DRF overview and request flow
• Django serializers vs DRF serializers - Django’s own serializers vs DRF’s
• FastAPI - the FastAPI side of the comparison
• Service layer vs fat models in Django - where business logic lives behind the API