Anvil Alternatives: Python-first, Low/No-code, and Full-stack Options

🎯 𝐃𝐚𝐲 𝟒 𝐨𝐟 𝟓𝟎: 𝐃𝐣𝐚𝐧𝐠𝐨'𝐬 "𝐁𝐚𝐭𝐭𝐞𝐫𝐢𝐞𝐬 𝐈𝐧𝐜𝐥𝐮𝐝𝐞𝐝" 𝐏𝐡𝐢𝐥𝐨𝐬𝐨𝐩𝐡𝐲 𝐢𝐧 𝐀𝐜𝐭𝐢𝐨𝐧⁣⁣ ⁣ I finally understand why experienced developers swear by Django. Today it clicked — this isn't just a framework. It's a fully loaded toolkit that lets you build instead of configure.⁣⁣ Zero custom authentication. Zero manual database queries. Zero boilerplate infrastructure. Just results.⁣⁣ ⁣ 𝐖𝐡𝐚𝐭 𝐈 𝐁𝐮𝐢𝐥𝐭: 🛠️⁣⁣ ⁣ A fully functional blog system — admin panel, public-facing website, and styled templates. All in one day. That's Django's superpower.⁣ ⁣⁣ 𝐓𝐡𝐞 "𝐁𝐚𝐭𝐭𝐞𝐫𝐢𝐞𝐬 𝐈𝐧𝐜𝐥𝐮𝐝𝐞𝐝" 𝐌𝐨𝐦𝐞𝐧𝐭: 🔋⁣⁣ Most frameworks hand you parts and say "good luck." Django hands you a fully assembled vehicle.⁣⁣ ⁣ I registered three models — Author, Category, Post — with filtering, searching, and bulk operations in 𝒖𝒏𝒅𝒆𝒓 𝟓𝟎 𝒍𝒊𝒏𝒆𝒔 𝒐𝒇 𝒄𝒐𝒅𝒆. No custom dashboard. No UI library. No authentication system to wire up.⁣  ⁣ Django's built-in admin is production-grade straight out of the box.⁣⁣ ⁣ 𝐃𝐣𝐚𝐧𝐠𝐨 𝐓𝐞𝐦𝐩𝐥𝐚𝐭𝐞 𝐋𝐚𝐧𝐠𝐮𝐚𝐠𝐞 (𝐃𝐓𝐋): 📝⁣⁣ Clean. Simple. Powerful.⁣⁣ ⁣ {% 𝘧𝘰𝘳 𝘱𝘰𝘴𝘵 𝘪𝘯 𝘱𝘰𝘴𝘵𝘴 %}    → 𝘕𝘰 𝘑𝘢𝘷𝘢𝘚𝘤𝘳𝘪𝘱𝘵 𝘭𝘰𝘰𝘱𝘴⁣⁣ {{ 𝘱𝘰𝘴𝘵.𝘢𝘶𝘵𝘩𝘰𝘳.𝘯𝘢𝘮𝘦 }}     → 𝘕𝘰 𝘈𝘗𝘐 𝘤𝘢𝘭𝘭𝘴⁣⁣ {% 𝘶𝘳𝘭 '𝘣𝘭𝘰𝘨:𝘱𝘰𝘴𝘵_𝘥𝘦𝘵𝘢𝘪𝘭' %}  → 𝘕𝘰 𝘩𝘢𝘳𝘥𝘤𝘰𝘥𝘦𝘥 𝘜𝘙𝘓𝘴⁣⁣ {{ 𝘥𝘢𝘵𝘦|𝘥𝘢𝘵𝘦:"𝘔 𝘥, 𝘠" }}    → 𝘕𝘰 𝘥𝘢𝘵𝘦 𝘭𝘪𝘣𝘳𝘢𝘳𝘪𝘦𝘴⁣⁣ ⁣ One base template with {% block %} tags and every page inherits consistent structure 𝒂𝒖𝒕𝒐𝒎𝒂𝒕𝒊𝒄𝒂𝒍𝒍𝒚.⁣⁣ 𝐖𝐡𝐚𝐭'𝐬 𝐀𝐜𝐭𝐮𝐚𝐥𝐥𝐲 𝐈𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐯𝐞: 💡⁣⁣ Static files? 𝑩𝒖𝒊𝒍𝒕-𝒊𝒏.⁣⁣ Templates? 𝑩𝒖𝒊𝒍𝒕-𝒊𝒏.⁣⁣ Admin panel? 𝑩𝒖𝒊𝒍𝒕-𝒊𝒏.⁣⁣ Authentication? 𝑩𝒖𝒊𝒍𝒕-𝒊𝒏.⁣⁣ ORM? 𝑩𝒖𝒊𝒍𝒕-𝒊𝒏.⁣⁣ ⁣ By Day 3 I had models and a CLI. By Day 4 I have a publishable web application.⁣⁣ ⁣ 𝑻𝒉𝒂𝒕'𝒔 𝒕𝒉𝒆 𝒎𝒂𝒈𝒊𝒄 𝒐𝒇 𝒐𝒑𝒊𝒏𝒊𝒐𝒏𝒂𝒕𝒆𝒅 𝒇𝒓𝒂𝒎𝒆𝒘𝒐𝒓𝒌𝒔.⁣⁣ 𝐓𝐡𝐞 𝐑𝐞𝐚𝐥 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲: 🚀⁣⁣ ⁣ Django's philosophy is quietly powerful — move fast because the fundamentals are already solved. You're not reinventing wheels. You're shipping products.⁣⁣ Day 5 incoming. More depth, more complexity. 💪⁣⁣ #Django #WebDevelopment #Python #BatteriesIncluded #50DayChallenge #LearningInPublic #Backend #FullStack #DeveloperJourney #PythonDeveloper

