Maybe you renamed a model, and suddenly your database is a mess. Or maybe you're just experimenting and want to roll things back.

That’s where reverting migrations comes in.

Knowing how to undo a migration in Django is just as important as knowing how to make one. It’s not about being perfect – it’s about being able to fix mistakes fast, without panic. I've been there.

A single migration can break everything if it goes wrong. But the good news is, Django gives you tools to take a step back safely.

Let me walk you through how this works, using plain language and clear steps.

Table of Contents

• What Exactly Is a Migration in Django?

• How to Revert a Migration in Django

  • Case 1: Undo a Migration That’s Already Been Applied

  • Case 2: Undo a Migration You Haven’t Applied Yet

• Special Case: Reverting All Migrations (Reset Everything)

• Example Scenario: Fixing a Broken Migration

• Common Pitfalls (And How to Avoid Them)

• FAQs

  • Can I revert more than one migration at a time?

  • How do I know which migration names to use?

  • Is reverting migrations safe?

• Further Resources

• Conclusion

What Exactly Is a Migration in Django?

Before we can talk about undoing a migration, let’s make sure we’re on the same page.

A migration in Django is a record of changes to your database. It tracks what models you’ve added or changed, and applies those changes to your actual database using SQL (behind the scenes).

You usually create a migration with this command:

python manage.py makemigrations

And apply it like this:

python manage.py migrate

That’s when Django updates your database tables to match your models.

Now, what if you want to undo that last step?

How to Revert a Migration in Django

Alright, here’s the main part. Let’s say you just ran a migration and want to undo it. There are two situations:

1. You applied the migration already and want to reverse it

2. You haven’t applied it yet and just want to delete it

Let’s handle both.

Case 1: Undo a Migration That’s Already Been Applied

If you've already run python manage.py migrate, Django has changed your database.

To reverse that migration, use this:

python manage.py migrate your_app_name migration_name_before

Let me break that down:

• your_app_name is the name of your Django app (like blog, users, or store)

• migration_name_before is the name of the migration before the one you want to undo

Let’s go through an example.

Say you have these migrations for an app called store:

0001_initial.py  
0002_add_price_to_product.py  
0003_change_price_field.py

If you want to undo the 0003_change_price_field.py migration, you’d run:

python manage.py migrate store 0002

That tells Django to roll back to migration 0002, effectively undoing everything in 0003.

Once that’s done, you’ll see output like:

Operations to reverse:
   - Alter field price on product

And your database is back the way it was before 0003.

Case 2: Undo a Migration You Haven’t Applied Yet

Maybe you ran makemigrations, but not migrate. So you just created the migration file and haven’t actually touched the database yet.

In that case, you can safely delete the migration file.

Just go into your app’s migrations/ folder, and delete the unwanted migration file (for example: 0003_change_price_field.py).

Then you can re-run makemigrations with the correct changes.

Quick tip: Don't delete __init__.py or the 0001_initial.py file unless you know what you’re doing. That first one is usually required.

Special Case: Reverting All Migrations (Reset Everything)

Sometimes you just want to wipe all the migrations and start over.

This is common when you're still in development, and your database structure is messy.

Here's how I usually do it:

1. Delete the migration files inside the migrations/ folder of your app (except for __init__.py)

2. Drop the database or just clear the tables if you're using SQLite or a test DB

3. Run:

python manage.py makemigrations
python manage.py migrate

If you're using SQLite, you can also just delete the .sqlite3 file and start fresh.

For PostgreSQL or MySQL, you'll need to drop and recreate the database, or reset it using a tool like pgAdmin or DBeaver.

Example Scenario: Fixing a Broken Migration

Let’s say you added a new field to a model:

class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=6, decimal_places=2, default=0.00)

You made a typo:

price = models.DecimalField(max_digits=6, decimal_places=2, default='free')

Oops. Django lets you do this:

python manage.py makemigrations store
python manage.py migrate

Then it breaks.

You can fix this by reverting:

python manage.py migrate store 0001

Then fix the typo in your model and run:

python manage.py makemigrations
python manage.py migrate

Back on track!

Common Pitfalls (And How to Avoid Them)

• Don’t just delete a migration without reversing it first. This can confuse Django.

• Always check which migrations are applied using:

python manage.py showmigrations

• Keep backups of your database, especially in production. Use tools like pg_dump or mysqldump if needed.

• Don't reset migrations in a live app unless you absolutely must. It can mess up production data.

FAQs

Can I revert more than one migration at a time?

Yes! You just migrate back to the point before the migrations you want to undo.

Example:

You’ve applied:

[X] 0001_initial  
[X] 0002_add_price_to_product  
[X] 0003_change_price_field  
[X] 0004_add_discount_field

To undo both 0004 and 0003, run:

python manage.py migrate store 0002

This rolls back both 0004 and 0003, leaving only 0001 and 0002 applied.

How do I know which migration names to use?

Run python manage.py showmigrations And you’ll see a list like:

 [X] 0001_initial
 [X] 0002_add_price_to_product
 [X] 0003_change_price_field

The [X] shows applied migrations. To undo 0003, migrate back to 0002.

Is reverting migrations safe?

It is, as long as you haven’t made changes to data that depend on the migration. Always test in development before trying in production.

Conclusion

Reverting migrations in Django isn't scary once you get the hang of it. It's like using undo in a Word document – you just need to know how far back to go.

So now that you know how to revert a migration in Django, what’s the trickiest migration issue you've run into—and how did you fix it?

Shoot me a message – I’d love to hear your story.

Further Resources

• Official Django Migration Docs

• Django Migrations Primer by RealPython

• Common Django Mistakes and How to Avoid Them

I’ve helped a lot of people get started with Python and Django, and trust me: understanding virtual environments early on can save you tons of headaches later.

A virtual environment can help you keep your Django projects organized. It also avoids conflicts between different versions of packages, and gives you a cleaner way to manage your development tools.

By the end of this guide, you’ll not only know how to activate your virtual environment, but also why you should.

Let's get into it.

Here’s what we’ll cover:

1. What Is a Virtual Environment in Python?

2. Why Use a Virtual Environment?

3. How to Set Up and Activate a Django Virtual Environment

   • 1. Install Python (If You Haven’t Yet)

   • 2. Install virtualenv (Optional but Useful)

   • 3. Create a Virtual Environment

   • 4. Activate the Virtual Environment

4. What Can You Do After Activating It?

5. How to Deactivate the Virtual Environment

6. FAQs

   • Do I need to activate the environment every time?

   • What if activate Doesn’t work?

   • Can I use VS Code or another editor with this?

7. Bonus Tips

   • Add a .gitignore File

   • Use requirements.txt

8. Helpful Resources

9. Conclusion

10. Further Learning

What Is a Virtual Environment in Python?

A virtual environment is like a private workspace just for your project. Instead of installing packages (like Django) globally for your whole computer, you install them inside this little bubble. That way, different projects don’t mess with each other.

Imagine you’re working on two Django projects: one needs Django 3.2 and the other needs Django 4.1. Without a virtual environment, you'd run into version conflicts. But with virtual environments, each project stays separate and clean.

Why Use a Virtual Environment?

Here’s why I always use one when working with Django:

• Keeps your project dependencies isolated.

• Prevents version conflicts between different projects.

• Makes it easy to manage and uninstall packages.

• Most importantly, Django expects it, especially if you want to follow best practices.

How to Set Up and Activate a Django Virtual Environment

Let’s walk through the process from start to finish.

1. Install Python (If You Haven’t Yet)

You need Python 3.8 or later. You can check what version you have by opening your terminal and typing:

python --version

If you see something like Python 3.11.7You’re good.

If you don’t have Python, download it here:

👉 https://www.python.org/downloads/

Make sure to check the box “Add Python to PATH” during installation if you're on Windows.

2. Install virtualenv (Optional but Worth Knowing)

Python includes a built-in tool called venv, and that’s what we’ll use in this tutorial.

However, some developers prefer virtualenv because:

• It works with older Python versions

• It can be slightly faster in larger environments

• It offers some additional flexibility

To install virtualenv just run:

pip install virtualenv

Note: You don’t need virtualenv for this tutorial, but it’s good to know about. We'll be using Python’s built-in venv going forward.

3. Create a Virtual Environment

Now go to your Django project folder (or make one):

mkdir my_django_project
cd my_django_project

Then run:

python -m venv venv

• python -m venv uses Python’s built-in virtual environment module

• venv is the name of the folder that will store your environment (you can call it anything)

This creates a folder called venv/ in your project directory. That folder contains everything your virtual environment needs.

4. Activate the Virtual Environment

Here’s the part everyone asks about.

Activation depends on your operating system.

On Windows (CMD):

venv\Scripts\activate

On Windows (PowerShell):

.\venv\Scripts\Activate.ps1

On Mac or Linux:

source venv/bin/activate

After you activate it, your terminal prompt will change. It’ll look something like this:

(venv) your-computer-name:my_django_project username$

That (venv) at the beginning means the virtual environment is active.

What Can You Do After Activating It?

Now that it’s active, you can install Django (or anything else) just for this project:

pip install django

This installs Django inside the virtual environment, not globally.

To double-check:

pip list

You’ll see Django and any other installed packages listed there.

How to Deactivate the Virtual Environment

When you’re done working, just type:

deactivate

That’s it. Your terminal goes back to normal, and your system’s Python is no longer linked to the project.

FAQs

Do I need to activate the environment every time?

Yes, every time you open a new terminal session and want to work on your Django project, activate it again using the command for your OS.

What if activate Doesn’t work?

If you’re on Windows, PowerShell might block the script. Run this:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Then try activating again.

Can I use VS Code or another editor with this?

Absolutely. VS Code even detects your virtual environment automatically. You can select the interpreter from the bottom-left or by pressing Ctrl+Shift+P → “Python: Select Interpreter.”

Bonus Tips

Add a .gitignore File

If you're using Git, you don’t want to upload the venv folder to GitHub. Add this line to your .gitignore file:

venv/

Use requirements.txt

Once you’ve installed your project’s packages, freeze them like this:

