Optimize Django Queries with select_related() and prefetch_related()

This one Django mistake made my query 12 seconds slow, and I realize it for hours.... 12 seconds… for a simple page. At first, I thought: “Maybe my system is slow.” But the real problem was my query. Here’s what was wrong 👇 I was doing this: • Fetching all records • Looping in Python to filter data • Multiple DB hits inside a loop Basically… I made Django work harder than needed. Here’s what fixed it: ✅ Used `select_related()` to reduce joins ✅ Used `prefetch_related()` for reverse relations ✅ Moved filtering logic into the database ✅ Avoided unnecessary loops Result? ⚡ Query time dropped from 12 sec → under 1 sec Big lesson: If your Django app feels slow, don’t blame Django… Check how you’re querying the database. Most of the time, the problem is not the framework — it’s the query. Have you ever faced slow queries in Django? What was your fix? #django #backend #python #query #developer

Day-117 📘 Python Full Stack Journey – Django Models to UI Rendering Today I worked on a complete flow in Django — from creating database models to displaying dynamic data on a webpage. This felt like a true full-stack experience! 🚀 🎯 What I learned today: 🗄️ Model Creation (Database Table) Defined a model in models.py: class Course(models.Model): course_name = models.CharField() course_description = models.TextField() Learned: CharField → for small text data TextField → for larger content Understood that inheriting from models.Model creates a database table 🔄 Migrations & Admin Integration Applied database changes using: py manage.py makemigrations py manage.py migrate Registered model in admin.py: admin.site.register(Course) Managed data through Django Admin (add, edit, delete) 💡 Also learned that missing migrations can cause errors like “no such table” 🌐 Fetching & Displaying Data Retrieved data in views.py: details = { 'data': Course.objects.all() } Passed data to template and displayed using loop: {% for i in data %} <h1>{{i.course_name}}</h1> <p>{{i.course_description}}</p> {% endfor %} 🎨 Styling & Layout Used Flexbox/Grid to design responsive course cards Created a clean UI layout for displaying multiple records dynamically This session helped me understand how Django connects database → backend → frontend, making applications truly dynamic and data-driven. Excited to build more real-world features using Django! 💻✨ #Django #Python #FullStackDevelopment #WebDevelopment #Backend #Frontend #Database #CodingJourney #LearningToCode #Upskilling #ContinuousLearning

Your queryset works. But your database is doing the heavy lifting. Most Django developers treat QuerySets like simple Python objects. Chain filters, loop over results, and ship it. But under the hood, every queryset translates into SQL executed by PostgreSQL (or your database). Inefficient queries, N+1 problems, and unnecessary evaluations don’t show up in code, they show up in performance, latency, and load. The real issue is not writing queries. It’s understanding when they execute, how many times they execute, and what SQL they generate. Methods like select_related, prefetch_related, and proper indexing are not optimizations—they are baseline requirements once your data grows. Ignoring them turns a working API into a slow system under real traffic. If you don’t know what SQL your queryset generates, are you really in control of your backend? #Django #QuerySet #BackendEngineering #Performance

Day 7 of My Full Stack Journey! 🚀 Today was all about Django Models & Databases — and it was a big day! Here's what I covered: 🔹 Created Django Models with fields like CharField, IntegerField, EmailField & BooleanField 🔹 Ran Migrations and explored the SQLite Database visually 🔹 Set up Django Admin Panel & created a Superuser 🔹 Registered Models in Admin and managed data through GUI 🔹 Used Django ORM — all(), filter(), get(), create(), update(), delete() 🔹 Built 2 complete models — Student & Book — independently! 🔹 Learned 3 ways to add data: Admin Panel (GUI) Django Shell (Python) DB Shell (SQL) The biggest insight today — ORM eliminates the need to write raw SQL. Python directly talks to the database! 🤯 Consistency > Motivation. Showing up every day is the real skill! 💪 Next up → HTML Forms in Django! 🎯 #Django #Python #FullStackDevelopment #100DaysOfCode #WebDevelopment #LearningInPublic #Day7

Day-120,121 📘 Python Full Stack Journey – Django Forms & User Input Handling Today I learned how to handle user input in Django using models and forms — an important step toward building interactive and data-driven applications. 🚀 🎯 What I learned today: 🗄️ Model Creation (Contact Form) Created a Contact model to store user data: Name Email Phone number Applied migrations and registered the model in Django Admin for easy data management 📝 Django ModelForm Created a form using Django’s built-in ModelForm: class BookingContact(forms.ModelForm): class Meta: model = Contact fields = '__all__' Learned how Django automatically generates form fields from models 🌐 Displaying Forms in Templates Rendered forms in HTML using: {{ form }} {{ form.as_p }} for structured layout 📩 Form Submission (POST Method) Used POST method for secure data submission Added {% csrf_token %} for protection Handled form submission in views.py: if request.method == 'POST': form = BookingContact(request.POST) if form.is_valid(): form.save() 🎨 Custom Form Styling Styled individual form fields manually using labels and inputs Learned how to design forms for better user experience This session helped me understand how Django manages forms, validation, and database storage seamlessly — a key step in building real-world web applications. Excited to keep building more interactive features! 💻✨ #Django #Python #FullStackDevelopment #WebDevelopment #Backend #Forms #Database #CodingJourney #LearningToCode #Upskilling #ContinuousLearning