Five things I learned building a Claude Code plugin. Each one is a decision file the plugin captured while I was building it. Link in comments. (When I say "I wrote" below, I mean Claude wrote most of it while I supervised and said "no, not like that." Claude Code builds Claude Code plugins now - fun times.) 1. Markdown files are the truth. Everything else is a cache. Decisions are .md files in .claude/decisions/, plus a auto-generated list at claude/rules/decisions.md that loads at session start. A SQLite search index sits alongside and rebuilds from markdown on demand. Humans and agents both read markdown natively. No parsing layer in between. Karpathy's LLM knowledge bases post took this mainstream. The decision file here predates it, and Claude Code's memory uses the same principle. Not a trend - just what works. 2. No external libraries - just Python's standard library Just what comes with Python. No pip install anything. Took more work - custom YAML parser, FTS5 queries by hand. (Python stdlib got TOML but still no YAML!) - but the plugin can never break someone's Python environment. 3. A tiny bash layer so hooks stay fast Claude Code runs your plugin on every tool use. Python takes ~100ms to start up, so 50 tool calls adds 5 seconds of lag per session. A bash script catches events that don't need Python. Latency stays under 10ms. The first version ran Python on everything - my own plugin annoyed me. 4. A strict order for when policies fire The plugin runs a handful of policies on every hook - detecting decisions, injecting context, nudging. They fire independently but their outputs merge. Without a firing order, weird bugs emerge. A nudge fires before its context. A validation runs after the file is already written. Now there's a fixed order: block, lifecycle, context, nudges. Even if a policy says "reject", the result gets forced to "allow" - nudge-don't-block locked in at the architecture level. A policy can misfire, but none can stop Claude. 5. Skill, hooks, CLI - each does one job Claude Code plugins have three places for logic: a skill (markdown that tells Claude how to behave), hooks (code that runs on events), and a CLI. My first version stuffed everything into the skill. 200 lines of templates, validation, search logic - trying to be an entire program written in English. Now each layer has one job. The skill says what to do - about 60 lines, nothing more. Hooks enforce correctness. The CLI does the computation. The real reason this matters: LLM work costs tokens and is probabilistic. Local code is free and deterministic. Move what you can down to the CLI. --- Would love to hear from others building Claude Code plugins - or thinking about it. What's working, what's stuck. #ClaudeCode #PluginDevelopment #Python #OpenSource #DevTools

