Django REST Framework: Building Scalable CRUD APIs with ViewSets and Routers

I spent 6 years starting Python backend projects the same way: Create folder structure Wire up config management Write the Dockerfile Set up CI/CD Add test boilerplate Configure auth Write a README 45 minutes of muscle memory before writing a single line of actual business logic. JavaScript developers don't have this problem. They run npx create-next-app and start building. Python never had the same experience. So I built snapstack -- the create-next-app for Python. One command. Production-ready project. Zero manual edits needed. pip install snapstack && snapstack create my-api What you get: FastAPI, Django, or Flask -- your choice Working health check endpoint + passing test on first run Dockerfile + docker-compose with health checks GitHub Actions CI with lint + test pipeline JWT authentication (optional) SQLAlchemy 2 with async support pyproject.toml with typed config, dev extras, and ruff .pysnap.json manifest for future snapstack update upgrades Under the hood: 59 tests with full coverage Manifest-driven template engine (add a framework without touching core code) Plugin system via Python entry points Community template registry Everything is open source, MIT licensed, and available on PyPI today. If you've ever felt the friction of starting a new Python project, I'd love your feedback. What would you want snapstack to scaffold next? GitHub: https://lnkd.in/dk8268nb PyPI: https://lnkd.in/dndVAYeR #Python #OpenSource #DeveloperTools #FastAPI #Django #Flask #BackendDevelopment

Day 57 of #90DaysOfCode Today I built an interactive web application using Flask where users can guess a randomly generated number directly through the browser. The server generates a random number between 0 and 9 when it starts. Users attempt to guess the number by entering their guess in the URL, and the application responds with feedback indicating whether the guess is too high, too low, or correct. How the application works • Generates a random number using Python • Displays a prompt on the homepage asking the user to guess • Captures the user's guess using dynamic Flask routing • Compares the guess with the generated number • Returns visual feedback with different messages and images Key concepts explored • Building web applications using Flask • Dynamic routing using URL parameters • Handling user input through route variables • Returning HTML responses from Flask routes This project helped reinforce how backend frameworks process requests and return dynamic responses based on application logic. GitHub Repository https://lnkd.in/gUc57VJQ #Python #Flask #BackendDevelopment #WebDevelopment #SoftwareEngineering #90DaysOfCode

Most Python developers use Flask, FastAPI, or Django… But many still overlook one fundamental concept: HTTP methods. No matter which framework you choose, everything comes down to how your application handles these requests: • GET – Retrieve data • POST – Create a resource • PUT – Replace an entire resource • PATCH – Update specific fields • DELETE – Remove a resource Here’s where it gets interesting 👇 A lot of developers confuse PUT and PATCH. PUT → Replaces the entire resource PATCH → Updates only what’s necessary Why does this matter? Because choosing the right method leads to: ✔ Cleaner API design ✔ Better performance ✔ Easier maintainability Frameworks may differ in style and complexity, but the foundation remains the same: HTTP. Master these basics once, and switching between Flask, FastAPI, and Django becomes much easier. What’s one concept in backend development that took you time to fully understand? #Python #WebDevelopment #APIDesign #BackendDevelopment #Flask #FastAPI #Django #HTTPMethods

🚀 Optimizing Django Queries for Better Performance! While working on backend development, I explored how inefficient database queries can impact application performance. Here’s what I learnt while working with Django ORM: 🔹 Difference between select_related and prefetch_related 🔹 How to reduce multiple database hits by optimizing queries 🔹 Avoiding N+1 query problems in real-world scenarios 🔹 Using values() and values_list() for efficient data fetching 💡 One thing I found interesting: Even a simple API can become slow if queries are not handled properly. Small optimizations in ORM can significantly improve performance. This helped me understand how backend performance plays a key role in building scalable applications. Excited to apply these learnings in real-world projects 🚀 #Django #Python #BackendDevelopment #PerformanceOptimization #LearningInPublic

🚀 From Backend APIs to Smart Automation with Core Python A few days ago, I shared my Streamlit Password Generator project. Today, I’m excited to share another project I built using Core Python + Streamlit — a Smart File Organizer. As a backend engineer with 4+ years in PHP/Laravel and Django, I’ve spent most of my career building APIs, payment systems, and transaction-heavy platforms. But recently, I decided to go deeper into core Python fundamentals — not just frameworks. So I built something simple… but powerful. 🧠 The Problem: We all have messy folders filled with random files: Images (.png, .jpg, .jpeg) Documents (.pdf, .docx, .txt) Videos Audio files And “mystery files” 😅 🛠 The Solution: A Smart File Organizer that: • Accepts a folder path • Scans all files • Detects file extensions • Automatically groups them into folders like: Images Documents Videos Audio Others Built with: Core Python (os, shutil, file handling) Streamlit (for a clean interactive UI) 💡 What I Loved About This Project Seeing how powerful Python’s standard library is Writing logic without depending on heavy frameworks Turning backend logic into a usable interface with Streamlit Building something practical that solves a real everyday problem What’s interesting is this: As a backend developer used to Django and Laravel, this experience reminded me that strong fundamentals > frameworks. Frameworks are tools. Core language knowledge is power. I’m really enjoying this phase of building small but practical tools with Python. More projects coming soon 🚀 #Python #Streamlit #BackendDeveloper #SoftwareEngineering #BuildInPublic #LearningJourney #WomenInTech