pip freeze > requirements.txt

Then later, you (or someone else) can install them with:

pip install -r requirements.txt

This is useful for team projects or for moving your app to a server.

Conclusion

Activating your Django virtual environment might seem like a small thing, but it’s a big step toward becoming a confident and organized developer.

Once you get the hang of it, it becomes second nature – and your future self will thank you for learning it the right way from the start.

Would you love to connect with me? You can do so on X.com/_udemezue

Helpful Resources

• Official Python Docs on venv

• Django Official Website

• Python Virtual Environments Tutorial (Real Python)

• How to Fix “activate.ps1 cannot be loaded” in PowerShell

Further Learning

If you're serious about Django, here are some free and paid resources I recommend:

• Django for Beginners by William S. Vincent

• FreeCodeCamp’s Django Crash Course on YouTube

• CS50 Web Programming with Python and JavaScript

Getting those first few users can feel like climbing a mountain. It’s the hardest part, but also the most important. Without customers, your SaaS doesn’t grow.

Without feedback from real users, you can’t improve. And let’s be honest – seeing people pay for your product is a huge motivation boost.

I’ve seen this challenge many times, and I know the pressure is real. That’s why I’m breaking it all down in the simplest way possible. No confusing words, no vague advice – just a clear plan you can use.

Let’s jump right in.

Why Getting Your First SaaS Customers Matters So Much

Before we talk strategy, let’s be super clear about why the first customers are gold:

• They validate your idea. If strangers are willing to pay, you’re onto something real.

• They help you shape the product. Early users are honest about what works and what’s broken.

• They fuel your momentum. A few early wins can give you the confidence to keep pushing forward.

• They help you spread the word. Happy first customers are often your best marketers.

Your first ten customers matter more than your next hundred. So it’s worth taking the time to get this right.

Real Ways to Get Your First SaaS Customers

1. Start With People You Know

Don’t be shy to reach out to friends, family, former coworkers, and old clients. Tell them about your new SaaS and ask if they know anyone who might need it.

And remember: you’re not begging – you’re offering something valuable.

Pro Tip: Focus on the people they know, not just whether they want to buy themselves.

2. Join Communities Where Your Customers Hang Out

Find Facebook groups, Reddit forums, Slack communities, or LinkedIn groups where your ideal users already spend time.

Be helpful. Answer questions. Join conversations. Build trust. Then, when it’s natural, mention your product.

Real Example: If you built a tool for yoga instructors, find Facebook groups for yoga teachers.

3. Launch on Product Hunt

Product Hunt is full of early adopters looking for new tools.

If you do a good launch (with a nice-looking page, clear description, and a bit of buzz on the side), you could get your first few hundred signups in one day.

Helpful read: How to Launch on Product Hunt Successfully

4. Offer a “Beta” Version

Invite early users to test your software before the official launch.
Make it feel special – they get early access, and their feedback will shape the product.

Bonus Tip: Beta users are often more forgiving about bugs. They expect a few rough edges.

5. Use Cold Outreach (But Do It Right)

Sending emails to strangers sounds scary. But if you write short, respectful, personalized emails, it works.
Focus on how you can solve a real problem they have – not on how great your product is.

Good Cold Email Example:

"Hi [Name],
I noticed you [specific detail]. I built a tool that might save you [X hours / $X per month].
Would you like me to send a quick demo?"

Keep it about them, not you.

6. Get Active on LinkedIn

Post helpful tips, mini case studies, and personal stories. Show people you understand their struggles.
It builds trust. It shows you’re serious. And it keeps you top-of-mind when someone does need your product.

7. Partner With Other Small Businesses

Find companies that serve the same audience but aren’t direct competitors.

Maybe you made a booking app for barbershops. You could partner with a payment processor or marketing agency that also targets barbers.

Offer a referral deal or co-host a webinar together.

8. Content Marketing (Start Small)

You don’t need a full blog with 50 articles right away. Start with 2–3 simple, super-useful blog posts that answer real questions your customers have.

Example:

If you built an invoicing tool, write posts like:

• “How to Send Your First Invoice as a Freelancer”

• “5 Mistakes New Freelancers Make With Payments”

Helpful Link: Beginner’s Guide to Content Marketing

9. Run a Tiny Paid Ad Test

A small Facebook or Google ad campaign (even $5–10 a day) can give you quick feedback.

Target very specifically – not just "small business owners," but "independent yoga teachers in New York."

Watch which messages work, which don’t, and adjust fast.

10. Create Simple Case Studies

Even if you only have one early customer, ask them if you can tell their story. How they used your product. What problem it solved. What results they saw.

Nothing builds trust faster than real success stories.

11. Offer a Founder's Deal

Offer lifetime discounts or special plans to your first customers. This rewards them for taking a chance on you early, and it creates urgency (“only 20 spots left!”).

Example: Lifetime access for $99 instead of $20/month.

12. Make It Ridiculously Easy to Share

Add a simple “Share with a friend” button in your app, emails, and thank-you pages. Happy users want to help – just make it easy for them.

FAQs

Should I offer my SaaS for free at first?

I would recommend a free trial instead of free forever. Free users are often less serious. You want customers who see value and are willing to pay for it.

How long does it usually take?

Honestly? It depends. Some people land their first customers in a week. Others need a few months. Stay patient and keep improving both your product and your outreach.

What if no one seems interested?

It happens. If you're hearing crickets, it might be time to talk directly to potential customers, ask more questions, and tweak your offer. Sometimes it’s just a positioning problem.

Final Thoughts

Getting your first SaaS customers isn’t about being perfect. It’s about getting real people to trust you enough to give your product a shot. Start small. Talk to people. Solve real problems.

And keep improving a little every day.

If you need a hand with SaaS marketing or growing your idea, I’m always happy to connect. You can find me on X at x.com/_udemezue, or check out my portfolio: Udemezue.pages.dev.

Further Resources

If you want to dive deeper, check out:

• The Mom Test (book) — How to talk to customers and get honest feedback.

• Indie Hackers — A community where founders share how they got their first users.

• First 1000 Users Guide (from Demand Curve) — Very detailed but still easy to follow.

Now, Django has a built-in User model, but sometimes you might want a custom one. That's where things can get a little confusing if you're just starting.

The good news? Getting the user model in Django is very simple once you understand how Django is set up.

Today, I’ll walk you through exactly how to get the user model in Django, explain why it matters, show you real code you can use, and answer a few common questions people usually have around this topic.

Let's jump right into it.

Table of Contents

• Why Getting the User Model Correctly Matters

• How to Get the User Model in Django

• Full Example: Using the User Model

• When to Use settings.AUTH_USER_MODEL

• Quick Summary

• Common Mistakes to Avoid

• FAQs

  • 1. Can I access request.user it directly?

  • 2. What happens if I call get_user_model() Multiple times?

  • 3. How do I know if I’m using a custom user model?

  • 4. When should I create a custom user model?

• Further Resources

• Conclusion

Why Getting the User Model Correctly Matters

Before anything else, it’s important to know why this even matters.

Django projects depend heavily on user information – not just for logins, but for permissions, profiles, admin management, and much more.

If you get the user model the wrong way, you can easily run into problems later, especially if you customize your user model.

Django even warns you about this in its official documentation. If you don't use the right way to access the user model, your project could break when you change or extend it.

That’s why it’s super important to always get the user model the recommended way, which I’ll show you next.

How to Get the User Model in Django

Alright, here’s the simplest way to get the user model in Django:

from django.contrib.auth import get_user_model

User = get_user_model()

What’s happening here?

• get_user_model() is a built-in Django function.

• It returns the correct User model – whether you're using the default one or a custom one you created.

If you’re wondering why not just import from django.contrib.auth.models import User, the reason is this: if you ever swap out the default User model for a custom one, directly importing like that will break your code.

By using get_user_model(), you stay safe and future-proof your project.

Full Example: Using the User Model

Let’s look at a full working example, not just a little snippet.

Imagine you want to create a new user inside a Django view:

from django.contrib.auth import get_user_model
from django.http import HttpResponse

def create_user_view(request):
    User = get_user_model()
    user = User.objects.create_user(username='newuser', password='securepassword123')
    return HttpResponse(f"Created user: {user.username}")

In this example:

• First, I get the user model with get_user_model().

• Then, I use Django’s built-in create_user method to create a user safely.

• Finally, I send back a simple HTTP response showing the created username.

Notice how clean and flexible it is – no matter what user model you're using under the hood.

When to Use settings.AUTH_USER_MODEL

Another thing you’ll often see in Django projects is something like this:

from django.conf import settings

settings.AUTH_USER_MODEL

This doesn’t get the user model. Instead, it gives you the string path to the user model, like "auth.User" (for default) or "myapp.MyCustomUser" if you customized it.

You usually use settings.AUTH_USER_MODEL inside your models.py when you want to link to the User model in a ForeignKey, OneToOneField, or ManyToManyField.

For example:

from django.conf import settings
from django.db import models

class Profile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    bio = models.TextField()

Here, the Profile model is tied to the correct user model. Again, this keeps your project flexible and future-proof.

Quick Summary

Remember this table – it saves a lot of headaches later!

Common Mistakes to Avoid

• Directly importing User: Never just do from django.contrib.auth.models import User unless you are 100% sure you're sticking with the default model forever (not recommended).

• Hardcoding relationships: If you write something like ForeignKey('auth.User') instead of using settings.AUTH_USER_MODEL, it will break if you ever switch to a custom user model.

• Not creating custom user models early: If you think you might ever need a custom user model (like adding phone numbers, extra profile fields), set it up early. Switching later is painful once you have a database full of users.

FAQs

1. Can I access request.user directly?

Yes! Inside views, request.user gives you the current logged-in user object. Behind the scenes, Django is using the correct user model, whether it’s custom or default.

2. What happens if I call get_user_model() multiple times?

No problem at all. Django caches it internally, so it’s efficient. Feel free to call it wherever you need it.

3. How do I know if I’m using a custom user model?