🛠️ Building Custom Apps in Frappe Framework v16 — Here's what actually matters. (Full breakdown in the slides attached 👇) Most developers approach Frappe like it's just another Python framework. It isn't. And the ones who figure that out early move significantly faster. Here's the real picture from building production-grade custom apps on v16: ⚡ One command. Zero boilerplate. bench new-app library_management In under 60 seconds — scaffolded, pip-installed, assets compiled. That's the promise. And it delivers. 📁 The scaffold isn't a template. It's architecture. Every directory has intent: → hooks.py — The nervous system of your app. This is where you register DocType event listeners, scheduled jobs, permission overrides, and custom JS/CSS injections. If you're overriding core files instead of using hooks, you're doing it wrong. → modules.txt — Declares what your app exposes. Every DocType, Report, Page lives inside a module. Missing or malformed? Your app won't appear in Desk. → patches.txt — Your migration history. Sequential. Permanent. Treat it like a database migration log — because it is one. → public/ — Static assets, now built via esbuild in v16. Know the difference between app-level JS and DocType-specific JS. → www/ — File-based routing. Drop a .html + .py pair, get an instant portal page. Zero config. → pyproject.toml — Replaces setup.py. Your Python dependencies, auto-installed with the app. ⚠️ V16 gotchas that will catch you off guard: • esbuild replaced Rollup — older JS patterns fail silently • Cache is aggressive — always bench clear-cache after hook changes • Hook functions must be fully importable strings — one bad import = silent failure • Patches that fail mid-run leave your site in an inconsistent state → write them idempotent • ignore_permissions=True in multi-tenant benches = subtle security debt 🏗️ The principle that separates scalable Frappe apps from legacy nightmares: Your app should be a guest in the framework's house. Use override_doctype_class — not core edits. Use Custom Fields — not schema hacks. Always call super() — missing it breaks GL entries and stock ledgers silently, months later. The developers who struggle with Frappe fight the framework. The ones who thrive treat hooks as the integration surface and DocTypes as the source of truth. #FrappeFramework #ERPNext #PythonDevelopment #CustomAppDevelopment #WebDevelopment #OpenSource #SoftwareArchitecture #ERPDevelopment #BackendDevelopment #TechCommunity #Automation #Industry #Manufacturing

