Advanced Django Concepts — Signals, Middleware, and Background Tasks with Celery

 

Advanced Django Concepts — Signals, Middleware, and Background Tasks with Celery

Once you’ve mastered the basics of Django, the next step is diving into advanced concepts that make your applications robust, scalable, and maintainable.

In this article, we’ll cover:

  • Signals — decoupled event handling

  • Middleware — request/response processing

  • Background tasks with Celery — asynchronous processing

These topics are crucial for building production-ready applications.

1️⃣ Django Signals — Event-Driven Programming

Signals allow you to trigger actions automatically when certain events occur, without tightly coupling your code.

Example Use Cases

  • Send welcome email when a new user registers

  • Update cached data after saving a model

  • Log changes automatically

Creating a Signal

from django.db.models.signals import post_save
from django.dispatch import receiver
from django.contrib.auth import get_user_model

User = get_user_model()

@receiver(post_save, sender=User)
def send_welcome_email(sender, instance, created, **kwargs):
    if created:
        print(f"Send welcome email to {instance.email}")

  • post_save triggers after saving a model

  • created=True ensures it runs only for new users

2️⃣ Middleware — Request/Response Processing

Middleware is a layer that processes requests before they reach the view and responses before they are sent to the client.

Common Use Cases

  • Authentication and authorization

  • Logging requests

  • Response compression

  • Rate-limiting or throttling

Creating Custom Middleware

class SimpleLoggingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        print(f"Incoming request: {request.path}")
        response = self.get_response(request)
        print(f"Outgoing response: {response.status_code}")
        return response

Add it to settings.py:

MIDDLEWARE = [
    ...
    'myapp.middleware.SimpleLoggingMiddleware',
]

Middleware allows centralized control over your application’s behavior.

3️⃣ Background Tasks with Celery

For tasks that take a long time (sending emails, generating reports, processing files), running them synchronously blocks requests.

Celery allows asynchronous task execution.

Step 1: Install Celery

pip install celery redis

Redis will be used as a message broker.

Step 2: Configure Celery in Django

celery.py in project root:

import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

app = Celery('myproject')
app.config_from_object('django.conf:settings', namespace='CELERY')
app.autodiscover_tasks()

Step 3: Create a Task

from celery import shared_task
from django.core.mail import send_mail

@shared_task
def send_welcome_email_task(user_email):
    send_mail(
        'Welcome!',
        'Thanks for signing up!',
        'no-reply@example.com',
        [user_email],
    )

Call asynchronously:

send_welcome_email_task.delay('user@example.com')

  • .delay() queues the task

  • Non-blocking — request completes immediately

 Real-World Use Cases for These Concepts

Concept                Example Use Case
Signals                    Auto-create profile when user registers
Middleware                    Log API requests and enforce rate-limits
Celery                    Send batch emails, process files, generate reports

Using them together allows scalable, decoupled, and maintainable applications.

Best Practices

Signals

  • Avoid complex business logic in signals

  • Use them for lightweight decoupled actions

  • Document all signals in one place

Middleware

  • Keep middleware simple and fast

  • Avoid database-heavy operations

  • Order matters — middleware runs in sequence

Celery

  • Use proper retry and error handling

  • Monitor tasks with Flower or Celery Beat

  • Separate critical tasks from non-critical to prevent bottlenecks

Performance Considerations

  • Signals can trigger multiple queries — combine with caching if needed

  • Middleware impacts every request — optimize for speed

  • Celery tasks should be idempotent and asynchronous

Why Mastering These Concepts Matters

  • Enables highly decoupled code

  • Supports asynchronous and scalable systems

  • Prepares you for complex production-level Django applications

  • Improves backend interview readiness

Signals, Middleware, and Celery are advanced Django concepts that take your applications from beginner-level CRUD apps to production-grade, scalable systems.

  • Signals → automate actions without tight coupling

  • Middleware → centralize request/response logic

  • Celery → handle long-running background tasks efficiently

Comments

Post a Comment

Popular posts from this blog

Database Integration in FastAPI (SQLAlchemy CRUD)

  Introduction So far, we’ve built APIs without storing data.But real-world applications need a database to: Store user data. Manage products. Persist application state. In this blog, we’ll connect FastAPI with a database using SQLAlchemy and perform CRUD operations . What is SQLAlchemy? SQLAlchemy is a powerful Python ORM (Object Relational Mapper) that allows you to: Interact with databases using Python code. Avoid writing raw SQL queries. Work with models instead of tables. Step 1: Install Dependencies pip install sqlalchemy (For SQLite, no extra driver needed) Project Structure Update app/ ├── main.py ├── database/ │ ├── connection.py ├── models/ │ ├── item.py ├── schemas/ │ ├── item.py ├── routes/ │ ├── item.py Step 2: Database Connection app/database/connection.py from sqlalchemy import create_engine from sqlalchemy . orm import sessionmaker , declarative_base DATABASE_URL = "sqlite:///./test.db" engine = create_engine ( DAT...
Read more

Middleware & CORS in FastAPI

  Introduction As your API grows, you may need to: Log requests Modify responses Handle cross-origin requests This is where Middleware and CORS (Cross-Origin Resource Sharing) come into play.They help control how requests and responses flow through your application. What is Middleware? Middleware is a function that runs: Before a request reaches your route After a response is returned Think of it as a pipeline layer between client and server. Request Flow with Middleware Client → Middleware → Route → Middleware → Response Creating Custom Middleware from fastapi import FastAPI , Request import time app = FastAPI () @ app . middleware ( "http" ) async def log_requests ( request : Request , call_next ): start_time = time . time() response = await call_next ( request ) process_time = time . time() - start_time print ( f"Request: { request . url} | Time: { process_time } " ) return response What This Middle...
Read more

Python Data Handling

Python Data Handling for Beginners In Python, data handling means storing, changing, and using data in different ways. In this post, you will learn: Lists Tuples Dictionaries Sets String Methods Type Conversion 1. Python Lists :Lists store many values in one variable.                fruits = ["apple", "banana", "mango"]                                                                       Method                          Use                                            append()          ...
Read more