Check your Django settings file (settings.py) and look for AUTH_USER_MODEL. If it’s set (like 'myapp.MyCustomUser', you are using a custom model. If it’s not there, Django is using the default.

4. When should I create a custom user model?

If you even think you’ll need fields like phone number, date of birth, profile pictures, and so on, it’s better to set up a custom model early.

Here’s a great guide from Django’s official docs on customizing user models.

Conclusion

Working with users in Django doesn’t have to be tricky. Once you know to use get_user_model() when you need the model and settings.AUTH_USER_MODEL for database relationships, your code stays clean, safe, and ready for whatever changes come your way.

Now that you know how to get the user model in Django, what’s one thing you'd love to customize about your users in your project? Shoot me a message on X.

If you want me to show you how to build a custom user model from scratch, let me know – it’s not hard once you know the steps.

Further Resources

• Official Django documentation: Using a custom user model

• Simple explanation on AbstractBaseUser vs AbstractUser

• StackOverflow: Best practices for Django user models

But to manage your data easily – adding, editing, or deleting entries – you need Django’s Admin panel.

Now, here’s the catch: just creating a model isn’t enough. If you want it to show up in the Admin panel, you have to register it.

And honestly, registering models in Django Admin is one of the simplest but most important steps. If you miss it, it feels like your model doesn’t even exist.

In this guide, I’ll walk you through exactly how to register your models in Django Admin, step-by-step, with easy-to-understand code examples.

Table of Contents

• Why Django Admin Matters

• How to Register Models in Django Admin

  • Step 1: Make Sure You Have a Model

  • Step 2: Register Your Model In Admin

  • Step 3: (Optional) Customize How Your Model Looks in Admin

• FAQS

  • 1. I added a model, but it’s not showing up in Admin. What happened?

  • 2. Do I have to register every model separately?

  • 3. How do I unregister a model?

• Helpful Links and Resources

• Final Thoughts

Why Django Admin Matters

Django Admin is like your personal dashboard for the backend of your website. Once you register your models, you can manage your app's content without touching any code.

Imagine being able to add new blog posts, approve users, update product listings – all with a few clicks. That’s the magic of Django Admin.

Without properly registering your models, you’re stuck managing everything manually, which can get messy real quick.

Plus, Django Admin saves developers hours of time. It’s one of the reasons Django is such a powerful framework.

How to Register Models in Django Admin

Step 1: Make Sure You Have a Model

Before you can register anything, you need a model. Here’s a super basic example of a model inside a Django app called blog.

Inside blog/models.py:

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    body = models.TextField()
    date_created = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

In this model:

• title is a short text field.

• body is for longer content.

• date_created automatically stores the time when the post is created.

And that __str__ method? That’s just telling Django how to show each Post in the Admin – it’ll display the post’s title instead of something like Post object (1).

Quick tip: Always add a __str__ method to your models. It makes your Admin interface much cleaner.

Step 2: Register Your Model in Admin

Alright, your model is ready. Time to register it!

Open blog/admin.py. When you create a new Django app, this file is empty by default.

Here’s how to register the Post model:

from django.contrib import admin
from .models import Post

admin.site.register(Post)

What’s happening here?

• First, you import Django’s admin module.

• Then, you import your model (Post).

• Finally, you use admin.site.register() to tell Django, "Hey, I want this model to show up in the Admin panel."

Save the file. Now if you go to your Admin site (usually at http://127.0.0.1:8000/admin), you’ll see Posts listed there.

Step 3: (Optional) Customize How Your Model Looks in Admin

By default, Django Admin shows your models in a very basic table. But you can make it so much better with a little customization.

Here’s how you can make Posts show the title and creation date at a glance.

Still inside blog/admin.py:

from django.contrib import admin
from .models import Post

class PostAdmin(admin.ModelAdmin):
    list_display = ('title', 'date_created')

admin.site.register(Post, PostAdmin)

Now:

• list_display tells Django which fields you want to show in the list view.

• You create a PostAdmin class that describes how the Post model should behave in Admin.

• When you register, you pass both the model (Post) and the admin class (PostAdmin).

Quick tip: Customizing your Admin improves your workflow a lot – especially when you’re managing many entries.

FAQS

1. I added a model, but it’s not showing up in Admin. What happened?

Make sure you:

• Registered the model inside admin.py.

• Ran migrations (python manage.py makemigrations and python manage.py migrate) if you changed anything in the model.

Also, check if the app is listed in your INSTALLED_APPS inside settings.py.

2. Do I have to register every model separately?

Yes. Each model you want to manage in Admin needs to be registered. But you can register multiple models together too:

from .models import Post, Comment, Category

admin.site.register([Post, Comment, Category])

3. How do I unregister a model?

You can use:

from django.contrib import admin
from .models import Post

admin.site.unregister(Post)

But honestly, most of the time, you just stop registering it if you don't want it there.

Final Thoughts

Registering models in Django Admin might seem like a tiny step, but it has a huge impact on how you work with your data.

It turns your database into a friendly dashboard that anyone can use – even non-technical people.

Once you get comfortable with registering and customising your models, you’ll move faster and feel a lot more in control of your app.

Now I’m curious — which model are you most excited to register in your Django Admin? Let’s chat on X.

Helpful Links and Resources

• Django Official Documentation – Admin Site

• Understanding Django Models (Real Python)

• Django Girls Tutorial – Introduction to Django Admin

These are great places to go if you want to dive even deeper into Django Admin customization.

So what’s going on?

This is where CORS (Cross-Origin Resource Sharing) comes in. It's a browser security feature that blocks web pages from making requests to a different domain than the one that served the web page.

It’s there to protect users, but if it’s not configured correctly, it can stop your app from working the way you want.

Let’s fix that.

In this article, I’ll walk you through everything you need to know to enable CORS in Django without headaches.

Here’s what we’ll cover:

• What is CORS and Why Should You Care?

• How to Enable CORS in Django

  • 1. Install django-cors-headers

  • 2. Add It to INSTALLED_APPS

  • 3. Add Middleware

  • 4. Set the Allowed Origins

• Optional Settings You Might Need

  • Allow All Origins (Not Recommended for Production)

  • Allow Credentials (Cookies, Auth)

  • Allow Specific Headers

• Example: Full Settings File Snippet

• Common Errors (And How to Fix Them)

  • 1. CORS Not Working At All?

  • 2. Preflight Request Fails (OPTIONS method)

  • 3. Using Django Rest Framework?

• FAQs

  • Can I allow multiple frontend URLs?

  • Does CORS affect local development only?

  • Is it secure to allow all origins?

  • Do I need to change anything on the frontend?

• Further Resources

• Final Thoughts

What is CORS and Why Should You Care?

Before you start changing settings, it’s important to understand what CORS is.

Imagine you have a frontend built with React running on http://localhost:3000 and a Django API running on http://localhost:8000.

When the frontend tries to talk to the backend, your browser sees that they’re not the same origin (they have different ports), and it blocks the request.

That’s CORS doing its job. It assumes you might be trying to do something unsafe – like stealing cookies or user data – so it steps in.

Now, as a developer, if you trust the frontend and you own both ends, then it’s safe to let those requests through. You just need to tell Django it’s okay.

How to Enable CORS in Django

You’re going to need a third-party package called django-cors-headers. It’s widely used and actively maintained. Here’s how to set it up:

1. Install django-cors-headers

Run this in your terminal:

pip install django-cors-headers

This adds the package to your environment so Django can use it.

2. Add It to INSTALLED_APPS

Open your settings.py file and find the INSTALLED_APPS section. Add this line:

INSTALLED_APPS = [
    ...
    'corsheaders',
]

This registers the app with Django.

3. Add Middleware

Now scroll down to the MIDDLEWARE section in settings.py. Add this at the top of the list:

MIDDLEWARE = [
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',
    ...
]

Why at the top? Because middleware in Django runs in order. If you don’t place it at the top, the CORS headers might not be added correctly, and your browser will still block your requests.

4. Set the Allowed Origins

This is where you tell Django which origins are allowed to talk to your backend.

Still in settings.py, add:

CORS_ALLOWED_ORIGINS = [
    "http://localhost:3000",
]

Replace localhost:3000 with whatever domain or port your frontend is using. If you're using HTTPS or deploying, make sure to include the correct URL, like https://yourfrontend.com.

And that’s it! You’re now allowing your frontend to access your backend.

Optional Settings You Might Need

Depending on your project, you might run into other issues. Here are some extra settings you might find useful:

Allow All Origins (Not Recommended for Production)

If you’re just testing and want to allow everything (be careful with this), you can use:

CORS_ALLOW_ALL_ORIGINS = True

Again, don’t use this in production unless you understand the risks. It can open up your API to abuse.

Allow Credentials (Cookies, Auth)

If your frontend is sending authentication credentials like cookies or tokens, you also need this:

CORS_ALLOW_CREDENTIALS = True

And make sure you don’t use CORS_ALLOW_ALL_ORIGINS with this setting – it won’t work due to security rules. Stick to CORS_ALLOWED_ORIGINS.

Allow Specific Headers

By default, common headers are allowed, but if you’re sending custom ones (like X-Auth-Token), you can add:

CORS_ALLOW_HEADERS = [
    "content-type",
    "authorization",
    "x-auth-token",
    ...
]

Example: Full Settings File Snippet

Here’s a mini version of what your settings.py might look like after setup:

INSTALLED_APPS = [
    ...
    'corsheaders',
    ...
]

MIDDLEWARE = [
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',
    ...
]

CORS_ALLOWED_ORIGINS = [
    "http://localhost:3000",
]

CORS_ALLOW_CREDENTIALS = True

You can tweak this based on your needs, but that’s the basic structure.

Common Errors (And How to Fix Them)

1. CORS Not Working At All?

Double check:

• You added corsheaders.middleware.CorsMiddleware it at the top of the middleware list.

• Your frontend origin matches exactly, including port and protocol.

• You restarted your server after changing the settings.

2. Preflight Request Fails (OPTIONS method)

Sometimes your browser sends an OPTIONS request first to check if the server will allow the real request. Make sure your views or Django setup allow that method, or Django will return a 405 error.

You don’t usually need to do anything here unless you’re using a custom middleware or view decorator that blocks it.

3. Using Django Rest Framework?

No problem – django-cors-headers works out of the box. Just make sure it’s installed and the middleware is set up correctly.

FAQs

Can I allow multiple frontend URLs?

Yes! Just add more items to the list:

CORS_ALLOWED_ORIGINS = [
    "http://localhost:3000",
    "https://myfrontend.com",
]

Does CORS affect local development only?

No, it applies in production too. Any time your frontend and backend are on different origins (different domain or port), you need to handle CORS.

Is it secure to allow all origins?

No. Only do that temporarily during development. Always restrict access in production to just the domains you trust.

Do I need to change anything on the frontend?

Sometimes. If you're sending credentials (like cookies), you’ll need to set credentials: "include" in your fetch or Axios requests.

Example with fetch:

fetch("http://localhost:8000/api/data", {
  method: "GET",
  credentials: "include",
})

Final Thoughts

CORS can feel like a wall you keep running into when building web apps. But once you get the hang of how it works – and how to set it up in Django – it becomes a small thing you configure and move on.

Just remember:

• Be specific in production

• Always restart the server after changes

• Don’t ignore warnings in your browser console – they’re your friends

Now you know how to enable CORS in Django the right way.

Further Resources

• django-cors-headers GitHub page – for full documentation.

• MDN CORS Overview – to understand how CORS works under the hood.

• Official Django Middleware Docs

Now, if you're new to Django or still wrapping your head around the basics, don’t worry. I’ve been there too. Models might sound a bit intimidating at first, but they’re pretty straightforward once you see how they work.

I’ll walk you through it all – step by step – so by the end of this post, you’ll not only know how to create models, but also how to use them in real projects.

Let’s get into it.

Here’s what we’ll cover:

1. What is a Model in Django?

2. How to Create Models in Django

   • Step 1: Start a Django Project (if you haven’t already)

   • Step 2: Define Your Model

   • Step 3: Register the App and Create the Database

   • Step 4: Create and Use Objects

3. Extra Model Features That You’ll Use

   • 1. Default Values

   • 2. Auto Timestamps

   • 3. Model Meta Options

4. Using Models in Django Admin

5. FAQs

6. Final Thoughts

What is a Model in Django?

A model in Django is just a Python class that tells Django how you want your data to look. Django takes care of the hard part (talking to the database), so you can focus on describing your data in simple Python code.

Here’s a quick example of a basic model:

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=50)
    published_date = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2)