I used Django REST Framework for 5 years. Then I discovered these hidden features. I felt like I had been using a Ferrari in first gear the whole time. 😅 Here are 5 DRF secrets most developers never find 👇 --- 🔐 Secret 1 — SerializerMethodField Most developers hardcode data in serializers. But SerializerMethodField lets you add ANY custom computed field dynamically. Example: Instead of storing full_name in the database — compute it on the fly from first_name + last_name. class UserSerializer(serializers.ModelSerializer):   full_name = serializers.SerializerMethodField()   def get_full_name(self, obj):     return f"{obj.first_name} {obj.last_name}" No extra DB column. No migration. Just clean data. ✅ --- 🚦 Secret 2 — Built-in API Throttling Most developers build custom rate limiting from scratch. DRF already has it built in — and almost nobody uses it. 3 types: → AnonRateThrottle — for unauthenticated users → UserRateThrottle — for authenticated users → ScopedRateThrottle — per specific endpoint REST_FRAMEWORK = {   'DEFAULT_THROTTLE_RATES': {     'anon': '100/day',     'user': '1000/day'   } } One setting. Full rate limiting. No extra code. 🔥 --- 📄 Secret 3 — 3 Types of Pagination (Nobody Uses Them All) Most developers only know PageNumberPagination. But DRF has 3: → PageNumberPagination — classic page=1, page=2 → LimitOffsetPagination — ?limit=10&offset=20 — perfect for infinite scroll → CursorPagination — most secure, uses encrypted cursor — perfect for real-time feeds I switched one client's API from PageNumber to Cursor — and their feed felt 10x smoother instantly. 🚀 --- 🎯 Secret 4 — @action Decorator on ViewSets Most developers create separate APIView for every custom endpoint. Messy. Repetitive. Unnecessary. @action lets you add custom endpoints directly inside your ViewSet. class UserViewSet(viewsets.ModelViewSet):   @action(detail=True, methods=['post'])   def send_welcome_email(self, request, pk=None):     user = self.get_object()     # send email logic     return Response({'status': 'email sent'}) URL: /users/{id}/send_welcome_email/ Clean. Organized. Professional. ✅ --- ⚡ Secret 5 — select_related inside get_queryset Most developers write their queries in the serializer. The result? N+1 queries destroying your API performance. The fix? Override get_queryset in your ViewSet: def get_queryset(self):   return Order.objects.select_related(     'user', 'product'   ).prefetch_related('items') One change. Query count drops from 47 to 2. ⚡ This is exactly how I reduced a client's API response time from 8 seconds to 800ms. --- These 5 features exist in every DRF project. Most developers never find them. The ones who do — write cleaner code, build faster APIs, and deliver better products. --- Which one did you already know? #Django #DjangoRestFramework #Python #BackendDevelopment #WebDevelopment #FullStackDeveloper #API #SoftwareEngineering #OpenToWork #RemoteWork #ProgrammingTips

🔥 My client was losing customers every single day. The reason? Their Django API took 8–10 seconds to respond. I fixed it in under 800ms. Here's exactly how 👇 --- First, let me paint the picture. Imagine you open an app. You wait... 3 seconds. You wait... 6 seconds. You wait... 9 seconds. You close it and never come back. That's what was happening to my client's users — every single day. They came to me desperate. I got to work. --- Here's the exact 5-step process I used: ⚡ Step 1 — Stop guessing, find the real problem I see many developers randomly "optimizing" without knowing what's actually slow. I used Django Debug Toolbar first. The result shocked even me. 👉 1 single API call was firing 47 separate database queries. 47. For ONE request. Classic N+1 problem — and it was silently killing performance. --- ⚡ Step 2 — Kill the N+1 with 2 lines of code select_related() and prefetch_related() — two of the most underused tools in Django. Before: 47 database hits per request After: 2 database hits per request Response time: 8 seconds → 2 seconds Just from 2 lines of code. 🤯 --- ⚡ Step 3 — Database indexes (the most ignored optimization) The queries were doing full table scans. On a table with 2,000,000+ records. Every. Single. Request. Added composite indexes on the right columns. Query execution time dropped by 60% overnight. --- ⚡ Step 4 — Redis caching for the win Some data never changed — but the app was fetching it from the database on every request. That's like googling your own phone number every time you need to call yourself. Cached it in Redis with a 15-minute TTL. Result → endpoints now respond in under 50ms. ⚡ --- ⚡ Step 5 — DRF Serializer was the hidden villain The serializer was fetching 40+ fields. The API only needed 8. Used only() and defer() to fetch exactly what was needed. Nothing more. Nothing less. --- Final result? ❌ Before: 8–10 seconds ✅ After: under 800ms A client who was losing users every day — now has a fast, reliable product. --- The real lesson here? Most Django performance problems are NOT about Django. They are about developers who never question their own code. Debug first. Optimize second. Never guess. --- Are you dealing with slow APIs right now? Drop your biggest Django performance challenge in the comments — I read every single one. 👇 #Python #Django #WebDevelopment #BackendDevelopment #FullStackDeveloper #PerformanceOptimization #OpenToWork #RemoteWork #SoftwareEngineering #AWS

