When signals are appropriate vs not in Django - Visual Side-by-Side Comparison

Concept Flow - When signals are appropriate vs not

Event occurs in app

↓

Signal sent

↓

Signal receivers listen

↓

Receivers execute code

↓

Side effects happen

↓

App continues normal flow

Signals let parts of a Django app react to events without tight connections, but they should be used only for decoupled side effects.

Execution Sample

Django

from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=MyModel)
def my_handler(sender, instance, created, **kwargs):
    if created:
        print('New instance created')

This code listens for when a new MyModel instance is saved and prints a message only if it is newly created.

Execution Table

Step	Event	Signal Sent?	Receiver Called?	Receiver Action	Output
1	MyModel instance saved (new)	Yes	Yes	Check if created=True	Print 'New instance created'
2	MyModel instance saved (update)	Yes	Yes	Check if created=False	No output
3	Unrelated event	No	No	No action	No output
4	Signal sent but no receiver connected	Yes	No	No action	No output

💡 Execution stops after signal receivers finish or if no receivers are connected.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
instance.created	N/A	True	False	N/A	N/A
signal_sent	False	True	True	False	True
receiver_called	False	True	True	False	False

Key Moments - 3 Insights

Why doesn't the receiver run if the signal is sent but no receiver is connected?

Because signals only trigger code in connected receivers. If no receiver listens, no code runs, as shown in step 4 of the execution table.

Why check if 'created' is True inside the receiver?

Because post_save runs on both create and update. Checking 'created' ensures the receiver acts only on new instances, as in steps 1 and 2.

When should you avoid using signals?

Avoid signals for logic that should be explicit or tightly coupled, since signals can make code harder to follow and debug.

Visual Quiz - 3 Questions

Look at the execution table, at which step does the receiver print 'New instance created'?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Check the 'Output' column for the print statement in the execution table.

According to the variable tracker, what is the value of 'receiver_called' after step 4?

A Undefined

B True

C False

D None

💡 Hint

Look at the 'receiver_called' row under 'After Step 4' in the variable tracker.

If you remove the 'created' check inside the receiver, what changes in the execution table?

A Receiver prints message on both create and update

B Receiver never runs

C Signal is not sent

D Receiver runs only on update

💡 Hint

Refer to the 'Receiver Action' and 'Output' columns for steps 1 and 2 in the execution table.

Concept Snapshot

Django signals let apps react to events without tight links.
Use signals for side effects like logging or notifications.
Avoid signals for core logic or when explicit calls are clearer.
Signals send events; receivers listen and act.
Check event details (like 'created') inside receivers.
Too many signals can make debugging hard.

Full Transcript

Django signals are tools to let parts of your app respond when something happens, like saving a model. When an event occurs, Django sends a signal. Receivers that listen to this signal run their code. For example, after saving a new model instance, a receiver can print a message. But signals only work if receivers are connected. If no receiver listens, nothing happens. Also, signals run on many events, so inside the receiver you often check details like if the instance was just created. Signals are good for side effects like sending emails or logging, but avoid using them for main logic because they can make your code harder to understand and debug.