From SQL Queries to Pythonic Code Django ORM has completely changed the way I interact with databases. Instead of writing long and complex SQL queries, I now use simple, readable, and powerful Python code to: ✔ Query data efficiently ✔ Manage relationships (ForeignKey, ManyToMany) ✔ Build scalable and maintainable backend systems ✔ Reduce development time and avoid common SQL errors Example: User.objects.filter(is_active=True) What really impressed me is how Django ORM allows chaining queries and performing advanced operations like aggregations, annotations, and joins — all without writing raw SQL. It not only improves productivity but also makes the codebase cleaner and easier to understand for teams. Currently exploring: • Query optimization techniques (select_related, prefetch_related) • Writing efficient database queries • Understanding how ORM translates into SQL under the hood Every day I’m realizing that mastering the basics deeply can unlock powerful capabilities. Excited to keep building, optimizing, and growing as a backend developer #python #django #SQL #webdevelopment #backend

As a Django developers don't stop at “it works.” Go further, make it fast, scalable, and production-ready 🚀 Here’s a simple example 👇 Basic query (works, but not optimal): orders = Order.objects.filter(items__product__user=user).distinct() It gets the correct data… But can trigger multiple database queries later (slow performance). Now the professional version 👇 orders = Order.objects.filter( items__product__user=user ).select_related('user').prefetch_related('items__product').distinct() Same result. But way more efficient. Why this matters: Without optimization → multiple database hits With optimization → data fetched once and reused Simple analogy: Without optimization = going to the market 10 times With optimization = buying everything in one trip Use this when you’re: • Looping through querysets • Accessing related data (user, items, products) • Building dashboards or real-world apps Quick tip: select_related → SQL JOIN (ForeignKey, OneToOne) prefetch_related → separate query + Python merge (ManyToMany, reverse FK) If you're learning Django, this is the difference between beginner and professional. Follow for more real-world dev tips 🚀 #Django #Python #WebDevelopment #Backend #Programming #SoftwareEngineering #LinkedIn

𝐖𝐡𝐚𝐭 𝐢𝐟 𝐲𝐨𝐮 𝐧𝐞𝐯𝐞𝐫 𝐡𝐚𝐝 𝐭𝐨 𝐰𝐫𝐢𝐭𝐞 𝐫𝐚𝐰 𝐒𝐐𝐋 𝐚𝐠𝐚𝐢𝐧? That's Django's ORM (Object-Relational Mapper) in a nutshell. An ORM lets you interact with your database using Python instead of SQL. You define your data as Python classes (called models), and Django handles the database queries behind the scenes. Here's a simple example: Instead of writing: SELECT * FROM blog_post WHERE author_id = 1; You write: Post.objects.filter(author_id=1) Same result. Pure Python. No SQL dialect to worry about. What makes the Django ORM powerful: → Works with PostgreSQL, MySQL, SQLite, Oracle. Same code, different DB → Migrations: Change your model, run a command, database updates automatically → Querysets that are chainable, lazy, and incredibly readable → Relationships like ForeignKey, ManyToMany, OneToOne, all handled elegantly I've worked with Oracle 19c and PostgreSQL in production. The ORM made switching between them painless which required just a config change. The caveat? For very complex queries, raw SQL is still available. The ORM doesn't replace SQL knowledge. It reduces how often you need it. If you're building data-heavy apps, learning the Django ORM deeply is one of the best investments you can make. Tomorrow: Django REST Framework, turning Django into an API powerhouse. #Django #ORM #Python #BackendDevelopment #Database

Django ORM is Powerful — But It Can Destroy Performance I’ve seen Django apps fail not because of bad logic… but bad queries. 🔴 Issue: ORM abstraction hiding inefficient queries (N+1, repeated joins) 🟢 Fix: - "select_related", "prefetch_related" - Query inspection with Django Debug Toolbar - Raw SQL where needed 💡 Lesson: Abstraction is helpful — until you stop understanding it. #Django #ORM #Performance #Backend

💡Django tip Fix Race Conditions in Django: #python #django #sql #api Every high-traffic store, ticketing platform, or booking system has this silent killer: two users hit "Buy" at the same millisecond, both see stock = 1, both complete — now you've sold something you don't have. select_for_update() locks the row at the database level so only one transaction wins. Important notes on the code 1 nowait=True — fails immediately under contention instead of silently queuing, giving the API a fast, explicit error response 2 save(update_fields=['stock']) — writes only the changed column, not the entire row 3 Custom exceptions (OutOfStockError, InsufficientQuantityError) — clean separation between "no stock at all" vs "not enough stock" 4 Logic extracted into a services.py layer — keeps views thin and the purchase logic fully testable in isolation OutOfStockError Triggered when stock == 0 — the product has absolutely nothing left. No amount of reducing quantity will help. InsufficientQuantityError Triggered when stock > 0 but less than what the user requested — there's some stock, just not enough for this order. #tip #tips #tipoftheday