Why background tasks matter in Django - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use background tasks in Django?

Which of the following best explains why background tasks are important in Django applications?

A They automatically fix bugs in the code during runtime.

B They replace the need for a database in Django projects.

C They allow long-running operations to run without blocking user requests, improving responsiveness.

D They make the Django server run faster by compiling Python to machine code.

💡 Hint

Think about what happens when a user waits for a slow task to finish on a website.

Background tasks let heavy or slow work happen separately from user requests, so the website stays fast and responsive.

❓ component_behavior

intermediate

What happens when a background task runs in Django?

Consider a Django app using a background task queue like Celery. What is the main behavior when a background task is triggered?

A The task runs immediately in the same thread as the web request, delaying the response.

B The task runs only when the Django server restarts.

C The task is saved in the database but never executed.

D The task is sent to a worker process that runs it separately, allowing the web request to finish quickly.

💡 Hint

Think about how background workers help with multitasking.

Background tasks are handled by separate worker processes, so the main web server can respond to users without waiting.

❓ state_output

advanced

Output of a Django view with a background task

What will be the output to the user when a Django view triggers a background task to send an email?

Assume the task is correctly configured and the email sending takes several seconds.

Django

from django.http import HttpResponse
from myapp.tasks import send_email_task

def send_email_view(request):
    send_email_task.delay('[e-mail]')
    return HttpResponse('Email is being sent!')

A "Email is being sent!" appears immediately, and the email is sent later in the background.

B The user waits several seconds before seeing any response, then sees "Email is being sent!".

C The view raises an error because delay() is not a valid method.

D The email is sent synchronously, and the user sees no response until it finishes.

💡 Hint

Remember what delay() does in Celery tasks.

Calling delay() queues the task to run later, so the view returns the response immediately.

📝 Syntax

advanced

Identify the correct way to define a background task in Django with Celery

Which of the following code snippets correctly defines a Celery task in Django?

A

from celery import task

@task
def add(x, y):
    return x + y

B

from celery import shared_task

@shared_task
def add(x, y):
    return x + y

C

from celery import task

def add(x, y):
    return x + y

D

from celery import shared_task

@shared_task
def add(x, y):
    print(x + y)

💡 Hint

Look for the modern decorator used to define reusable tasks.

@shared_task is the recommended decorator to define tasks that can be called asynchronously in Django projects using Celery.

🔧 Debug

expert

Why does this background task never run?

Given this Django Celery task code, why might the task never execute?

from celery import shared_task

@shared_task
def process_data():
    data = fetch_data()
    save_results(data)

# In views.py
process_data()

A The task is called directly instead of using delay(), so it runs synchronously and may block or fail silently.

B The @shared_task decorator is missing, so Celery does not recognize the function as a task.

C Celery requires tasks to be called with apply_async(), so delay() is invalid.

D The fetch_data() function is undefined, causing a NameError before the task runs.

💡 Hint

How do you trigger a Celery task to run asynchronously?

Calling the task function directly runs it immediately in the current process, not in the background. To run asynchronously, use delay() or apply_async().