Latest Update to the PyRepl.dev Web App — Version 2.3.0! Hey all — we just bumped up a new Update to the Python REPL IDE Web App — we're now up to version 2.3.0! To remind you, this is a full-stack web-based IDE for executing Python code with an integrated REPL (Read-Eval-Print Loop). Built on Astro 6 with server-side rendering, React 19 interactive islands, Clerk authentication, and a Turso (libSQL) cloud database. The app provides a modern development environment with a file explorer, Monaco code editor, console panel, live web preview, project management, and package installation. For this version, and perhaps for the next couple of Updates, there are not many new User & UI Features added, more like a lot of internal updates and fixes to make the App far more robust & bullet-proof. Such as — • IDE.tsx (the main Astro App file) broken-out into modules • Big test-coverage push, using both Vitest for Unit Testrs and Playwright for Integration end-to-end Test Suite • A much faster, more reliable CI / CD pipeline, mirroring the local test suits, in GitHub Actions for every push. • The user-facing app behaves the same as 2.2.1 in most places, but the internals are dramatically more modular, the test suite is substantially larger, and the GitHub Actions pipeline now runs the full tes suites • Better loading experience — added a dedicated <LoadingScreen> component that shows a "Taking too long? Reload" button after a timeout. • "Complete Your Profile" modal now properly closes when you click Cancel or finish the form, instead of stubbornly re-appearing. Accessibility fix in the Command palette for screen readers announce the palette correctly • Better mobile layout — Explorer header is now hidden on small (mobile-sized) viewports • Long filenames are truncated cleanly in the Explorer — they no longer break the sidebar layout • Dependency updates — Astro v6.1.7 (was v6.1.5), @astrojs/node v10.0.5, @clerk/astro v3.0.15, @clerk/react v6.4.1, @clerk/testing v2.0.15, @tanstack/react-query v5.99.0, react-resizable-panels v4.10.0, React + react-dom v19.2.5, lucide-react v1.8.0, aws-cdk v2.1118.0, Vitest + @vitest/coverage-v8 v4.1.4, jsdom v29.0.2, TypeScript v6.0.2, @playwright/test v1.59.1, react-hook-form v7.72.1, eslint v10.2.0 autoprefixer v10.5.0 • Added: concurrently v9.2.1 (devDep), cross-fetch v4.1.0 • Removed: local-ssl-proxy (replaced by e2e/https-proxy.mjs) For the Next versions, there probably won't be much in New User Features — it'll mostly be stuff like adding Aria for Accessibility and putting all the UI components into Storybook.js. After that, back on track for new features! Enjoy a far more Robust, Quickly Loading Python REPL IDE Web App v2.3.0! https://pyrepl.dev GitHub Repository — https://lnkd.in/gXdMe2qu Changelog — https://lnkd.in/gpZjmwsc

I have recently been reading Swizec Teller's new book Scaling Fast and in it he mentions architectural complexity, which reminded me of my desire for a tool that combines database dependencies between Django apps and import dependencies between Django apps. To date, I have used other tools such as graph models from Django extensions, import-linter is the most recent one, and pyreverse from Pylint. They all do bits of the job, but require manual stitching together to get a cohesive graph of everything overlaid in the right way. So I remembered about this, and so over the last couple of days, I've built a new package which combines all of this into a live view which updates as you build your app, a management command and a panel for Debug Toolbar. Why the Django app level, you ask? Primarily, I do find models good, but they can get a little too complicated and a little you get a few too many lines and doing imports at the module level within an app or like separating it all out, again, you lose it becomes there becomes too much noise to signal to really understand the logical relationship between different components in the system. I like to think that Django apps naturally represent logical representations of different parts of a project or a system. A project obviously is too large unless you're dealing with multiple projects, but within a single Django project, it's a good representation to have an app deal with one thing. You can I know you can structure Django projects & apps in many ways. So it'd be interesting to see this tool used on other's project structures that aren't one app for a single logical component. So without further ado, here is Django Dependency Map , which combines output from Django extensions graph_models and grimp, which is used by import-linter to dynamically map the dependencies between your different apps and third-party apps. Initially, it was a management command, which then outputs a HTML file, which exists. I then added that into a live view, and there's an integration into Django debug toolbar. The live map page has the following features: you can hide nodes and kind of see how the dependencies change. force graph & hierarchical graph representation, Detailed information on a single app and its relationships import cycle detection import violations from import-linter Debug toolbar panel Export of the graph to mermaid & dot formats My hope is twofold. One, it might reveal things about your projects that you didn't know about in terms of how fit how interlinked things are. And secondly, I hope it may change the way you build your Django apps. I'm hoping to have it open as another tab and just to watch as I'm building things to make sure out as I'm and maybe as an agent's building things see use it as a sense check of if it's doing things right or as I expect it to in terms of overall architecture rather than at the code level. The pypi package is coming very soon, but you can visit the repo here: https:/

