How to Add Dynamic Fields to a Model Based on a ForeignKey in Django

What will you learn?

In this tutorial, you will learn how to dynamically add extra fields to a Django model based on values from another model. This advanced technique enhances data modeling and relationship handling in Django applications without the need for frequent database schema modifications.

Introduction to the Problem and Solution

When working with Django, there is often a need to extend a model by adding additional fields that depend on the values of another related model. This scenario typically involves having two models where one serves as a reference (ForeignKey) for the other. By establishing this relationship, you can introduce new fields dynamically into the referencing model based on the values of the referenced model.

To solve this problem effectively, it is crucial to grasp advanced concepts of Django’s Object-Relational Mapping (ORM), such as ForeignKey relationships, dynamic model alterations using signals or custom save methods, and potentially utilizing Django�s content types framework for more intricate scenarios. In this guide, we will primarily focus on an approach that leverages model inheritance and signal listeners to achieve our objective without requiring constant modifications to the database schema whenever a new field is needed.


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

class ParentModel(models.Model):
    name = models.CharField(max_length=100)

class ChildModel(models.Model):
    parent = models.ForeignKey(ParentModel, on_delete=models.CASCADE)
    dynamic_field = models.JSONField(default=dict)

@receiver(post_save, sender=ParentModel)
def update_dynamic_field(sender, instance=None, created=False,**kwargs):
    if created:
        child_instance = ChildModel.objects.get(parent=instance)
        # Update dynamic_field based on ParentModel instance properties.
        child_instance.dynamic_field['new_key'] = 'new_value'

# Copyright PHD


In the provided code snippet:

  • Models Definition: Two models are defined – ParentModel, which represents a generic object, and ChildModel, which references ParentModel through a ForeignKey.

  • Dynamic Field: The dynamic_field within ChildModel is implemented as a JSONField. This allows storing arbitrary JSON objects in it, making it suitable for scenarios where the stored data may vary.

  • Signal Listener: Utilizing Django’s signals (post_save) connected via the @receiver decorator ensures that when an instance of ParentModel is saved (either created or updated), our signal listener function (update_dynamic_field) gets triggered.

  • Within the signal listener function:

    • When creating a new instance (created=True), it creates an associated ChildModel.
    • In case of updating an existing instance (created=False), it retrieves the related ChildModel, updates its dynamic_field, and saves it back into the database.

This methodology enables us to dynamically modify or extend related data upon creating or updating parent instances without necessitating alterations to our initial database schema every time new requirements emerge.

    How do I access dynamic fields in templates?

    You can access them by iterating over items in your template like so: {% for key,value in object.dynamic_field.items %}.

    Can I query objects based on dynamic field values?

    Yes! You can use PostgreSQL specific lookups like .filter(dynamic_field__yourkey=’yourvalue’).

    Are there performance considerations with JSONFields?

    While convenient, large JSONFields can impact performance during queries. It�s wise not too store excessively large amounts of data here.

    Is this method safe from SQL injection?

    Django�s ORM provides protection against SQL injection; however careful consideration should be given when allowing user-generated keys/values within your JSONField.

    Can I use signals with other relation types besides ForeignKey?

    Absolutely! Signals work across many relation types including OneToOneField and ManyToManyField relations as well.


    By exploring how to add dynamic fields based on relationships between models in Django applications, we have witnessed the flexibility and power it brings without requiring frequent schema modifications. Leveraging features like ForeignKey relations combined with signal handlers or overriding save methods allows us to enhance our application’s capabilities while maintaining simplicity within our codebase.

    Leave a Comment