When async helps and when it does not in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

When does async improve Django view performance?

Which scenario below best explains when using async views in Django will improve performance?

A When the view waits for slow external APIs or database queries and can release the thread during waiting.

B When the view performs long CPU-heavy calculations without waiting for external resources.

C When the view only renders a simple template with no external calls.

D When the view uses synchronous ORM queries exclusively.

💡 Hint

Think about when releasing the thread during waiting helps.

Async views help when the code waits on external I/O like APIs or databases, allowing other requests to run meanwhile. CPU-heavy or purely synchronous code won't benefit.

❓ component_behavior

intermediate

Output of async Django view with blocking code

What will be the behavior of this async Django view when called multiple times concurrently? ```python from django.http import JsonResponse import time async def my_view(request): time.sleep(2) # blocking call return JsonResponse({'status': 'done'}) ```

Django

from django.http import JsonResponse
import time

async def my_view(request):
    time.sleep(2)  # blocking call
    return JsonResponse({'status': 'done'})

A All requests will be handled concurrently without delay.

B The view will return immediately without waiting.

C The server will raise a SyntaxError due to async with time.sleep.

D Each request will block the server thread for 2 seconds, causing sequential delays.

💡 Hint

Consider what happens when blocking code runs inside async functions.

Using blocking calls like time.sleep inside async views blocks the event loop, causing requests to be handled one after another, not concurrently.

📝 Syntax

advanced

Identify the syntax error in async Django ORM usage

Which option contains the correct syntax for using Django's async ORM method inside an async view? ```python async def get_user(request): user = await User.objects.get(id=1) return JsonResponse({'username': user.username}) ```

Django

async def get_user(request):
    user = await User.objects.get(id=1)
    return JsonResponse({'username': user.username})

A Cannot use await with ORM; must call get() without await in async views.

B Correct as is, Django ORM supports await on get() in async views.

C Must use sync_to_async wrapper around User.objects.get() to await it.

D Must define get_user as a synchronous function to use ORM.

💡 Hint

Check if Django ORM methods are natively async or require wrappers.

Django ORM methods like get() are synchronous and must be wrapped with sync_to_async to be awaited in async views.

❓ state_output

advanced

Effect of async on Django middleware execution order

Given this middleware setup, what is the order of print statements when a request is processed? ```python class SyncMiddleware: def __init__(self, get_response): self.get_response = get_response print('SyncMiddleware init') def __call__(self, request): print('SyncMiddleware before') response = self.get_response(request) print('SyncMiddleware after') return response class AsyncMiddleware: def __init__(self, get_response): self.get_response = get_response print('AsyncMiddleware init') async def __call__(self, request): print('AsyncMiddleware before') response = await self.get_response(request) print('AsyncMiddleware after') return response ``` Middleware order in settings: [SyncMiddleware, AsyncMiddleware]

Django

class SyncMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
        print('SyncMiddleware init')

    def __call__(self, request):
        print('SyncMiddleware before')
        response = self.get_response(request)
        print('SyncMiddleware after')
        return response

class AsyncMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
        print('AsyncMiddleware init')

    async def __call__(self, request):
        print('AsyncMiddleware before')
        response = await self.get_response(request)
        print('AsyncMiddleware after')
        return response

A AsyncMiddleware init, SyncMiddleware init, AsyncMiddleware before, SyncMiddleware before, SyncMiddleware after, AsyncMiddleware after

B SyncMiddleware init, AsyncMiddleware init, SyncMiddleware before, AsyncMiddleware before, AsyncMiddleware after, SyncMiddleware after

C SyncMiddleware init, AsyncMiddleware init, AsyncMiddleware before, SyncMiddleware before, SyncMiddleware after, AsyncMiddleware after

D AsyncMiddleware init, SyncMiddleware init, SyncMiddleware before, AsyncMiddleware before, AsyncMiddleware after, SyncMiddleware after

💡 Hint

Remember middleware __init__ runs on startup, __call__ runs per request in order.

Middleware __init__ runs in order on startup. On request, SyncMiddleware __call__ runs first, then calls AsyncMiddleware __call__, which awaits the next layer. The prints show nested calls accordingly.

🔧 Debug

expert

Debugging async Django view causing server hang

You wrote this async Django view but the server hangs and never responds: ```python from django.http import JsonResponse import asyncio async def slow_view(request): asyncio.sleep(3) return JsonResponse({'status': 'done'}) ``` What is the cause of the hang?

Django

from django.http import JsonResponse
import asyncio

async def slow_view(request):
    asyncio.sleep(3)
    return JsonResponse({'status': 'done'})

A asyncio.sleep is a coroutine and must be awaited; missing await causes the hang.

B asyncio.sleep is blocking and freezes the event loop.

C The view must be synchronous to use sleep.

D JsonResponse cannot be returned from async views.

💡 Hint

Check how to properly use async sleep functions.

asyncio.sleep is a coroutine that must be awaited. Without await, the coroutine is created but not run, causing the view to hang waiting indefinitely.