**No template boilerplate. No context switching. Just Python UI.** Introducing **Probo UI 1.4**, built with a 1200+ test suite for deterministic rendering. Probo UI (Python Rendered Objects for Backend Oriented User Interface) is a minimalist Python-first template framework that allows developers to construct and manipulate HTML component trees directly in Python. ➡️ **Build web applications that are almost 100% Python-driven.** The goal is simple. Instead of fragmenting your logic between Python, JavaScript, and complex template files, Probo UI enables backend engineers to build full, reactive interfaces using Python as the primary language. ⚡ **Why Probo UI?** • **Almost 100% Python web apps** – UI structures are built directly in Python. • **Framework agnostic** – works with **Django**, **FastAPI**, and **Flask**. • **Native HTMX support** – build dynamic interfaces without heavy frontend frameworks. • **Server-driven UI architecture** – great for dashboards, internal tools, and admin systems. • **Structured component tree** – query, traverse, and modify UI elements programmatically. • **Efficient styling system & Bootstrap integration** – inline styles, head styles, animations, and media queries. Bootstrap integration for rapid responsive layout building. • **Minimal JavaScript overhead** – focus on backend logic rather than frontend complexity. • **Real SSDOM Architecture** – Query, traverse, and modify UI elements as live Python objects. • **Enhanced CLI scaffolding** – All new projects or Django apps created with the Probo CLI now come with a stock SSDOM index document and a sample greeting component out of the box. 🌐 **Live Demo & Ecosystem** Key highlights: * Dynamic UI rendering via **HTMX-powered interactions** * **Component-driven architecture** using reusable domain-level UI modules * **Context-aware rendering**, where UI fragments are injected and updated based on backend state * Clean separation of concerns while maintaining a **Python-first development model** 🔗 **Live Demo** https://lnkd.in/e5UafrFt 🧱 **Tech Stack** * Django * Probo UI * HTMX 📂 Source Code & Docs: * Demo Application: https://lnkd.in/dGNgB9Fp * 📂 Docs: https://lnkd.in/d3sjzXMG This demo reflects how Probo UI can be used to build production-style backend-driven interfaces, reducing frontend complexity while maintaining interactivity and scalability. 📦 What’s Next? I’m currently building a `probo-components` package for community-driven extensions and innovations plus SSDOM events and a series of tutorials for production-style Python web applications integrated with: • **Django** • **FastAPI** • **Flask** Each demo will be published on GitHub. 💬 I’d love to connect with anyone interested in: • Server-driven UI architectures • Python-based frontend systems • The future of HTMX in the Python ecosystem • or having a chat #python #webdevelopment #django #htmx #opensource