Let me break it down:

• title and author are just short pieces of text, so I’m using CharField.

• published_date is a date – easy enough, that’s what DateField is for.

• price is a number with decimals, so DecimalField does the job.

Each line describes one piece of data I want to store for every book. Simple, right?

How to Create Models in Django

Step 1: Start a Django Project (if you haven’t already)

If you’re brand new, first you need a Django project:

django-admin startproject mysite
cd mysite
python manage.py startapp books

Now you’ve got a Django app called books where you can put your models.

Step 2: Define Your Model

Inside your app folder (books), open models.py. That’s where you’ll define your model.

Here’s a slightly more real-world example:

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    birthdate = models.DateField()

    def __str__(self):
        return self.name


class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    summary = models.TextField()
    isbn = models.CharField(max_length=13, unique=True)
    published = models.DateField()
    price = models.DecimalField(max_digits=6, decimal_places=2)

    def __str__(self):
        return self.title

What’s happening here:

• I’ve created two models: Author and Book.

• Book has a relationship with Author using ForeignKey. That means one author can have many books.

• I’m using __str__() to return a nice name when I look at objects in the Django admin.

Step 3: Register the App and Create the Database

Before Django can use your models, make sure your app is added to the project settings.

Open mysite/settings.py and find the INSTALLED_APPS list. Add 'books', to it:

INSTALLED_APPS = [
    # other apps
    'books',
]

Now, run migrations to create the database tables for your models:

python manage.py makemigrations
python manage.py migrate

This is how Django turns your Python code into actual database tables. The first command makes a migration file (basically, instructions for the database), and the second applies it.

Step 4: Create and Use Objects

Now you can use these models in your code. Open the Django shell:

python manage.py shell

Then try this out:

from books.models import Author, Book
from datetime import date

# Create an author
jane = Author.objects.create(name="Jane Austen", birthdate=date(1775, 12, 16))

# Create a book
book = Book.objects.create(
    title="Pride and Prejudice",
    author=jane,
    summary="A novel about manners and marriage in early 19th-century England.",
    isbn="1234567890123",
    published=date(1813, 1, 28),
    price=9.99
)

print(book)

Django will save these to your database automatically.

Extra Model Features That You’ll Use

1. Default Values

You can give a field a default value:

is_published = models.BooleanField(default=False)

2. Auto Timestamps

These are super useful when tracking created or updated times:

created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)

3. Model Meta Options

You can add class Meta to customize things like the default ordering:

class Book(models.Model):
    # fields...

    class Meta:
        ordering = ['published']

Using Models in Django Admin

Django’s built-in admin panel is one of the best parts of the framework. But your models won’t show up there unless you register them.

In books/admin.py, add:

from django.contrib import admin
from .models import Author, Book

admin.site.register(Author)
admin.site.register(Book)

Now run:

python manage.py createsuperuser

Then go to http://127.0.0.1:8000/admin, log in, and boom – your models are there, with a full interface.

FAQs

Can I change a model after I’ve made it?

Yes, but you’ll need to make a new migration:

python manage.py makemigrations
python manage.py migrate

What databases work with Django?

Django works with PostgreSQL, MySQL, SQLite (default), and more. Most people start with SQLite when learning because it's easy and works out of the box.

What’s the difference between CharField and TextField?

Use CharField for short text with a max length (like a name or title). Use TextField for longer text (like a blog post or summary).

Final Thoughts

Once you understand models, the rest of Django starts to click into place. Everything – forms, views, templates – eventually connects back to the model. It's how your app stores and works with real data.

The best way to learn is by building something. Start small, maybe a book catalog, a task manager, or a personal blog. Add models one at a time and play with them in the admin.

Further Resources

• Official Django Docs – Models

• Django Model Field Reference

• Simple Django Tutorial – Mozilla Developer Network

SECRET_KEY keeps your app secure by signing cookies, passwords, and other sensitive data. And if it ever gets exposed or leaked – yeah, that’s a problem.

Changing your Django SECRET_KEY is something you should do carefully. Maybe your key was committed to GitHub (we’ve all been there), or you just want to refresh it for better security.

Whatever the reason, I’ll walk you through how to do it safely without breaking anything. I’ll explain everything in plain English so you’re not left wondering what just happened.

Let’s get into it.

What Is The Django SECRET_KEY?

The SECRET_KEY is a long string of random characters stored in your settings.py file. It’s used internally by Django to:

• Securely sign session cookies

• Generate password reset tokens

• Protect data using cryptographic signing

Here’s what it looks like in your Django project:

# settings.py
SECRET_KEY = 'django-insecure-12345supersecretrandomstring'

If someone gets access to your SECRET_KEY, they could potentially:

• Forge session cookies and impersonate users

• Reset passwords or tamper with signed data

• Compromise the entire app

So yeah – it’s kind of a big deal.

When Should You Change Your Django Secret Key?

You should change your SECRET_KEY if:

• You accidentally shared it in public code (like GitHub)

• It was hardcoded in a file, and you want to switch to environment variables

• You’re rotating keys as part of a security policy

• You suspect it’s been compromised

Still not sure if it’s necessary? If the key has ever been shared or stored where someone else could access it, just change it.

How to Change Your Django SECRET_KEY Safely

1. Generate a New Secret Key

The key needs to be long, random, and secure. Django doesn’t provide a command for this out of the box, but you can generate one using Python.

Here’s a simple script:

from django.core.management.utils import get_random_secret_key

print(get_random_secret_key())

To run this:

1. Open your terminal

2. Run the Django shell with python manage.py shell

3. Paste in the script

It’ll return something like:

x3%6kn$mlg58+as!rcvnmvd8%(2p!p#&yk@r)+tdlj*w9kx!5gx

Copy this. You’ll need it in a second.

2. Store the Key Securely (Don’t Hardcode It)

Instead of pasting it into settings.py, it’s better to use an environment variable. That way, you don’t risk exposing it if you ever share your code.

Here’s how:

1. Open your .env file (create one if it doesn’t exist):

# .env
SECRET_KEY='x3%6kn$mlg58+as!rcvnmvd8%(2p!p#&yk@r)+tdlj*w9kx!5gx'

2. Install python-decouple if you haven’t already:

pip install python-decouple

3. Update your settings.py:

from decouple import config

SECRET_KEY = config('SECRET_KEY')

Now your key is stored outside your code. Much safer.

3. Commit Carefully

Make sure:

• Your .env file is added to .gitignore

• You never push it to your repository

Here’s how .gitignore should look:

# .gitignore
.env

You’d be surprised how often .env files get pushed by accident. Always double-check before you commit.

4. Restart Your App

After changing the key, restart your server. If you’re using a platform like Heroku or Docker, make sure you update the SECRET_KEY in your environment variables dashboard.

For Heroku:

heroku config:set SECRET_KEY='your-new-key'

For Docker:

# docker-compose.yml
environment:
  - SECRET_KEY=your-new-key

5. Re-Log In (and Ask Users To Do the Same)

Changing the secret key invalidates all old sessions. So, everyone (including you) will be logged out. This is expected behaviour. If you're running a public site, it’s a good idea to notify users in advance.

What Happens If You Don't Change It?

If your key is compromised, attackers can:

• Forge data

• Hijack accounts

• Break authentication systems

It’s not just about best practices. It’s about real-world security.

FAQs

Will this break my app?

No, as long as you restart your app and store the key properly, everything will work fine. Just remember: all users will be logged out.

Can I use the same key for multiple projects?

Nope. Each project should have its unique secret key.

Can I rotate the key regularly?

Yes, just be mindful that changing it too often will log users out repeatedly.

I forgot to add .env to .gitignore. What now?

Regenerate the key, update your project, and make sure the new .env file isn’t tracked.

Final Thoughts

Changing your Django SECRET_KEY might feel intimidating the first time, but it’s pretty simple when you break it down. As long as you generate a secure key, store it safely, and don’t expose it publicly, you’re doing great.

One last thing—when was the last time you checked if your secret key was accidentally pushed to GitHub? It might be a good time to take a quick look.

Helpful Resources

• Django Docs – SECRET_KEY

• GitGuardian – Secrets Detection

• 12 Factor App – Config

• Python-Decouple GitHub

Maybe you're trying to search for users with a username or an email that matches something. Or maybe you're trying to filter results where one condition is true but another is false.

That’s where Q comes in.

I remember the first time I ran into this problem – trying to use or in a .filter() and realizing quickly that regular Python logic doesn’t play nice there.

The error messages were confusing, and the docs didn’t help much. So let me break it down for you in a simple, practical way.

By the end of this guide, you’ll understand exactly what Q is, how it works, and how it can make your Django queries cleaner, more powerful, and a lot more flexible.

Table of Contents

• What's Q All About?

• How to Use Q in Django

  • Example 1: OR Logic

  • Example 2: AND Logic (Still Useful with Q)

  • Example 3: NOT Logic

• When Should You Use Q?

• Mixing Q and Regular Filters

• Real-World Example: Filtering Products

• Gotchas (Things To Watch Out For)

• Frequently Asked Questions

  • Is using Q slower than a regular filter()?

  • Can I use Q with annotate() or aggregate()?

  • Can I build Q objects dynamically?

• Further Resources

• Wrapping Up

What's Q All About?

In Django, the Q object (from django.db.models) lets you build complex queries using OR, AND, and NOT logic – something that’s hard to do using just regular .filter() calls.

Normally, when you use .filter() in Django, it adds AND logic like this:

MyModel.objects.filter(name='Alice', age=30)

This will get all rows where the name is 'Alice' and the age is 30. But what if you want:

Get all rows where name is 'Alice' or age is 30?

You can’t just do this:

MyModel.objects.filter(name='Alice' or age=30)  # ❌ This won't work!

That’s where Q comes in.

How to Use Q in Django

Here’s the basic import:

from django.db.models import Q

Now, you can use Q to create conditions and combine them using the | (OR), & (AND), and ~ (NOT) operators.

Let’s say you have a model like this:

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=100)
    age = models.IntegerField()
    city = models.CharField(max_length=100)

Example 1: OR Logic

from django.db.models import Q

people = Person.objects.filter(Q(name='Alice') | Q(age=30))

This will return anyone whose name is 'Alice' or whose age is 30. That’s clean and readable, right?

Example 2: AND Logic (Still Useful with Q)

people = Person.objects.filter(Q(name='Alice') & Q(age=30))

This will return people where both conditions are true. Technically, this gives the same result as using:

Person.objects.filter(name='Alice', age=30)

So why bother with Q here?

The real power of Q with AND is when you start nesting more complex conditions. For instance, suppose you want to find people who are named Alice and either live in Paris or are under 25. Here’s how you could write that:

people = Person.objects.filter(
    Q(name='Alice') & (Q(city='Paris') | Q(age__lt=25))
)

Without Q, this logic would be hard (and messy) to express. Q lets you group conditions logically and write flexible, readable queries.

Example 3: NOT Logic

What if you want everyone except people named Alice?

people = Person.objects.filter(~Q(name='Alice'))

The ~ operator flips the condition – it's saying “not this”.

When Should You Use Q?

You can reach for Q when:

• You need OR conditions

• You want to combine filters dynamically (for example, building a query based on user input)

• You need to write complex conditional logic

• You want to exclude certain things using ~Q(...)

But are there times you shouldn't use Q?

Yes – if you're writing a straightforward filter with only AND logic (like name='Alice' and age=30), using Q doesn't add much value. It can make your code unnecessarily verbose. Stick with plain .filter() unless you need more flexibility.

Mixing Q and Regular Filters

You can mix Q objects with normal keyword arguments in a filter. Just be careful with parentheses and order.

Person.objects.filter(Q(name='Alice') | Q(city='Paris'), age__gte=25)

This translates to:

(name = 'Alice' OR city = 'Paris') AND age >= 25

But here’s where parentheses make a big difference.

Take this incorrect example:

Person.objects.filter(Q(name='Alice') | Q(city='Paris') & Q(age__gte=25))

Due to operator precedence, this will evaluate as:

name = 'Alice' OR (city = 'Paris' AND age >= 25)

Which is not what you probably intended!

So when in doubt, use parentheses to clearly define your logic:

# Correct: (name = 'Alice' OR city = 'Paris') AND age >= 25
Person.objects.filter((Q(name='Alice') | Q(city='Paris')) & Q(age__gte=25))

Real-World Example: Filtering Products

Say you’ve got a Product model with price, in_stock, and category.

You want all products that are either:

• cheaper than $20 and in stock
  or

• In the 'Books' category

Here’s how that might look:

Product.objects.filter(
    (Q(price__lt=20) & Q(in_stock=True)) | Q(category='Books')
)

Without QYou’d have to write separate queries and merge them, or use more complicated logic. This way is faster and more efficient.

Things to Watch Out For

• Use parentheses: Just like in math, they control how things combine. Don’t trust default operator precedence unless you know it well.

• Don’t use or/and keywords: Python’s logical operators don’t work with Django ORM queries. Use | and & instead.

• Mixing Q with .exclude()? Be extra careful. Why? Because .exclude() inverts the logic of the entire filter. That means if you write:

    Person.objects.exclude(Q(name='Alice') & Q(city='Paris'))
  

  It’s saying: Exclude anyone who is named Alice and lives in Paris.

  But what if you wrote:

    Person.objects.exclude(Q(name='Alice') | Q(city='Paris'))
  

  Now it excludes anyone named Alice or who lives in Paris – a much broader exclusion! So always double-check what you're excluding.

• You might need to invert specific parts of your logic using ~Q(...) before passing them to .exclude() Rather than excluding the whole expression.

Frequently Asked Questions

Is using Q slower than a regular filter()?

Nope! Under the hood, Django converts your query into optimized SQL. Whether you use filter(name='Alice') or filter(Q(name='Alice'))Performance is almost the same. What matters more is how complex your query is.

Can I use Q with annotate() or aggregate()?

Yep. You can use Q with annotate() to apply conditional logic for things like counting or filtering within annotations.

from django.db.models import Count

# Count users with more than one blog post
User.objects.annotate(
    post_count=Count('posts', filter=Q(posts__published=True))
)

Can I build Q objects dynamically?

Absolutely. That’s one of the best parts! You can build up a list of Q() objects and combine them however you want:

filters = Q()
if search_name:
    filters |= Q(name__icontains=search_name)
if search_city:
    filters |= Q(city__icontains=search_city)

results = Person.objects.filter(filters)

This is especially useful for search forms or APIS where users can pass different combinations of filters.

Wrapping Up

So that’s Q In Django. It’s not some scary, abstract concept – it’s just a powerful way to control how your queries behave.

Once you get used to using Q, your code becomes cleaner, easier to read, and more flexible when handling complex filters.

Honestly, I can’t imagine writing Django queries without it anymore.

Further Resources

Want to go deeper?

• Django Q Object Official Docs

• Real Python's Guide to Q Objects

• Django ORM Cookbook – solid practical examples

If you’re working on a Django project – whether it’s a hobby blog, a client’s website, or a bigger web application – managing your admin accounts safely is a must.

And one key part of that? Making sure your superuser password is strong, secure, and easy for you to update.

You might be doing this because you forgot the old password, you're handing the project off to someone else, or you're tightening security after a team change.

Whatever your reason is, this guide will walk you through the easiest and safest ways to change a superuser password in Django.

I’ll break everything down in simple language, no heavy tech lingo or assumptions.

Let’s dive in.

What we’ll cover:

• Why Changing the Superuser Password Matters

• 3 Simple Ways to Change a Django Superuser Password

  • Method 1: Use Django’s Built-In Command

  • Method 2: Use the Django Shell

  • Method 3: Use Django Admin (If You’re Logged In)

• Bonus: Forgot Your Superuser Username?

• FAQs

  • What if I forgot both the username and password?

  • Will this log out other users?

  • Can I change the password from the database directly?

  • How do I know if my new password is secure?

• Final Thoughts

• Further Reading and Tools

Why Changing the Superuser Password Matters

Your Django superuser has full access to the admin dashboard. This means they can add or delete users, edit data, manage settings – everything. If that account gets compromised, the whole site is at risk.

Here’s what could go wrong if the password is weak or outdated:

• Someone could delete your database.

• A hacker could inject malicious data.

• Private user info could be exposed.

According to Verizon’s Data Breach Investigations Report, over 80% of hacking-related breaches are due to compromised or weak passwords. That’s a huge risk for something that’s easy to fix in a few minutes.

So let’s make sure your Django admin is locked down tight – without breaking anything.

3 Simple Ways to Change a Django Superuser Password

I’ll show you three different ways to update your superuser password. You only need to pick one that fits your current setup.

Method 1: Use Django’s Built-In Command

If you have access to the command line and your project’s virtual environment, this is the cleanest way.

Activate your virtual environment

This depends on your setup, but if you're using venv it might look like this:

source venv/bin/activate

Or on Windows:

venv\Scripts\activate

Navigate to your project folder

This is where manage.py lives:

cd your_project_folder

Run the following command:

python manage.py changepassword your_superuser_username

Example:

python manage.py changepassword admin

Django will then ask you to enter a new password. Type it in, hit enter, confirm it again, and you’re done.

That’s it. You just changed your superuser password!

Method 2: Use the Django Shell

Maybe you don’t remember the username or want more control. The Django shell lets you interact directly with your database using Python.

Here’s how:

First, open the shell:

python manage.py shell

Then run the following code:

from django.contrib.auth import get_user_model

User = get_user_model()

user = User.objects.get(username="admin")  # Replace 'admin' with your username
user.set_password("new_secure_password")   # Replace with your new password
user.save()

Now exit the shell:

exit()

