Home / Blogs

What Are Django Signals & How Do Django Signals Work in 2024


June 6, 2024


Django, the high-level Python web framework, is packed with features that help developers create robust and scalable web applications. One of these powerful features is Django signals.

In this blog post, we’ll explore what Django signals are, how they work, and provide a simple example to illustrate their usage.

What Are Django Signals?

Django signals allow certain senders to notify a set of receivers when specific actions have taken place. This can be incredibly useful for decoupling code and performing actions in response to changes within your application, such as saving an object, deleting an object, or user actions like logging in or out.

In essence, signals provide a way for different parts of your application to communicate without tightly coupling the sender and receiver.

To read more about managing file uploads in Django, refer to our blog How to Manage File Uploads in Django

How Do Django Signals Work?

Django provides a signal dispatcher that handles the registration of signals and the connection of signals to receivers. Here’s a brief overview of how signals work in Django:

Define a signal: You can define custom signals or use Django’s built-in signals.

Connect the signal: Connect the signal to a receiver function that gets called when the signal is sent.

Send the signal: Send the signal when a particular action occurs.

Django includes several built-in signals like pre_save, post_save, pre_delete, and post_delete, among others.

A Simple Example of Django Signals

Let’s walk through a simple example to demonstrate how Django signals work. In this example, we’ll use the built-in post_save signal which is sent after a model’s save() method is called.

Step 1: Initialize Your Django Project and Application

To begin, ensure that Django is installed on your system. Next, set up a new Django project and create an application within it:

django-admin startproject myproject
cd myproject
python manage.py startapp myapp

Step 2: Define a Model

In your myapp/models.py, define a simple model. For this example, let’s create a Profile model:

from django.db import models
from django.contrib.auth.models import User

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField(blank=True)

    def __str__(self):
        return self.user.username

Step 3: Create a Signal Receiver

Next, create a receiver function that will be called when the post_save signal is sent. In myapp/signals.py, define the receiver:

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

@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
    if created:

@receiver(post_save, sender=User)
def save_profile(sender, instance, **kwargs):

Step 4: Connect the Signal

Make sure to connect the signal. This can be done in the ready method of your app’s AppConfig. In myapp/apps.py, modify the MyappConfig class:

from django.apps import AppConfig

class MyappConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'myapp'

    def ready(self):
        import myapp.signals

Step 5: Register the AppConfig

Ensure that Django uses the AppConfig by specifying it in the INSTALLED_APPS setting in myproject/settings.py:


Step 6: Apply Migrations and Test

Execute the migrations to configure the database structure:

python manage.py makemigrations
python manage.py migrate

Now, when a new User instance is created, a corresponding Profile instance will also be created automatically.

# Example usage in Django shell

python manage.py shell

>>> from django.contrib.auth.models import User
>>> user = User.objects.create_user('john', 'john@example.com', 'password123')
>>> user.profile

To read more about generating employee payslips in batches with Horilla HRMS, refer to our blog How to Generate Employee Payslips in Batches with Horilla HRMS


Django signals are a powerful feature for decoupling different parts of your application and allowing them to communicate effectively. In this simple example, we saw how to use the post_save signal to automatically create and save a Profile whenever a new User is created. This is just the tip of the iceberg; signals can be used for various other tasks like logging, caching, sending notifications, and much more. Embrace the flexibility and power of Django signals to enhance your application’s functionality and maintainability!

Horilla Editorial Team Author

Horilla Editorial Team is a group of experienced writers and editors who are passionate about HR software. We have a deep understanding of the HR landscape and are committed to providing our readers with the most up-to-date and informative content. We have written extensively on a variety of HR software topics, including applicant tracking systems, performance management software, and payroll software etc. We are always looking for new ways to share our knowledge with the HR community. If you have a question about HR software, please don't hesitate to contact us.