<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Rushal Barkhade on Medium]]></title>
        <description><![CDATA[Stories by Rushal Barkhade on Medium]]></description>
        <link>https://medium.com/@rushalbarkhade11795?source=rss-619cf1fad823------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*hEzauNcgopW6MqeY.jpg</url>
            <title>Stories by Rushal Barkhade on Medium</title>
            <link>https://medium.com/@rushalbarkhade11795?source=rss-619cf1fad823------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 15:08:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rushalbarkhade11795/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[RAG vs Fine-Tuning: Which One Should You Use?]]></title>
            <link>https://medium.com/django-unleashed/rag-vs-fine-tuning-which-one-should-you-use-8661bb43cd2c?source=rss-619cf1fad823------2</link>
            <guid isPermaLink="false">https://medium.com/p/8661bb43cd2c</guid>
            <category><![CDATA[fine-tuning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[reg]]></category>
            <dc:creator><![CDATA[Rushal Barkhade]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 03:23:35 GMT</pubDate>
            <atom:updated>2026-11-10T03:23:35.799Z</atom:updated>
            <content:encoded><![CDATA[<p>When people start building with LLMs, one question shows up very quickly:</p><p><strong>Should I use RAG or fine-tuning?</strong></p><p>I asked myself the same thing when I started thinking seriously about production AI features.</p><p>At first, fine-tuning sounded powerful. It felt like the “advanced” option. RAG sounded practical, but maybe less impressive.</p><p>The truth is much simpler.</p><p>In most real products, the right choice is not about what sounds more advanced.</p><p>It is about what actually solves the problem.</p><p>After working through different AI use cases, I started seeing a pattern:</p><ul><li>some problems need fresh knowledge,</li><li>some need style or behavior consistency,</li><li>some need better retrieval,</li><li>some need both,</li><li>and some do not need either.</li></ul><p>That is why this decision matters.</p><p>If you choose the wrong approach early, you can build something that is expensive, hard to maintain, or simply not useful enough.</p><p>Here is the way I think about it now.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HlQpLHpcPj3W_UglYZFYGw.png" /></figure><h3>My simple definition</h3><p>Before comparing them, I like to reduce both ideas to plain language.</p><p><strong>RAG</strong> means the model gets relevant external information at query time.</p><p><strong>Fine-tuning</strong> means the model itself is adjusted so it behaves differently or performs better on a specific task.</p><p>That is the simplest version.</p><p>RAG helps the model know more at the moment of answering.</p><p>Fine-tuning helps the model behave differently over time.</p><p>Both are useful.</p><p>They solve different problems.</p><h3>Why I usually think of RAG first</h3><p>If the problem is knowledge, I usually start with RAG.</p><p>That is because most business applications are not asking the model to “learn everything forever.”</p><p>They are asking it to answer based on current, changing, or private information.</p><p>For example:</p><ul><li>internal company docs</li><li>product manuals</li><li>support articles</li><li>policies</li><li>user-specific records</li><li>dynamic knowledge bases</li></ul><p>In those cases, RAG is usually a strong fit.</p><p>Why?</p><p>Because the information can be updated without retraining the model.</p><p>That matters a lot in real systems.</p><p>If your content changes often, fine-tuning can become a maintenance burden. You do not want to retrain every time a document changes or a policy gets updated.</p><p>RAG lets you keep the model flexible while still grounding responses in your own data.</p><p>That is one of the main reasons I lean toward it first.</p><h3>What RAG is good at</h3><p>RAG is a good choice when you want the model to answer using specific, current, or private information.</p><p>It works well when you need:</p><ul><li>up-to-date answers</li><li>document search</li><li>knowledge base queries</li><li>product support</li><li>internal search over company data</li><li>context-aware responses</li></ul><p>It is especially useful when your data already exists somewhere and the problem is retrieval, not training.</p><p>That is a big distinction.</p><p>Sometimes the issue is not that the model does not know enough.</p><p>Sometimes the issue is that the right information is not being passed in at the right time.</p><p>RAG fixes that.</p><h3>What fine-tuning is actually good at</h3><p>Fine-tuning is better when you want the model to behave in a more specific way.</p><p>For example:</p><ul><li>follow a very particular style</li><li>produce more consistent outputs</li><li>classify text in a custom format</li><li>learn task-specific behavior</li><li>match a domain-specific response pattern</li></ul><p>Fine-tuning is not mainly about giving the model fresh knowledge.</p><p>It is about shaping behavior.</p><p>That is why it can be powerful, but also why it is easy to misuse.</p><p>If your real problem is “the model needs the latest docs,” fine-tuning is probably not the answer.</p><p>If your real problem is “the model needs to write or respond in a very specific way every time,” fine-tuning may help.</p><h3>The biggest difference: changing knowledge vs changing behavior</h3><p>This is the way I think about it now:</p><ul><li><strong>RAG changes what the model sees</strong></li><li><strong>Fine-tuning changes how the model behaves</strong></li></ul><p>That one sentence explains a lot.</p><p>If the model keeps missing important context, RAG helps.</p><p>If the model keeps producing the wrong kind of output, fine-tuning may help.</p><p>When I frame it this way, the decision becomes much clearer.</p><h3>Why I would not start with fine-tuning by default</h3><p>Fine-tuning sounds attractive because it feels like a more tailored solution.</p><p>But in practice, it comes with trade-offs:</p><ul><li>you need training data,</li><li>you need a process to maintain that data,</li><li>you need evaluation,</li><li>you need iteration,</li><li>and you need a reason strong enough to justify the extra complexity.</li></ul><p>That is a lot.</p><p>For many applications, the first version does not need all of that.</p><p>A clean RAG system is often faster to build, easier to update, and simpler to explain.</p><p>That is why I would rarely start with fine-tuning unless the problem clearly demands it.</p><h3>Where RAG can fail</h3><p>RAG is not magic either.</p><p>It works well only if retrieval is good.</p><p>If the wrong documents are retrieved, the model may still produce a bad answer.</p><p>That means RAG depends on:</p><ul><li>good chunking</li><li>good embeddings</li><li>good search/retrieval logic</li><li>relevant context ranking</li><li>clean source material</li></ul><p>If those parts are weak, the final answer will be weak too.</p><p>So while RAG is often the practical first step, it still needs careful design.</p><p>A bad retrieval pipeline can make the whole system feel unreliable.</p><h3>Where fine-tuning can fail</h3><p>Fine-tuning also has failure modes.</p><p>It can make people feel like the system is more specialized than it really is.</p><p>But if the dataset is poor, inconsistent, or too small, the result may not help much.</p><p>Also, if the underlying problem is knowledge freshness, fine-tuning can actually make things worse by giving a false sense of completeness.</p><p>Another issue is cost.</p><p>Training, testing, and maintaining fine-tuned models can become expensive if you do not really need them.</p><p>So the question is not whether fine-tuning is good.</p><p>The question is whether it is worth the complexity for your use case.</p><h3>A simple decision framework I use</h3><p>When I am deciding between the two, I ask these questions:</p><h3>1. Does the model need fresh or private information?</h3><p>If yes, RAG is usually the better first choice.</p><h3>2. Does the model need to behave in a very specific, repeatable way?</h3><p>If yes, fine-tuning may help.</p><h3>3. Is the main problem retrieval or behavior?</h3><p>If it is retrieval, use RAG.<br>If it is behavior, think about fine-tuning.</p><h3>4. Do I need the system to update often?</h3><p>If yes, RAG is easier to maintain.</p><h3>5. Do I have enough high-quality training data?</h3><p>If no, fine-tuning may not be worth it yet.</p><p>That framework keeps the decision practical.</p><h3>In real products, the answer is often RAG first</h3><p>If I am being honest, most production use cases I would build first would start with RAG.</p><p>That is because the product usually needs:</p><ul><li>current information</li><li>easy updates</li><li>lower operational complexity</li><li>a faster path to launch</li></ul><p>RAG gives you a strong path to production without forcing you into a training pipeline too early.</p><p>That does not make fine-tuning useless.</p><p>It just means fine-tuning is often the second step, not the first.</p><h3>When I would choose fine-tuning</h3><p>I would consider fine-tuning when I have a very specific reason, such as:</p><ul><li>a narrow task with repeated patterns,</li><li>a well-defined output format,</li><li>a consistent brand voice,</li><li>specialized classification,</li><li>domain-specific reasoning,</li><li>or a workflow where prompting alone is no longer enough.</li></ul><p>In those situations, changing the model’s behavior can be more valuable than giving it additional information.</p><p>The key is having enough high-quality examples.</p><p>Fine-tuning works best when the model can learn from consistent patterns instead of trying to memorize constantly changing facts.</p><h3>Sometimes the best answer is both</h3><p>People often compare RAG and fine-tuning as if they compete with each other.</p><p>In reality, many production AI systems use both.</p><p>A common architecture looks like this:</p><ul><li>RAG retrieves the most relevant information.</li><li>The LLM uses that information to answer.</li><li>A fine-tuned model ensures the answer follows the desired style, format, or behavior.</li></ul><p>For example, imagine building an AI assistant for a healthcare company.</p><p>RAG can retrieve the latest clinical guidelines, internal policies, and patient documentation.</p><p>Fine-tuning can ensure every response follows the organization’s communication standards and required response format.</p><p>One solves the knowledge problem.</p><p>The other solves the behavior problem.</p><p>Together, they create a more reliable system than either approach alone.</p><h3>Sometimes you need neither</h3><p>This is something I think is easy to overlook.</p><p>Not every AI application needs RAG or fine-tuning.</p><p>Many use cases work surprisingly well with:</p><ul><li>a strong foundation model,</li><li>clear system prompts,</li><li>a few-shot examples,</li><li>and good prompt engineering.</li></ul><p>It’s worth trying the simplest solution first.</p><p>If prompting already gives reliable results, adding RAG or fine-tuning only increases complexity without providing much additional value.</p><p>Start simple.</p><p>Measure performance.</p><p>Only add complexity when the data tells you it’s necessary.</p><h3>My rule of thumb</h3><p>Over time, I’ve settled on a simple way of thinking about the decision:</p><ul><li>If the model needs <strong>new knowledge</strong>, start with <strong>RAG</strong>.</li><li>If the model needs <strong>different behavior</strong>, consider <strong>fine-tuning</strong>.</li><li>If it needs <strong>both</strong>, combine them.</li><li>If prompting already works, don’t add either.</li></ul><p>Keeping these distinctions clear has helped me avoid overengineering and focus on solving the actual problem instead of chasing the most sophisticated architecture.</p><h3>Final thoughts</h3><p>When I first learned about RAG and fine-tuning, I thought they were competing approaches.</p><p>Now I see them as complementary tools.</p><p>RAG answers the question:</p><p><em>“How can the model access the right information?”</em></p><p>Fine-tuning answers a different question:</p><p><em>“How should the model behave?”</em></p><p>Those are different problems, and they deserve different solutions.</p><p>For most real-world applications, I’d start with the simplest approach that can succeed.</p><p>In many cases, that’s a well-designed RAG pipeline.</p><p>If the product eventually needs more consistent behavior, structured outputs, or domain-specific performance, then fine-tuning becomes a natural next step.</p><p>The goal isn’t to use the most advanced technique.</p><p>The goal is to build an AI system that’s accurate, maintainable, and genuinely useful.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8661bb43cd2c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/django-unleashed/rag-vs-fine-tuning-which-one-should-you-use-8661bb43cd2c">RAG vs Fine-Tuning: Which One Should You Use?</a> was originally published in <a href="https://medium.com/django-unleashed">Django Unleashed</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I Split My AI Agent Between Django and FastAPI]]></title>
            <link>https://medium.com/django-unleashed/why-i-split-my-ai-agent-between-django-and-fastapi-18f1ce68ee5a?source=rss-619cf1fad823------2</link>
            <guid isPermaLink="false">https://medium.com/p/18f1ce68ee5a</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[fastapi]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Rushal Barkhade]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 01:31:01 GMT</pubDate>
            <atom:updated>2026-11-02T01:31:01.587Z</atom:updated>
            <content:encoded><![CDATA[<p>The more I built with AI, the more one thing became obvious:</p><p><strong>not every part of the system should live in the same place.</strong></p><p>At first, I thought I could keep everything inside Django.</p><p>That would have been the simplest path. One codebase. One deployment. One place to debug. For a while, that sounds great.</p><p>But once the AI logic started growing, that simplicity started turning into clutter.</p><p>I did not want my Django app to become a dumping ground for product logic, prompt handling, model calls, tool orchestration, background tasks, and experimental agent behavior all mixed together.</p><p>That is how systems become hard to maintain.</p><p>So I split the architecture.</p><p>Django handled the product side.</p><p>FastAPI handled the AI agent side.</p><p>That decision made the system cleaner, easier to reason about, and much easier to evolve.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UbQ1zxcLTxTb_bBfvKdUOg.png" /></figure><h3>The problem I was trying to solve</h3><p>The product use case was straightforward.</p><p>A user would trigger an action inside the app, and an AI agent would help complete the task.</p><p>In practice, that meant the system needed to do a few things:</p><ul><li>accept the request</li><li>validate it</li><li>understand the context</li><li>call the agent</li><li>possibly use tools or external APIs</li><li>return a result</li><li>store state if needed</li></ul><p>That sounds manageable until the AI logic starts getting more complex.</p><p>Then the questions begin:</p><ul><li>Where should the prompt live?</li><li>Where should tool usage live?</li><li>What happens if the model takes too long?</li><li>How do I keep the request cycle fast?</li><li>How do I keep the codebase readable?</li><li>How do I stop the AI layer from leaking into every part of the app?</li></ul><p>That was the point where I knew I needed a better boundary.</p><h3>Why Django alone was not enough</h3><p>I still think Django is excellent.</p><p>It is great for:</p><ul><li>authentication</li><li>permissions</li><li>database models</li><li>admin workflows</li><li>REST APIs</li><li>business rules</li><li>user-facing product logic</li></ul><p>That is exactly what it should be doing.</p><p>But an AI agent is a different kind of workload.</p><p>An agent is not just “call the model and return text.”</p><p>A real agent may need to:</p><ul><li>reason over context</li><li>call tools</li><li>chain steps together</li><li>retry actions</li><li>store intermediate state</li><li>handle failures</li><li>manage timeouts</li><li>return structured output</li></ul><p>That is a different responsibility.</p><p>If I force all of that into Django, I eventually end up with a codebase that is too mixed up to change confidently.</p><p>I did not want product code and AI orchestration to compete with each other.</p><h3>Why FastAPI made sense for the agent layer</h3><p>FastAPI gave me a better place for the AI service.</p><p>Not because Django could not handle it.</p><p>But because I wanted the agent to feel like its own service, with its own responsibility.</p><p>That gave me a few clear advantages:</p><ul><li>the agent could evolve independently</li><li>the AI endpoints stayed clean</li><li>async handling felt more natural</li><li>the service could be optimized for fast request handling</li><li>the main Django app stayed focused on the product</li></ul><p>I was not choosing FastAPI because it was trendy.</p><p>I was choosing it because the AI layer had a different shape than the rest of the application.</p><p>That mattered.</p><h3>The architecture</h3><p>The architecture became much easier to think about once I separated the responsibilities.</p><pre>User<br>  ↓<br>Django App<br>  ↓<br>Validate request / handle product logic<br>  ↓<br>Send job or request to AI service<br>  ↓<br>FastAPI Agent<br>  ↓<br>Prompt / tool orchestration / reasoning<br>  ↓<br>Return structured result<br>  ↓<br>Django stores response or sends it to the user</pre><p>That flow gave the whole system a cleaner shape.</p><p>Django became the product brain.</p><p>FastAPI became the AI brain.</p><p>And the boundary between them became much easier to understand.</p><h3>What Django handled</h3><p>Inside Django, I kept the parts that belonged to the product itself.</p><p>That meant:</p><ul><li>authentication</li><li>permissions</li><li>database models</li><li>workflow state</li><li>request validation</li><li>saving outputs</li><li>usage tracking</li><li>APIs for the frontend</li></ul><p>In other words, Django handled the parts of the system that needed to be stable and product-focused.</p><p>That is where Django shines.</p><p>I did not want to weaken that by mixing in agent logic everywhere.</p><h3>What FastAPI handled</h3><p>The AI service handled the parts that were more experimental and more workflow-driven.</p><p>That included:</p><ul><li>prompt construction</li><li>model orchestration</li><li>tool calling</li><li>multi-step reasoning</li><li>structured response generation</li><li>retries</li><li>intermediate state</li><li>AI-specific logging</li></ul><p>This gave the AI logic a place to grow without disrupting the rest of the product.</p><p>If I wanted to change how the agent behaved, I could work in the FastAPI service without touching the entire Django app.</p><p>That was a huge win.</p><h3>The biggest reason I split the system:maintainability</h3><p>This was the real reason.</p><p>Small systems can survive a bit of mess.</p><p>Growing systems cannot.</p><p>I have seen what happens when everything gets bundled together:</p><ul><li>code becomes harder to read</li><li>changes become risky</li><li>debugging takes longer</li><li>deployments get more fragile</li><li>no one is sure where a piece of logic belongs</li></ul><p>That is a bad place to be.</p><p>By separating Django and FastAPI, I gave each part of the system a clear job.</p><p>If something failed in the product layer, I looked at Django.</p><p>If something failed in the AI workflow, I looked at FastAPI.</p><p>That separation made troubleshooting much easier.</p><p>And it made the codebase feel calmer.</p><h3>How I thought about the service contract</h3><p>The interface between Django and FastAPI mattered a lot.</p><p>I did not want loose, vague communication between the two.</p><p>I wanted a clean contract.</p><p>So I treated the AI service like a component that accepts a request, does one job well, and returns a structured response.</p><p>For example, Django might send:</p><ul><li>user ID</li><li>input text</li><li>relevant context</li><li>request metadata</li></ul><p>And FastAPI might return:</p><ul><li>generated output</li><li>status</li><li>tool usage</li><li>optional metadata</li></ul><p>That kind of contract keeps the system predictable.</p><p>It also makes the integration easier to test and easier to change later.</p><h3>Why structured output mattered</h3><p>One thing I learned quickly is that AI features become much more useful when the output is structured.</p><p>If the agent returns only free-form text, the rest of the app has to do extra work.</p><p>But if the AI service returns something predictable, Django can decide what to do next without guessing.</p><p>For example:</p><pre>{<br>  &quot;status&quot;: &quot;success&quot;,<br>  &quot;message&quot;: &quot;Draft generated successfully&quot;,<br>  &quot;actions&quot;: [<br>    &quot;save_response&quot;,<br>    &quot;notify_user&quot;<br>  ]<br>}</pre><p>That makes the response much easier to work with.</p><p>It turns the AI output into something the product can actually use.</p><p>That is especially important when the agent is part of a larger workflow.</p><h3>Why I did not want long AI work inside the request cycle</h3><p>This was another major reason for the split.</p><p>Some AI tasks are fast.</p><p>Some are not.</p><p>Some require multiple steps, tool calls, or long reasoning paths.</p><p>If I let all of that happen directly inside the main Django request, the user experience would start to suffer.</p><p>The solution was to keep the request layer responsive and let the AI service handle the heavy thinking.</p><p>That meant Django could accept the request, save state, and hand off the work without blocking the whole app.</p><p>The user got a faster experience.</p><p>The system got a cleaner separation.</p><p>And I got a lot less stress.</p><h3>A cleaner way to think about the stack</h3><p>This is how I started thinking about it:</p><pre>Django<br>→ Product logic<br>→ Auth<br>→ State<br>→ Persistence<br>→ User workflows<br><br>FastAPI<br>→ AI orchestration<br>→ Agent behavior<br>→ Tool use<br>→ Structured reasoning<br>→ Model interaction</pre><p>That is the mental model that made the architecture feel right.</p><p>Django handled the product.</p><p>FastAPI handled the agent.</p><p>Everything had a place.</p><p>That is a much healthier way to build.</p><h3>What I would not do again</h3><p>I would not put all of this into one layer just because it feels easier in the beginning.</p><p>Early convenience becomes later complexity very quickly.</p><p>I would also not let the AI service become vague.</p><p>A separate service only works if the boundary is clear.</p><p>If the contract between Django and FastAPI is messy, you have not solved the problem — you have just moved it.</p><p>The goal is not separation for its own sake.</p><p>The goal is clarity.</p><h3>What this taught me about building AI products</h3><p>This project taught me something important:</p><p>AI features are not just about the model.</p><p>They are about architecture.</p><p>The model is only one piece of the experience.</p><p>The real product is everything around it:</p><ul><li>request handling</li><li>state management</li><li>reliability</li><li>observability</li><li>failure handling</li><li>response structure</li><li>user experience</li></ul><p>That is why I stopped asking, “Where should I put the model call?”</p><p>I started asking, “Where should this AI behavior live so the system stays clean as it grows?”</p><p>That is a much better question.</p><p>And it leads to much better architecture.</p><h3>Final thoughts</h3><p>Splitting the AI agent between Django and FastAPI was not about architecture purity.</p><p>It was about making the product easier to build, easier to maintain, and easier to scale.</p><p>Django handled the application.</p><p>FastAPI handled the agent.</p><p>The result was a system that felt much more manageable.</p><p>If you are building AI features into a backend product, my advice is simple:</p><p><strong>do not force everything into one layer just because it seems easier today.</strong></p><p>Build boundaries that match the job each part of the system is supposed to do.</p><p>That will save you a lot of pain later.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=18f1ce68ee5a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/django-unleashed/why-i-split-my-ai-agent-between-django-and-fastapi-18f1ce68ee5a">Why I Split My AI Agent Between Django and FastAPI</a> was originally published in <a href="https://medium.com/django-unleashed">Django Unleashed</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Integrated an LLM into a Django Application Without Making It a Mess]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/django-unleashed/how-i-integrated-an-llm-into-a-django-application-without-making-it-a-mess-2d8572ea453f?source=rss-619cf1fad823------2"><img src="https://cdn-images-1.medium.com/max/1536/1*KzoEM-E_wRDDIVmF2nCByw.png" width="1536"></a></p><p class="medium-feed-snippet">The first time I added an LLM to a Django application, I thought the hard part would be the model.</p><p class="medium-feed-link"><a href="https://medium.com/django-unleashed/how-i-integrated-an-llm-into-a-django-application-without-making-it-a-mess-2d8572ea453f?source=rss-619cf1fad823------2">Continue reading on Django Unleashed »</a></p></div>]]></description>
            <link>https://medium.com/django-unleashed/how-i-integrated-an-llm-into-a-django-application-without-making-it-a-mess-2d8572ea453f?source=rss-619cf1fad823------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d8572ea453f</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Rushal Barkhade]]></dc:creator>
            <pubDate>Tue, 29 Sep 2026 08:30:57 GMT</pubDate>
            <atom:updated>2026-09-29T08:30:57.131Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How We Reduced Django API Response Time from 2s to 200ms]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@rushalbarkhade11795/how-we-reduced-django-api-response-time-from-2s-to-200ms-1b81271ac58b?source=rss-619cf1fad823------2"><img src="https://cdn-images-1.medium.com/max/1536/1*BziIu8S_hJL3P6j8-Ad2ag.png" width="1536"></a></p><p class="medium-feed-snippet">A slow API endpoint is rarely caused by one line of code.</p><p class="medium-feed-link"><a href="https://medium.com/@rushalbarkhade11795/how-we-reduced-django-api-response-time-from-2s-to-200ms-1b81271ac58b?source=rss-619cf1fad823------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@rushalbarkhade11795/how-we-reduced-django-api-response-time-from-2s-to-200ms-1b81271ac58b?source=rss-619cf1fad823------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b81271ac58b</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Rushal Barkhade]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 05:37:18 GMT</pubDate>
            <atom:updated>2026-09-28T05:37:18.399Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[5 PostgreSQL Mistakes That Slowed Down Our SaaS]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@rushalbarkhade11795/5-postgresql-mistakes-that-slowed-down-our-saas-48a219458ce5?source=rss-619cf1fad823------2"><img src="https://cdn-images-1.medium.com/max/1536/1*biSSwadBRbyKaW8u_I6JPg.png" width="1536"></a></p><p class="medium-feed-snippet">When our SaaS started growing, the app did not feel slow at first. Pages loaded fine, background jobs ran, and the database seemed healthy&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@rushalbarkhade11795/5-postgresql-mistakes-that-slowed-down-our-saas-48a219458ce5?source=rss-619cf1fad823------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@rushalbarkhade11795/5-postgresql-mistakes-that-slowed-down-our-saas-48a219458ce5?source=rss-619cf1fad823------2</link>
            <guid isPermaLink="false">https://medium.com/p/48a219458ce5</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[postgres]]></category>
            <category><![CDATA[python-programming]]></category>
            <dc:creator><![CDATA[Rushal Barkhade]]></dc:creator>
            <pubDate>Sat, 26 Sep 2026 13:48:38 GMT</pubDate>
            <atom:updated>2026-09-26T13:48:38.423Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Anatomy of a Scalable Django SaaS: Lessons from Real Apps]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@rushalbarkhade11795/the-anatomy-of-a-scalable-django-saas-lessons-from-real-apps-1dee1e8e9672?source=rss-619cf1fad823------2"><img src="https://cdn-images-1.medium.com/max/1536/1*v-CAeCbDlt6VUlhaJG6uNw.png" width="1536"></a></p><p class="medium-feed-link"><a href="https://medium.com/@rushalbarkhade11795/the-anatomy-of-a-scalable-django-saas-lessons-from-real-apps-1dee1e8e9672?source=rss-619cf1fad823------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@rushalbarkhade11795/the-anatomy-of-a-scalable-django-saas-lessons-from-real-apps-1dee1e8e9672?source=rss-619cf1fad823------2</link>
            <guid isPermaLink="false">https://medium.com/p/1dee1e8e9672</guid>
            <category><![CDATA[django]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Rushal Barkhade]]></dc:creator>
            <pubDate>Mon, 06 Oct 2025 14:59:07 GMT</pubDate>
            <atom:updated>2025-10-06T14:59:07.680Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[⚡ Async Python in Machine Learning Pipelines]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://awstip.com/async-python-in-machine-learning-pipelines-04398f0efc0f?source=rss-619cf1fad823------2"><img src="https://cdn-images-1.medium.com/max/1024/1*hd7Qrz3KdmcIBU-a_2cvWQ.png" width="1024"></a></p><p class="medium-feed-snippet">Typically, when we think of machine learning, we think of training models or optimising LLMs. Data pipelines, however, are a hidden&#x2026;</p><p class="medium-feed-link"><a href="https://awstip.com/async-python-in-machine-learning-pipelines-04398f0efc0f?source=rss-619cf1fad823------2">Continue reading on AWS Tip »</a></p></div>]]></description>
            <link>https://awstip.com/async-python-in-machine-learning-pipelines-04398f0efc0f?source=rss-619cf1fad823------2</link>
            <guid isPermaLink="false">https://medium.com/p/04398f0efc0f</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[asynchronous]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Rushal Barkhade]]></dc:creator>
            <pubDate>Wed, 24 Sep 2025 02:31:47 GMT</pubDate>
            <atom:updated>2025-09-29T14:31:39.074Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[‍ Building AI Agents with Python in 2025]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/django-unleashed/building-ai-agents-with-python-in-2025-be8c5e2f3330?source=rss-619cf1fad823------2"><img src="https://cdn-images-1.medium.com/max/1536/1*jVUtIzI1B-uNELpOtLcN2A.png" width="1536"></a></p><p class="medium-feed-snippet">In 2025, AI agents will be ubiquitous. Agents are changing the way we interact with software, from self-sufficient customer support bots&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/django-unleashed/building-ai-agents-with-python-in-2025-be8c5e2f3330?source=rss-619cf1fad823------2">Continue reading on Django Unleashed »</a></p></div>]]></description>
            <link>https://medium.com/django-unleashed/building-ai-agents-with-python-in-2025-be8c5e2f3330?source=rss-619cf1fad823------2</link>
            <guid isPermaLink="false">https://medium.com/p/be8c5e2f3330</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Rushal Barkhade]]></dc:creator>
            <pubDate>Thu, 18 Sep 2025 17:40:31 GMT</pubDate>
            <atom:updated>2025-09-19T07:10:41.286Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[ Python in 2025: Is It Still the Best Language for AI?]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://python.plainenglish.io/python-in-2025-is-it-still-the-best-language-for-ai-77649642c783?source=rss-619cf1fad823------2"><img src="https://cdn-images-1.medium.com/max/1536/1*F41U6AbfCD1PiRWhLKOacg.png" width="1536"></a></p><p class="medium-feed-snippet">For more than ten years, Python has dominated the AI field. Researchers, engineers, and startups all use it, from Hugging Face&#x2026;</p><p class="medium-feed-link"><a href="https://python.plainenglish.io/python-in-2025-is-it-still-the-best-language-for-ai-77649642c783?source=rss-619cf1fad823------2">Continue reading on Python in Plain English »</a></p></div>]]></description>
            <link>https://python.plainenglish.io/python-in-2025-is-it-still-the-best-language-for-ai-77649642c783?source=rss-619cf1fad823------2</link>
            <guid isPermaLink="false">https://medium.com/p/77649642c783</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[python-ai-libraries]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[python-ai]]></category>
            <dc:creator><![CDATA[Rushal Barkhade]]></dc:creator>
            <pubDate>Mon, 15 Sep 2025 14:01:39 GMT</pubDate>
            <atom:updated>2025-09-18T05:04:31.455Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[️ Use Django Axes to Protect Your Django App from Brute-Force Attacks]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://python.plainenglish.io/%EF%B8%8F-use-django-axes-to-protect-your-django-app-from-brute-force-attacks-1e4ff465a994?source=rss-619cf1fad823------2"><img src="https://cdn-images-1.medium.com/max/1536/1*eQyVI_LRwE4-QMtUpAoECA.png" width="1536"></a></p><p class="medium-feed-snippet">Security is an important consideration while developing a web application.The brute-force assault, in which attackers quickly test various&#x2026;</p><p class="medium-feed-link"><a href="https://python.plainenglish.io/%EF%B8%8F-use-django-axes-to-protect-your-django-app-from-brute-force-attacks-1e4ff465a994?source=rss-619cf1fad823------2">Continue reading on Python in Plain English »</a></p></div>]]></description>
            <link>https://python.plainenglish.io/%EF%B8%8F-use-django-axes-to-protect-your-django-app-from-brute-force-attacks-1e4ff465a994?source=rss-619cf1fad823------2</link>
            <guid isPermaLink="false">https://medium.com/p/1e4ff465a994</guid>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[django-axes]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[django-security]]></category>
            <dc:creator><![CDATA[Rushal Barkhade]]></dc:creator>
            <pubDate>Tue, 02 Sep 2025 01:48:10 GMT</pubDate>
            <atom:updated>2025-09-03T00:11:32.640Z</atom:updated>
        </item>
    </channel>
</rss>