That’s it. This method is especially helpful if you’re working in a staging environment or doing things programmatically.

Method 3: Use Django Admin (If You’re Logged In)

This one only works if you can still log in with the current superuser account.

1. Go to your Django admin page, usually at http://127.0.0.1:8000/admin/.

2. Log in with your current credentials.

3. Click on Users.

4. Find your superuser account and click on it.

5. Scroll down to the “Password” section and click "this form" under the "Raw passwords are not stored..." message.

6. Enter your new password twice and save.

This method is super quick and doesn’t require any code at all.

Bonus: Forgot Your Superuser Username?

If you don’t remember the exact username of your superuser, no worries. You can list all users like this:

python manage.py shell

Then:

from django.contrib.auth import get_user_model

User = get_user_model()

for user in User.objects.all():
    print(user.username)

This will print out all usernames in your system, including your superuser.

FAQs

What if I forgot both the username and password?

Use the shell method above to list all usernames, then reset it using either the shell or the changepassword command.

Will this log out other users?

Changing your superuser password won’t affect other users unless you have custom logic tied to sessions. For most projects, everything else keeps running just fine.

Can I change the password from the database directly?

Technically yes, but don’t do it. Passwords in Django are hashed using PBKDF2 by default. If you enter something manually in the database, it won’t work unless it's hashed the right way. Always use the Django shell or admin panel instead.

How do I know if my new password is secure?

Django checks password strength by default. But if you want to be extra safe, use a tool like Bitwarden Password Generator or 1Password’s Generator.

Final Thoughts

That’s pretty much everything you need to know to change your superuser password in Django. It’s quick, safe, and once you’ve done it once, it’ll be second nature.

It’s small actions like this that go a long way in keeping your Django projects secure. And since it only takes a minute or two, there’s no reason to put it off.

Let’s keep the conversation going, Connect with me on x.com/_udemezue

Further Reading and Tools

• Official Django change password documentation

• How Django stores passwords securely

• PBKDF2 explained on OWASP

That’s where ForeignKey comes in. It helps link one model to another, like tying a comment to a post, or an order to a customer.

It’s one of those things in Django that can seem confusing at first, but once it clicks, you’ll wonder how you ever built apps without it.

So let’s break it all down. I’ll walk you through everything from what a ForeignKey is, to how to use it in your Django project.

Here’s what we’ll cover:

• What is a Foreign Key in Django?

• Why Use a ForeignKey Instead of Storing IDs Manually?

• Real-World Example: Blog Posts and Comments

• What is on_delete and Why Does It Matter?

• How to Access Related Objects in Django

• How to Create Foreign Key Relationships in Django Admin

  • What Happens in the Database?

• How to Query with ForeignKey

  • Get all comments for a post with id=1:

  • Get all posts that have at least one comment by a specific user:

• FAQs

  • Can a ForeignKey be optional?

  • Can a ForeignKey point to the same model (self)?

  • Can a model have more than one ForeignKey?

• Final Thoughts

  • Further Resources

What is a Foreign Key in Django?

In the simplest terms, a Foreign Key in Django creates a many-to-one relationship between two models. This means many rows in one table can be related to a single row in another.

For example:

• One blog post can have many comments

• One customer can have many orders

• One author can write many books

If you're coming from a spreadsheet background, think of it like linking two sheets using a shared column. In Django, you do this in your model definitions.

Why Use a ForeignKey Instead of Storing IDs Manually?

You might be wondering, “Why not just store the ID of the related object in a plain integer field?”

Well, you could – but you'd lose a ton of power. Without a ForeignKey:

• You don’t get automatic validation that the related object exists.

• You can't follow relationships easily in queries (for example, post.comments.all() wouldn’t be possible).

• The Django admin can’t provide dropdowns or inline forms for related data.

• You lose out on helpful features like on_delete behaviour and related object naming.

ForeignKey fields automate and enforce these relationships, making your code cleaner, more secure, and easier to maintain.

Real-World Example: Blog Posts and Comments

Let’s say you’re building a blog. You’ll probably have a Post model and a Comment model. Each comment needs to be linked to a specific post.

Here’s how that looks in code:

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    published_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

class Comment(models.Model):
    post = models.ForeignKey(Post, on_delete=models.CASCADE)
    author = models.CharField(max_length=100)
    text = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f'Comment by {self.author}'

Let me explain each part of that:

• models.ForeignKey(Post, on_delete=models.CASCADE): This line creates the connection. It means each comment is linked to one post. The on_delete=models.CASCADE part tells Django to delete all related comments if a post is deleted.

• __str__ methods just make it easier to read things in the admin or shell.

What is on_delete and Why Does It Matter?

When you create a ForeignKey in Django, you have to include an on_delete argument. This controls what happens to the child rows (like comments) if the parent row (like a blog post) is deleted.

Here are the common options:

• models.CASCADE: Delete the child rows, too (like deleting all comments when a post is deleted).

• models.PROTECT: Prevent deletion if there are related objects.

• models.SET_NULL: Set the ForeignKey to NULL instead of deleting.

• models.SET_DEFAULT: Set a default value.

• models.DO_NOTHING: Do nothing (not recommended unless you really know what you're doing).

I usually go with CASCADE for simple apps, but it's worth thinking through depending on the situation.

How to Access Related Objects in Django

Once you’ve set up the ForeignKey, Django gives you a few nice tools to work with related data.

For example, let’s say you have a post object:

post = Post.objects.get(id=1)

You can get all comments for that post like this:

comments = post.comment_set.all()

The comment_set is automatically created by Django, and you can customize the name with related_name:

class Comment(models.Model):
    post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='comments')

Now you can do:

post.comments.all()

Much cleaner, right?

How to Create Foreign Key Relationships in Django Admin

The Django admin handles ForeignKeys well. If you’ve got both Post and Comment models registered in admin.py, you’ll get a dropdown in the comment form to select the post it belongs to.

You can also make inline forms, so you can add comments while editing a post. Here’s a quick example:

from django.contrib import admin
from .models import Post, Comment

class CommentInline(admin.TabularInline):
    model = Comment
    extra = 1

class PostAdmin(admin.ModelAdmin):
    inlines = [CommentInline]

admin.site.register(Post, PostAdmin)
admin.site.register(Comment)

Now when you're editing a post, you can add or edit comments right there on the same page.

What Happens in the Database?

Django uses a relational database (like PostgreSQL, MySQL, or SQLite), and ForeignKey creates a column in the database table that holds the ID of the related object.

If you run python manage.py makemigrations and then python manage.py migrate, Django will create the actual database tables with the proper relationships behind the scenes.

How to Query with ForeignKey

You can also filter or search based on ForeignKey relationships:

Get all comments for a post with id=1:

Comment.objects.filter(post_id=1)

Or, using the post object:

post = Post.objects.get(id=1)
comments = Comment.objects.filter(post=post)

Get all posts that have at least one comment by a specific user:

Post.objects.filter(comments__author='John')

That comments__author part is thanks to the related_name='comments' I added earlier.

FAQs

Can a ForeignKey be optional?

Yes, just add null=True, blank=True like this:

post = models.ForeignKey(Post, on_delete=models.SET_NULL, null=True, blank=True)

You might want this if the related object isn't always required. For example, a Comment might optionally belong to a Post, or a Task might optionally have a related Project. It’s useful when building drafts, soft deletes, or handling legacy data.

Can a ForeignKey point to the same model (self)?

Absolutely. That’s called a self-referential ForeignKey, often used for things like threaded comments or categories.

class Category(models.Model):
    name = models.CharField(max_length=100)
    parent = models.ForeignKey('self', null=True, blank=True, on_delete=models.SET_NULL)

Can a model have more than one ForeignKey?

Totally. For example, an Order model could have one ForeignKey to a Customer, and another to a ShippingAddress.

Final Thoughts

If you’re building anything in Django that deals with more than one model, understanding ForeignKey is essential. It makes your app more structured, easier to query, and way more powerful.

At first, it might feel like a lot, but once you build one or two relationships and see it all working in the admin and your views, it clicks.

And if something’s still unclear, that’s normal. I had to build a few mini-projects before it started to feel natural.

Further Resources

• Django Docs on ForeignKey

• Django Model Field Reference

• Writing Models in Django

• Django Admin Docs

I’ve used it across multiple projects – from small web apps to large-scale platforms – and it never disappoints.

In this post, I’ll walk you through how to connect PostgreSQL with Django step-by-step.

Let’s get started.

What we’ll cover:

1. Why Use PostgreSQL with Django?

2. What You'll Need

3. How to Use PostgreSQL in Django

   • Step 1: Install PostgreSQL

   • Step 2: Install the PostgreSQL Adapter for Python

   • Step 3: Create a Django Project (If You Haven’t Yet)

   • Step 4: Create a PostgreSQL Database

   • Step 5: Update Django Settings to Use PostgreSQL

   • Step 6: Run Migrations

   • Step 7: Test the Connection

4. Common Issues (and Fixes)

5. Optional: Use dj-database-url for Better Settings

6. Frequently Asked Questions

   • Is PostgreSQL better than SQLite for Django?

   • Do I need to install PostgreSQL on my production server?

   • Is psycopg2-binary safe to use in production?

   • Can I switch from SQLite to PostgreSQL mid-project?

7. Wrapping Up

8. Further Resources

Why Use PostgreSQL with Django?

PostgreSQL is a popular, open-source relational database that’s known for its performance, flexibility, and powerful features like:

• Advanced data types (JSON, arrays, and so on)

• Full-text search

• Support for complex queries

• Data integrity and reliability

Django officially recommends PostgreSQL as the most feature-complete database backend it supports. If you're planning to build a serious web application, PostgreSQL is usually the best database to pair with Django.

What You’ll Need

Before we begin, make sure you have the following:

• Python installed (3.7 or higher is best)

• Django installed (I’ll be using version 4.x)

• PostgreSQL installed and running

• psycopg2 or psycopg2-binary (This is the adapter that lets Django talk to PostgreSQL)

How to Use PostgreSQL in Django

Here is how to get started:

Step 1: Install PostgreSQL

