DRF permissions in Django - Performance & Optimization

Performance: DRF permissions

MEDIUM IMPACT

This affects the server response time and user experience by controlling access checks before processing requests.

Checking user permissions on each API request

Django

from rest_framework.permissions import IsAuthenticated, DjangoModelPermissions
from rest_framework.views import APIView
from rest_framework.response import Response

class MyView(APIView):
    permission_classes = [IsAuthenticated, DjangoModelPermissions]

    def get(self, request):
        # process request
        return Response(data)

Using DRF's built-in permission classes centralizes checks, reduces code duplication, and leverages optimized permission evaluation.

📈 Performance GainReduces server CPU usage by avoiding redundant permission logic and improves maintainability.

Checking user permissions on each API request

Django

class MyView(APIView):
    def get(self, request):
        if not request.user.is_authenticated:
            return Response(status=403)
        if not request.user.has_perm('app.view_model'):
            return Response(status=403)
        # process request
        return Response(data)

Manually checking permissions in each view duplicates code and can cause inconsistent checks, increasing server processing time.

📉 Performance CostAdds extra CPU time per request due to repeated manual checks and branching.

Performance Comparison

Pattern	Server CPU Usage	Code Duplication	Response Delay	Verdict
Manual permission checks in each view	High (repeated checks)	High	Increased delay	[X] Bad
DRF built-in permission classes	Low (centralized checks)	Low	Minimal delay	[OK] Good

Rendering Pipeline

Permission checks happen on the server before the response is generated and sent to the browser, affecting how quickly the user can interact with the page.

→Server Request Handling

→Response Generation

⚠️ BottleneckServer-side permission evaluation can delay response if inefficient or duplicated.

Core Web Vital Affected

INP

This affects the server response time and user experience by controlling access checks before processing requests.

Optimization Tips

1Use DRF's built-in permission classes to centralize and optimize permission checks.

2Avoid manual permission checks in each view to reduce server CPU usage.

3Monitor API response times in DevTools Network tab to detect permission-related delays.

Performance Quiz - 3 Questions

What is the main performance benefit of using DRF's built-in permission classes?

A They centralize permission logic, reducing server processing time.

B They increase the number of permission checks per request.

C They add extra client-side validation to speed up responses.

D They cache user permissions in the browser.

DevTools: Network

How to check: Open DevTools, go to Network tab, make API requests and check response times.

What to look for: Look for longer server response times indicating slow permission checks.

Practice

1. What is the main purpose of permissions in Django REST Framework (DRF)?

easy

A. To control who can access or modify API endpoints

B. To style the API responses

C. To speed up database queries

D. To manage user sessions

Solution

1. Step 1: Understand the role of permissions in DRF

   Permissions define rules about who can use or change API data.

2. Step 2: Compare options with permissions purpose

   Only controlling access matches the purpose of permissions.

3. Final Answer:

   To control who can access or modify API endpoints -> Option A

4. Quick Check:

   Permissions = Access control [OK]

Hint: Permissions control access, not styling or speed [OK]

Common Mistakes:

• Confusing permissions with styling or performance
• Thinking permissions manage sessions

2. Which of the following is the correct way to apply the built-in permission IsAuthenticated to a DRF view?

easy

A. permissions = IsAuthenticated()

B. permission_classes = [IsAuthenticated]

C. permission_classes = IsAuthenticated

D. permission_classes = (IsAuthenticated)

Solution

1. Step 1: Recall DRF permission syntax

   Permissions are set as a list or tuple in permission_classes.

2. Step 2: Check each option's syntax

   permission_classes = [IsAuthenticated] uses a list with the class name, which is correct. permissions = IsAuthenticated() uses wrong attribute name and instance. permission_classes = IsAuthenticated misses list brackets. permission_classes = (IsAuthenticated) uses parentheses but without a comma, so it's not a tuple.

3. Final Answer:

   permission_classes = [IsAuthenticated] -> Option B

4. Quick Check:

   Use list for permission_classes [OK]

Hint: Use a list of permission classes for permission_classes [OK]

Common Mistakes:

• Using instance instead of class in permission_classes
• Forgetting to wrap in list or tuple
• Using wrong attribute name

3. Given this DRF view snippet, what will happen if an anonymous user tries to access it?

from rest_framework.permissions import IsAuthenticated
from rest_framework.views import APIView

class MyView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request):
        return Response({'message': 'Hello'})

medium

A. The user will receive a 401 Unauthorized response

B. The user will see the message 'Hello'

C. The user will receive a 403 Forbidden response

D. The server will raise a syntax error

Solution

1. Step 1: Understand IsAuthenticated permission behavior

   This permission denies access to anonymous users and returns 401 Unauthorized.

2. Step 2: Analyze the code behavior for anonymous user

   Since the user is not logged in, DRF returns 401, not 403 or success.

3. Final Answer:

   The user will receive a 401 Unauthorized response -> Option A

4. Quick Check:

   IsAuthenticated denies anonymous with 401 [OK]

Hint: IsAuthenticated returns 401 for anonymous users [OK]

Common Mistakes:

• Confusing 401 Unauthorized with 403 Forbidden
• Expecting anonymous users to see data
• Thinking code has syntax errors

4. Identify the error in this custom permission class:

from rest_framework.permissions import BasePermission

class IsOwner(BasePermission):
    def has_object_permission(self, request, view, obj):
        return obj.owner == request.user

# Usage in view
class MyView(APIView):
    permission_classes = [IsOwner()]

    def get(self, request, pk):
        obj = get_object(pk)
        self.check_object_permissions(request, obj)
        return Response({'id': obj.id})

medium

A. get_object method is undefined

B. has_object_permission method is missing a return statement

C. check_object_permissions is called incorrectly

D. Permission class should be passed as class, not instance

Solution

1. Step 1: Check how permission_classes should be set

   DRF expects permission classes, not instances, so use IsOwner without parentheses.

2. Step 2: Review other parts for errors

   has_object_permission returns correctly, check_object_permissions usage is correct, get_object assumed defined elsewhere.

3. Final Answer:

   Permission class should be passed as class, not instance -> Option D

4. Quick Check:

   Use class names, not instances in permission_classes [OK]

Hint: Use class names, not instances, in permission_classes [OK]

Common Mistakes:

• Passing permission instances instead of classes
• Assuming missing return in has_object_permission
• Confusing method calls with errors

5. You want to create a custom permission that allows access only if the user is authenticated and is the owner of the object. Which is the correct way to combine built-in and custom permissions in DRF?

hard

A. Set permission_classes = [IsAuthenticatedOrReadOnly, IsOwner] and override has_permission in IsOwner

B. Set permission_classes = [IsOwner] only and check authentication inside IsOwner

C. Set permission_classes = [IsAuthenticated, IsOwner] and implement has_object_permission in IsOwner

D. Set permission_classes = [IsAuthenticated()] and call IsOwner manually in the view

Solution

1. Step 1: Understand combining permissions in DRF

   DRF checks all permissions in the list; all must allow access.

2. Step 2: Check how to combine authentication and ownership

   Use IsAuthenticated to check login, and IsOwner to check object ownership via has_object_permission.

3. Step 3: Evaluate options

   Set permission_classes = [IsAuthenticated, IsOwner] and implement has_object_permission in IsOwner correctly combines both permissions. Set permission_classes = [IsOwner] only and check authentication inside IsOwner misses separate authentication check. Set permission_classes = [IsAuthenticatedOrReadOnly, IsOwner] and override has_permission in IsOwner mixes permission types incorrectly. Set permission_classes = [IsAuthenticated()] and call IsOwner manually in the view uses instance and manual calls, which is not standard.

4. Final Answer:

   Set permission_classes = [IsAuthenticated, IsOwner] and implement has_object_permission in IsOwner -> Option C

5. Quick Check:

   Combine permissions in list for layered checks [OK]

Hint: List all needed permissions in permission_classes [OK]

Common Mistakes:

• Skipping IsAuthenticated when ownership matters
• Using instances instead of classes
• Trying to call permissions manually