Backwards Migration with Django South

Django South is a useful database migration library for Django projects. It allows you to evolve your database schema over time through a series of incremental migration files. However, sometimes you may need to perform a backwards migration if you make a mistake or want to revert to an earlier version. Luckily, South makes backwards migrations easy too. In this post, we’ll explore some best practices for backwards migration with South.

The Risks of Skipping Backwards Migration

Before we dive in, it’s important to understand why properly doing backwards migrations matters. After all, if you just want to get back to a previous state, why not simply drop the database and reload? While that approach may seem quicker, it has some significant downsides:

First off, dropping the database means losing all existing data every time. This can be problematic if your database contains important records you still need.

Additionally, reloading the database does not undo any data migrations that have run. So if you accidentally migrated invalid data, it would still be present after reloading.

Finally, skipping backwards migrations breaks the migration history. This can cause issues down the road if you ever need to access the old migrations.

Therefore, it’s best to avoid shortcuts and instead use South’s backwards migration functionality. When done properly, this allows reversing migrations while preserving data integrity and history.

Step 1: Generate an Empty Backwards Migration

To start, you first need to create a blank migration file to write your backwards logic in. Run this command, replacing with a descriptive name:

python schemamigration app_name --empty <migration_name>

This will generate an empty migration file under /app_name/migrations.

Step 2: Add the Reverse Logic

Open the generated file. You’ll see a blank forwards() operation. Below it, add your backwards logic by writing code inside the backwards() function.

Any logic here should undo what the forwards migration originally did. Common backwards operations include:

  • Deleting model classes
  • Removing fields/columns
  • Changing columns back to previous types
  • Reverting data migrations

Your logic should be the reverse order of the original forwards migration. Be careful to restore the schema to exactly what it looked like before.

Step 3: Finish and Run the Migration

Once your backwards logic is written, finish by setting dependencies and other metadata in the migration file. Then, run theMigration with:

python migrate app_name <migration_name>

South will revert the changes made in the original forwardsMigration per the backwards logic you wrote.

Now your schema and data will be back in the state before the unwantedMigration occurred!

Key Considerations

There are a few key things to keep in mind when writing effective backwards migrations:

First, be careful about data integrity. Make sure you do not introduce invalid references or orphaned rows through the backwards migration logic. Performing data validations after migrating is wise.

Also, watch for dependency issues. If other apps relied on structures from the forwards migration, reversing it can cause crashes. Handle dependencies appropriately in both directions.

In addition, confirm theMigration executes fully. Sometimes complex logic will error out halfway through, so check the system state afterward.

Finally, note that backwards migrations can be slow on large datasets, so test on copies of production data during development.


Django South’s backwardsMigration functionality allows safely undoing changes to the database schema. With some care taken in writing reverse logic and testing, backwards migrations enable you to easily revert unwanted changes. Utilizing them makes it simpler to catch mistakes before they create problems.

So next time you need to roll back some messy project migrations, don’t take shortcuts – use South’s built-in tools to downshift your database without drama! Backwards migrations are a lifesaver.