If you haven’t installed PostgreSQL yet, you can grab it from the official PostgreSQL website. It works on Windows, macOS, and Linux.

Make sure you remember the username, password, and database name when you set it up – you’ll need those later.

Step 2: Install the PostgreSQL Adapter for Python

Django needs a little help to connect with PostgreSQL. That’s where psycopg2 comes in.

You can install it using pip:

pip install psycopg2-binary

Tip: The -binary version is easier to install and works for most people. If you run into issues later, you can switch to psycopg2 (non-binary).

Step 3: Create a Django Project (If You Haven’t Yet)

If you haven’t created a project yet, start with:

django-admin startproject myproject
cd myproject

This will give you the basic project structure.

Step 4: Create a PostgreSQL Database

Now, open your PostgreSQL client (like psql or pgAdmin), and create a new database:

CREATE DATABASE mydatabase;
CREATE USER myuser WITH PASSWORD 'mypassword';
ALTER ROLE myuser SET client_encoding TO 'utf8';
ALTER ROLE myuser SET default_transaction_isolation TO 'read committed';
ALTER ROLE myuser SET timezone TO 'UTC';
GRANT ALL PRIVILEGES ON DATABASE mydatabase TO myuser;

This sets up a database and user with the right permissions. Replace mydatabase, myuser, and mypassword with whatever values you prefer.

Step 5: Update Django Settings to Use PostgreSQL

Now it’s time to tell Django to use your new PostgreSQL database.

Open myproject/settings.py and look for the DATABASES setting. Replace the default sqlite3 section with this:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

This tells Django to:

• Use PostgreSQL (django.db.backends.postgresql)

• Connect to a local database called mydatabase

• Use the user and password you set up earlier

Step 6: Run Migrations

Now that everything’s connected, let’s create the database tables Django needs:

python manage.py migrate

If everything’s working, you’ll see Django creating tables in PostgreSQL. No errors? You’re good to go!

Step 7: Test the Connection

Let’s test it all by creating a superuser (admin account):

python manage.py createsuperuser

Follow the prompts, then run:

python manage.py runserver

Open your browser and go to http://127.0.0.1:8000/admin. Log in with your superuser account. You’ll be in the Django admin dashboard – and yes, all of this is backed by PostgreSQL now!

Common Issues (and Fixes)

Here are a few things that might trip you up:

• Error: psycopg2.errors.UndefinedTable: This usually means you forgot to run migrate.

• Can’t connect to database: Double-check your database name, user, and password. Make sure PostgreSQL is running.

• Role doesn’t exist: You might’ve forgotten to create the user in PostgreSQL, or you used the wrong name in settings.py.

Optional: Use dj-database-url for Better Settings

If you’re planning to deploy your app later (especially on services like Heroku), managing your database settings through a URL is cleaner.

Install the helper package:

pip install dj-database-url

Then in your settings.py:

import dj_database_url

DATABASES = {
    'default': dj_database_url.config(default='postgres://myuser:mypassword@localhost:5432/mydatabase')
}

This lets you control your database config from an environment variable, which is more secure and flexible.

Frequently Asked Questions

Is PostgreSQL better than SQLite for Django?

For learning or small projects, SQLite is fine. But for serious apps with lots of users or advanced queries, PostgreSQL is much better.

Do I need to install PostgreSQL on my production server?

Yes – unless you’re using a hosted PostgreSQL solution like Amazon RDS, Heroku Postgres, or Supabase.

Is psycopg2-binary safe to use in production?

Yes, for most cases. But some recommend switching to the non-binary version (psycopg2) in production for better control.

Can I switch from SQLite to PostgreSQL mid-project?

Yes, but you’ll need to migrate your data. Tools like Django’s dumpdata and loaddata can help with that.

Wrapping Up

Using PostgreSQL in Django is a great step forward when you want to build real, production-ready apps.

The setup is pretty straightforward once you know the steps, and the performance gains are worth it.

Come say hey on X.com/_udemezue and check out my blog while you're at it!

Further Resources

If you want to dive deeper, here are a few links I recommend:

• Django Database Settings Docs

• PostgreSQL Official Documentation

• Using PostgreSQL with Django (Real Python)

Maybe you’re switching hosting providers. Maybe you're backing things up or sharing data with someone. Or maybe you just want to peek at your data in a different format.

Exporting a database sounds technical (and yeah, it kind of is), but it doesn’t have to be hard. Django gives you built-in tools that make the process much easier than most people expect.

I’ve worked with Django for a while now, and I’ve helped developers, from beginners to pros, deal with database exports.

In this tutorial, I’m going to walk you through all the ways you can export your database in Django.

Here’s what we’ll cover:

• Why Would You Want To Export Your Database?

• First Things First: Know Your Database

  • Method 1: Use Django’s dumpdata Command

  • A Quick Tip About Fixtures

  • Method 2: Use Your Database’s Tools

  • Method 3: Export to CSV for Excel or Google Sheets

  • Method 4: Use Django Admin Actions

• FAQs

  • Can I export data in XML format instead of JSON?

  • What’s the best format for backups?

  • Can I automate backups?

• Further Reading

• Wrapping Up

Why Would You Want To Export Your Database?

There are a bunch of reasons you might want to export your Django database:

• Backup: Before making big changes, it's smart to save a copy.

• Migration: Moving to another server or switching from SQLite to PostgreSQL.

• Sharing data: Giving a snapshot of the data to teammates or analysts.

• Testing: Populating a test or staging environment with real data.

• Compliance: Legal or policy reasons for storing data outside your app.

The good news? Django has solid tools to help you do all this quickly and cleanly.

First Things First: Know Your Database

Django supports several types of databases: SQLite (the default), PostgreSQL, MySQL, and more. Depending on what you’re using, your export process might look a little different.

But for most common cases, especially if you’re using SQLite or PostgreSQL, the methods I’m about to show you will work great.

Method 1: Use Django’s dumpdata Command

This is the easiest and most common way to export your data.

Step-by-step:

1. Open your terminal.

2. Navigate to your Django project folder.

3. Run the following command:

python manage.py dumpdata > db.json

That’s it. You’ve just exported all your data into a JSON file called db.json.

What’s happening here?

• dumpdata is a Django management command that goes through your database and exports the data from all the models.

• The > the symbol means "send the output into a file" instead of printing it on the screen.

Want to export just one app?

You can be more specific:

python manage.py dumpdata myapp > myapp_data.json

Or even one model:

python manage.py dumpdata myapp.MyModel > model_data.json

This is useful if your database is big and you only need a slice of it.

A Quick Tip About Fixtures

The file you just created (db.json) is called a fixture in Django. You can use it to load data into another project using:

python manage.py loaddata db.json

So yeah, dumpdata + loaddata is a super handy combo for moving data around.

Method 2: Use Your Database’s Tools

Depending on what database you're using, you can also use tools that work outside of Django.

For SQLite (Django’s default)

Your database is just a file, usually named db.sqlite3.

You can copy it like any other file:

cp db.sqlite3 db_backup.sqlite3

If you want to export the data as SQL statements, you can use the sqlite3 command-line tool:

sqlite3 db.sqlite3 .dump > db_dump.sql

This creates a file with all the SQL commands needed to recreate your database. Pretty handy for backups.

For PostgreSQL

You’ll need access to pg_dump, which is PostgreSQL's built-in export tool.

Here’s an example:

pg_dump -U your_username your_database > backup.sql

You might need to enter your password, depending on how your database is set up.

You can find more info on pg_dump here.

Method 3: Export to CSV for Excel or Google Sheets

If you want your data in a spreadsheet, you can export it to CSV format.

Django doesn’t have a built-in command for this, but you can write a simple script.

Here’s an example that exports all entries from a model:

Example:

Let’s say you have a model like this:

# models.py
from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)

To export it to CSV:

# export_books.py
import csv
from myapp.models import Book

with open('books.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Title', 'Author'])

    for book in Book.objects.all():
        writer.writerow([book.title, book.author])

Run this script with Django’s shell:

python manage.py shell < export_books.py

Now you have a books.csv file you can open in Excel or Google Sheets.

Method 4: Use Django Admin Actions

If your model is registered in the Django admin, you can create a custom admin action that lets you export data directly from the interface.

Here’s a quick example:

# admin.py
import csv
from django.http import HttpResponse
from .models import Book

@admin.action(description='Export selected books to CSV')
def export_to_csv(modeladmin, request, queryset):
    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename=books.csv'
    writer = csv.writer(response)
    writer.writerow(['Title', 'Author'])

    for book in queryset:
        writer.writerow([book.title, book.author])

    return response

class BookAdmin(admin.ModelAdmin):
    actions = [export_to_csv]

admin.site.register(Book, BookAdmin)

Now you can select rows in the Django admin and export them. Easy and user-friendly.

FAQs

Can I export data in XML format instead of JSON?

Yes! Just add the --format option:

python manage.py dumpdata --format=xml > db.xml

What’s the best format for backups?

JSON is great for Django-to-Django transfers. SQL (using pg_dump or sqlite3 .dump) is better for full database backups.

Can I automate backups?

Totally. Set up a cron job or a simple Python script that runs dumpdata on a schedule and saves the file to cloud storage.

Wrapping Up

Exporting your database in Django doesn’t have to be a big deal. With built-in commands like dumpdata, or even custom scripts for CSV exports, you can handle data safely and with confidence. And once you get the hang of it, you’ll probably use these tools all the time.

Further Reading

• Django dumpdata documentation

• PostgreSQL pg_dump

• Backing up SQLite databases

• Django loaddata command

Docker makes it possible to package your Django app, along with all its dependencies, into something called a “container.”

That way, it runs the same on your computer, your teammate’s computer, a testing server, or even in production.

When I first started using Docker, it felt a little overwhelming. But after setting it up for a few Django apps, it all clicked.

The good news? I’m going to walk you through it, step by step, in a way that’s easy to follow, even if you’re brand new to Docker.

Table of Contents

1. What You’ll Need