🚀 Understanding the N+1 Query Problem in Django (From Real Experience) While working on a backend feature recently, I noticed performance issues when fetching related data in one of my APIs. After digging deeper, I realized it was due to the N+1 query problem. Here’s what I understood: 🔹 Django executes one query for the main data and additional queries for each related object 🔹 This leads to multiple database hits and slower API responses 🔹 It may not be noticeable with small data but becomes critical as data grows 💡 What helped me: By using "select_related" and "prefetch_related", I was able to reduce multiple queries into a minimal number of queries and improve response time. This made me realize how important query optimization is while building scalable backend systems. Have you faced similar performance issues in your projects? #Django #Python #BackendDevelopment #PerformanceOptimization #LearningInPublic

𝐁𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐖𝐞𝐛 𝐀𝐩𝐩𝐬 𝐢𝐧 𝐌𝐢𝐧𝐮𝐭𝐞𝐬: 𝐀𝐧 𝐈𝐧𝐭𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧 𝐭𝐨 𝐒𝐭𝐫𝐞𝐚𝐦𝐥𝐢𝐭. 𝐀𝐬 Python developers, we often build powerful data models and scripts, but sharing them with non-technical users can be a headache. Building a full web application using Django or Flask just to showcase a simple dashboard often feels like overkill. This is exactly where 𝐒𝐭𝐫𝐞𝐚𝐦𝐥𝐢𝐭 changes the game. 𝐒𝐭𝐫𝐞𝐚𝐦𝐥𝐢𝐭 is an open-source Python library that turns data scripts into shareable web apps in minutes. It requires absolutely zero front-end experience. No HTML, CSS, or JavaScript is needed—just pure Python. It automatically handles the UI updates as users interact with your widgets. 𝐇𝐨𝐰 𝐭𝐨 𝐆𝐞𝐭 𝐒𝐭𝐚𝐫𝐭𝐞𝐝 (𝐈𝐧𝐬𝐭𝐚𝐥𝐥𝐚𝐭𝐢𝐨𝐧):- • Open your Command Prompt or Terminal. • Run this simple command: pip install streamlit • To verify the installation and see a built-in demo, run: streamlit hello 𝐀 𝐐𝐮𝐢𝐜𝐤 𝐄𝐱𝐚𝐦𝐩𝐥𝐞:- Create a new Python file named app.py and add this code: import streamlit as st st.title("User Greeting Dashboard") user_name = st.text_input("Enter your name:") if user_name: st.success(f"Hello, {user_name}! Welcome to the platform.") else: st.write("Please enter a name, like 'Hamza' or 'Fatima'.") To launch your new web app, go to your terminal and type: streamlit run app.py Conclusion:- Streamlit drastically reduces the time to market for data applications. It allows us to focus entirely on the backend logic and data processing rather than getting bogged down by UI components. It is a must-have tool in any modern Python stack. Special thanks to my mentor Mian Ahmad Basit Ahmad Basit for the continued guidance. #MuhammadAbdullahWaseem #Nexskill #Streamlit #PythonProgramming #Pakistan

I just released v0.3.1 of an open-source developer tool I built: **DRF to Django Ninja Compiler**. It's a CLI that auto-converts Django REST Framework code into modern Django Ninja — using Python's AST module to reverse-engineer your serializers, views, URLs, permissions, and settings. 🔧 What it does: • Converts DRF Serializers → Pydantic Schemas (including nested serializers and `Meta.depth`) • Converts DRF ViewSets/APIViews → Ninja `@router` or `@api` endpoints • Detects `@action` decorators and generates dedicated routes • Supports all GenericAPIView variants (ListCreateAPIView, RetrieveUpdateDestroyAPIView, etc.) • Parses urls.py → generates NinjaAPI wiring • Parses REST_FRAMEWORK settings → generates a migration report • Maps permission_classes and authentication_classes to Ninja equivalents • Flags anything it can't auto-translate with inline TODO comments • `--project` flag scans an entire Django app directory in one command 📦 Install: `pip install drf-to-ninja` 🔗 GitHub: https://lnkd.in/dwZxszc7 🔗 PyPI: https://lnkd.in/dHPNhTtK 47 automated tests, security scanning with Bandit, and full CI/CD via GitHub Actions. Now officially in Beta! If you're migrating a Django project or know someone who is — give it a ⭐ and share it. #Python #Django #DjangoNinja #OpenSource #DeveloperTools #BackendDevelopment #Migration

Day 56 of #90DaysOfCode Today I started exploring backend web development with Flask by building a minimal web application in Python. The application initializes a Flask server and defines a route that returns a simple response when accessed through the browser. Although small, this project introduces the core concepts behind how web frameworks handle routing and HTTP requests. Key concepts explored • Creating a Flask application instance • Defining routes using decorators • Handling HTTP requests in a backend framework • Running a local development server This marks the beginning of building web applications and APIs using Python and Flask. GitHub Repository https://lnkd.in/gEBzxXhF #Python #Flask #BackendDevelopment #WebDevelopment #SoftwareEngineering #90DaysOfCode

WSGI vs ASGI. If you've used Django, Flask, or FastAPI, you've probably seen these terms — but do you really know what they mean? I recently explored how Python web servers actually communicate with applications and why modern frameworks are moving from WSGI to ASGI. I wrote a short article explaining: • Difference between WSGI and ASGI • Django's hybrid architecture • FastAPI's async-first design • How request handling actually works under the hood #Python #Backend #FastAPI #Django