The Most Efficient Duel Combination for Prototyping Based on current industry data and developer experience reports. Here is the definitive ranking for:  FASTEST + EASIEST full-stack combinations When all can be Dockerised. 🏆 The Winner: MERN Stack (MongoDB + Express.js + React + Node.js) Why it wins: One language (JavaScript/TypeScript) from database to UI. Zero context switching. Docker setup time: ~10 minutes with pre-built templates 🥈 Runner-Up: FastAPI + React + MongoDB (The FARM Stack) Best for: Python teams who want near-MERN speed Why this is almost as fast: FastAPI auto-generates API docs and validation MongoDB's schema-less design removes database migration delays Pre-built Docker templates available (docker compose up ready) Docker setup time: ~15 minutes 🥉 Honorable Mention: Laravel + Vue.js  Best for: PHP shops that can't leave their comfort zone Docker setup time: ~20 minutes Insight "The need to define database schema slows down prototyping... MongoDB lets you write code quickly and sort out later exactly what you want to do with the data." This is why MERN and FARM (both with MongoDB) beat Ruby + React and Laravel + Vue (typically PostgreSQL/MySQL): With SQL (Ruby/Laravel) With MongoDB (MERN/FARM) php artisan make:migrationJust insert datarake db:create db:migrateNo migration filesDefine schema firstSchema-on-readALTER TABLE for changesJust add new fields 🎯 Verdict If you want FASTEST prototyping: MERN Stack + Docker + MongoDB + Claude 3.5 Sonnet (AI assistance) Developers report 50% faster feature development with this approach. Setup is literally docker compose up. If you MUST use Python: FARM Stack (FastAPI + React + MongoDB) Andrew Ng (DeepLearning.AI) uses this personally for rapid prototyping. Your original Ruby + React or Vue + PHP combos?  They work fine for production. But for speed of spinning up and ease of configuration, the one-language, schema-less stacks win every time. N.B. Andrew Ng (https://deeplearning.ai/) uses this personally for rapid prototyping. #MERN #FARM #LARAVEL #WebDevelopment #RapidPrototyping #FullStack #TechLeadership #DeveloperProductivity #JavaScript #DeepLearningAI #SoftwareEngineering #WebDevelopment #MongoDB #ReactJS #NodeJS

📘 Day 85: Django – Loops, Multiple Pages & Template Inheritance 🔹 For Loop in Django Templates • Django allows looping inside HTML using template tags • Used to display multiple values dynamically 🔸 Key Points: • Written using {% for %} and {% endfor %} • Works with lists passed from views • Iterator prints each value using {{ }} 💡 Concept: • Backend sends list → Template loops → Displays each item 👉 Example covered: passing names list and displaying each name 🔸 Multiple Data with Loops • You can pass multiple lists (like name, place) • Each loop must have its own {% endfor %} 🔹 Key Idea: • One loop = one dataset 🔸 Multiple HTML Pages • Each HTML page needs its own function in views.py • Each function is mapped in urls.py 🔹 Key Points: • One view = one page • URL path decides which page loads 💡 Example: • Home → / • About → /ab • Contact → /co 🔸 Template Inheritance • Used to avoid repeating code (like navbar, footer) • One main file (parent) → other pages (child) extend it 🔹 Base Template (base.html) • Contains common structure (navbar, layout) • Uses blocks like: • {% block title %} • {% block content %} 🔹 Child Templates • Use {% extends "base.html" %} • Fill content inside blocks 💡 Concept: • Parent → structure • Child → content 🔸 Navbar Creation • Navbar is created inside base.html • Appears automatically in all pages 🔹 Key Points: • No need to repeat navbar in every file • Improves code reusability 🔸 URL Naming (Important) • Each URL is given a name in urls.py • Used for linking pages dynamically 🔹 Why use it? • Avoid hardcoding links • Easier to manage routes 🔸 Navigation using Django URL Tag • Instead of writing direct paths, use: 👉 {% url 'name' %} 🔹 Key Points: • Links pages using URL names • Makes navigation dynamic and clean 🔸 Complete Flow User clicks navbar link URL name is matched View function is called Template is rendered Data is displayed ✨ Today you learned: • How to use loops in Django templates • How to handle multiple HTML pages • Template inheritance (base + child structure) • How to build reusable layouts (navbar) • Dynamic navigation using URL names This is a major step toward building structured and professional Django applications 🚀 #Django #Python #WebDevelopment #FullStack #Day85 #Templates #Frontend #BackendDevelopment #CodingJourney