2. How to Dockerize Your Django Project

   • Step 1: Start a Django Project

   • Step 2: Create a Dockerfile

   • Step 3: Add a requirements.txt

   • Step 4: Create docker-compose.yml

   • Step 5: Run It!

3. Common Issues

   • Port Already in Use?

   • Database Not Working?

4. FAQs

   • Do I need Docker for development?

   • Can I run migrations inside Docker?

   • How do I stop everything?

5. Extra Tip: Use .dockerignore

6. What You’ve Built

7. Want to Go Deeper?

8. Further Reading

What You’ll Need

Before we begin, make sure you’ve got a few things installed:

• Python 3 (any version that Django supports)

• Django (of course)

• Docker and Docker Compose
  👉 Install Docker
  👉 Install Docker Compose

You don’t need to be an expert in Docker. I’ll explain what each part does as we build it together.

How to Dockerize Your Django Project

Step 1: Start a Django Project

If you already have a Django project, you can skip this part.

Otherwise, open your terminal and run:

django-admin startproject myproject
cd myproject

This will create a new Django project called myproject. You’ll see a structure like this:

myproject/
├── manage.py
└── myproject/
    ├── __init__.py
    ├── asgi.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py

Let’s say this is your app that you want to run inside Docker.

Step 2: Create a Dockerfile

In the root of your project (same folder as manage.py), create a file called Dockerfile. No file extension –just Dockerfile.

Here’s what goes inside:

# Use the official Python image
FROM python:3.10-slim

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

# Set the working directory in the container
WORKDIR /app

# Install dependencies
COPY requirements.txt /app/
RUN pip install --upgrade pip && pip install -r requirements.txt

# Copy the rest of the code
COPY . /app/

Let me break that down:

• FROM python:3.10-slim: This tells Docker to use a lightweight version of Python 3.10.

• ENV: These just help with cleaner logs and better performance.

• WORKDIR /app: This sets the default working directory inside the container.

• COPY and RUN: These lines copy your code into the container and install your Python packages.

Step 3: Add a requirements.txt

You’ll need a file listing your Python packages.

Create a file called requirements.txt in the root folder and add:

Django>=4.0,<5.0

You can add more later if your project grows. For now, that’s enough.

To generate a full list of dependencies from your local virtual environment, run:

pip freeze > requirements.txt

Step 4: Create docker-compose.yml

Now let’s create the file that tells Docker how to run everything together.

In your root folder, create docker-compose.yml:

version: '3.9'

services:
  web:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    volumes:
      - .:/app
    ports:
      - "8000:8000"

Let’s go line-by-line:

• build: .: This tells Docker to use the Dockerfile in the current folder.

• command: This runs Django’s development server inside the container.

• volumes: This mounts your code into the container so changes are reflected live.

• ports: This maps port 8000 inside Docker to port 8000 on your machine.

So if you go to http://localhost:8000, you’ll see your app.

Step 5: Run It!

Now the fun part. From your terminal, run:

docker-compose up --build

This tells Docker to:

• Build the container

• Install dependencies

• Run the Django server

If everything goes well, you’ll see logs from the Django server, and you can open your browser and go to http://localhost:8000.

You should see the Django welcome screen.

Common Issues

Port Already in Use?

If port 8000 is busy, change this line in docker-compose.yml:

ports:
  - "8001:8000"

Then go to http://localhost:8001.

Database Not Working?

If you need a database (like PostgreSQL), you can add another service to docker-compose.yml. Here's an example with PostgreSQL:

services:
  db:
    image: postgres
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
  web:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    volumes:
      - .:/app
    ports:
      - "8000:8000"
    depends_on:
      - db

Then, update your settings.py in Django to use that database.

FAQs

Do I need Docker for development?

No, but it helps keep your environment clean and consistent. If it works in Docker, it'll work anywhere.

Can I run migrations inside Docker?

Yes! Just run:

docker-compose run web python manage.py migrate

How do I stop everything?

Press Ctrl+C to stop the running server, and if you want to remove containers:

docker-compose down

Extra Tip: Use .dockerignore

Just like .gitignore, you can create a .dockerignore file to avoid copying unnecessary files into the Docker container. Here’s a simple one:

__pycache__
*.pyc
*.pyo
*.pyd
.env
.git

What You’ve Built

By now, you’ve:

• Created a Django project

• Built a Docker container for it

• Set up docker-compose to run everything

• Learned how to manage it all easily

Once you’re comfortable, you can expand this setup with static files, NGINX, Gunicorn, or even production-ready Docker builds.

Want to Go Deeper?

If this feels like a lot, that’s ok. It takes a little practice, but once you’ve done it a few times, Docker becomes second nature.

You’ll spend less time debugging setup issues and more time coding your app.

Further Reading

• Docker Documentation

• Django Official Docs

• Compose File Reference

The good news? You don’t have to sit around waiting. You can hand those tasks off to something else and let your app keep doing its thing. That "something else" is Celery.

Celery lets you run time-consuming tasks in the background while your app stays fast. And if you're using Django, it's actually not that hard to plug it in – once you understand how the pieces work together.

In this guide, I’ll walk you through what Celery is, why it’s useful, and exactly how to set it up with Django step by step.

Table Of Contents

1. What Is Celery and Why Should You Use It in Django?

2. How Celery Works (The Simple Version)

3. How to Use Celery in Django

   • 1. Install the right packages

   • 2. Create a celery.py file in your project folder

   • 3. Add Celery to init.py

   • 4. Set the broker URL in your settings

   • 5. Write your first task

   • 6. Call the task from your views

   • 7. Run the Celery worker

4. Optional: Using Django Admin to Monitor Tasks

5. FAQ

   • What happens if Redis goes down?

   • Can I retry failed tasks?

   • Is Celery the only option?

6. Wrapping It Up

7. Further Reading and Resources

What Is Celery and Why Should You Use It in Django?

Imagine you’re running an online shop. Someone places an order. You want to:

• Save the order to the database

• Send them an invoice by email

• Notify your warehouse

• Maybe even start printing a shipping label

If your app tries to do all this at once, your user is going to be stuck staring at a loading screen. Instead, what if you only saved the order right away – and passed the rest to Celery to handle in the background?

That’s exactly what Celery does.

It’s a task queue — which just means it runs things later, so your main app doesn’t have to wait. It’s especially helpful for:

• Sending emails

• Data imports/exports

• Running machine learning models

• Scraping data

• Generating reports

And yeah, it works really well with Django.

How Celery Works (The Simple Version)

Celery is made up of a few parts:

1. Task producer (your Django app) – This is where you call a task.

2. Broker (usually Redis) – This is the middleman. It takes the task and holds it until a worker can grab it.

3. Worker – This is Celery’s background process that grabs tasks from the broker and runs them.

Here’s the flow:

Django app → Redis → Celery Worker → Done ✅

Now let’s actually set this up.

How to Use Celery in Django

1. Install the right packages

You’ll need celery and a message broker. Redis is a popular choice.

pip install celery redis

Also make sure you have Redis running. You can install it locally via Homebrew (brew install redis) or use a Docker container.

If you’re using Docker:

docker run -p 6379:6379 redis

2. Create a celery.py file in your project folder

Let’s say your Django project is called myproject. Inside that same folder (where settings.py is), create a file called celery.py.

# myproject/celery.py
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()

Here’s what’s happening:

• os.environ... sets up Django’s settings.

• Celery("myproject") creates a new Celery app with your project name.

• app.config_from_object(...) tells Celery to read config from Django’s settings file.

• autodiscover_tasks() tells Celery to find tasks in your Django apps automatically.

3. Add Celery to __init__.py

Still in your myproject/ folder, open __init__.py and add:

from .celery import app as celery_app

__all__ = ("celery_app",)

This makes sure Celery starts with Django.

4. Set the broker URL in your settings

Open settings.py and add:

CELERY_BROKER_URL = 'redis://localhost:6379/0'

This tells Celery to use Redis as the broker.

5. Write your first task

Go to one of your Django apps (say you’ve got an app called shop), and create a file called tasks.py.

# shop/tasks.py
from celery import shared_task

@shared_task
def send_invoice_email(order_id):
    # Imagine this sends an email
    print(f"Sending invoice email for order {order_id}")

The @shared_task decorator tells Celery this is a background task.

6. Call the task from your views

Here’s how you’d use it in a Django view:

# shop/views.py

from .tasks import send_invoice_email
from django.shortcuts import render

def place_order(request):
    # pretend this saves an order
    order_id = 1234  # this would come from your model

    # run the task in the background
    send_invoice_email.delay(order_id)

    return render(request, "order_complete.html")

Notice the .delay() – this is what sends the task to Celery.

7. Run the Celery worker

Now open a terminal and start the worker:

celery -A myproject worker --loglevel=info

You should see the worker start and wait for tasks. When you place an order, it’ll print something like:

Sending invoice email for order 1234

Optional: Using Django Admin to Monitor Tasks

If you want to monitor task status in the admin, you can use django-celery-results.

pip install django-celery-results

Then update your settings.py:

INSTALLED_APPS += ["django_celery_results"]

CELERY_RESULT_BACKEND = "django-db"

Run migrations:

python manage.py migrate

Now Celery will save task results in your database, and you can see them in Django admin.

FAQ

What happens if Redis goes down?

Your tasks won’t be sent or picked up. But once Redis comes back, things should resume.

Can I retry failed tasks?

Yes! Celery supports retries. You can set how many times a task should retry and how often. Example:

@shared_task(bind=True, max_retries=3)

def risky_task(self):
    try:
        # Do something risky
        pass
    except Exception as e:
        raise self.retry(exc=e, countdown=60)

Is Celery the only option?

No. There’s also Django Q, Dramatiq, and Huey. But Celery is the most mature and has the biggest community.

Wrapping It Up

Using Celery in Django doesn’t just speed things up – it also helps improve the experience for your users.

Offloading heavy or slow tasks makes your app feel snappier and more reliable.

Once you get the basics down, you’ll find yourself using it for all kinds of things.

Further Reading and Resources

• Celery Documentation

• Redis Quickstart

• django-celery-results

• Asynchronous Tasks in Django (Real Python)

• Celery Monitoring with Flower