<?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 Muhammad Uzair on Medium]]></title>
        <description><![CDATA[Stories by Muhammad Uzair on Medium]]></description>
        <link>https://medium.com/@muhammaduzairse?source=rss-eb45f0aa40ce------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*fzGkl4Ln-URDmU7J1xNLgQ.jpeg</url>
            <title>Stories by Muhammad Uzair on Medium</title>
            <link>https://medium.com/@muhammaduzairse?source=rss-eb45f0aa40ce------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 13:40:01 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@muhammaduzairse/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[Three Bugs, One Takeover: How a Username Hijacked Every Account]]></title>
            <link>https://medium.com/@muhammaduzairse/three-bugs-one-takeover-how-a-username-hijacked-every-account-88834e1d891b?source=rss-eb45f0aa40ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/88834e1d891b</guid>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[melicious-bugs]]></category>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Muhammad Uzair]]></dc:creator>
            <pubDate>Tue, 09 Jun 2026 13:53:53 GMT</pubDate>
            <atom:updated>2026-06-09T13:53:53.020Z</atom:updated>
            <content:encoded><![CDATA[<p><em>None of them looked critical on their own. Chained together, they handed over the entire platform — without the victim clicking a thing.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N9-4H_pqk2aiY5vcycGgEA.png" /></figure><p>When you commission a security audit, you brace yourself for the one catastrophic finding: the SQL injection, the exposed admin panel, the hardcoded key in a public bundle. But the result that actually keeps you up at night is rarely a single bug. More often it’s two or three <em>medium</em>-looking ones that quietly snap together like puzzle pieces.</p><p>That’s exactly what we found while auditing the backend of our EdTech platform — a SaaS where teachers run courses, hand out assignments, and review student submissions. The top three findings each looked manageable in isolation. Chained, they formed a complete, hands-off account takeover: any teacher’s session could be stolen, an admin’s session along with it, and the victim never had to click anything at all.</p><p>Here’s how the three pieces fit — and what we changed so they never fit again.</p><h3>Piece #1 — A profile name that runs code (Stored XSS)</h3><p>The first bug lived somewhere nobody thinks twice about: the profile name field.</p><p>Our PUT /api/profiles/{id} endpoint accepted any string for name and schoolName and stored it exactly as sent — no sanitization, no encoding. So instead of &quot;Ms. Khan,&quot; a user could save this as their name:</p><pre>&lt;img src=x onerror=&quot;/* attacker JavaScript here */&quot;&gt;</pre><p>To the database, it’s just a string. The problem appears at <em>render</em> time. When the frontend displays that name, the browser doesn’t see “a teacher whose name contains some characters.” It parses an &lt;img&gt; tag with a broken source and an onerror handler — and dutifully runs the JavaScript inside it. In the logged-in victim&#39;s session. With their permissions, their cookies, their browser storage.</p><p>This is <strong>stored (persistent) cross-site scripting</strong>, and it’s the nastiest XSS variant precisely because there’s no phishing link to click. The payload lives in the database and gets replayed to victims automatically. The browser genuinely cannot tell injected code from legitimate data — to it, it’s all just characters in the HTML.</p><p>On its own, you might rate this “bad, but contained.” Hold that thought.</p><h3>Piece #2 — The keys left on the kitchen table (tokens in localStorage)</h3><p>The second bug was about <em>where</em> we kept our credentials.</p><p>We used JWTs for auth — a short-lived access token plus a 7-day refresh token. Whoever holds those tokens <em>is</em> authenticated, so the single most important decision about them is: who can read them?</p><p>We were storing both in localStorage. And localStorage has one defining property that matters here: <strong>any JavaScript running on the page can read it in a single line.</strong></p><pre>localStorage.getItem(&#39;refreshToken&#39;)</pre><p>Compare that to an httpOnly cookie. The browser still attaches it to every request automatically — but JavaScript literally cannot read it. document.cookie won&#39;t even show it. That one property is the entire difference between &quot;an injected script can steal this&quot; and &quot;it can&#39;t.&quot;</p><p>The refresh token made it worse. It was valid for seven days, it was returned in the login response body, and it survived logout. So a single read wasn’t a momentary leak — it was a week-long master key that mints fresh access tokens on demand.</p><p>Again, in isolation: a known anti-pattern, worth fixing, not obviously a five-alarm fire. But now look at Pieces #1 and #2 side by side. One bug lets an attacker run JavaScript in a victim’s browser. The other leaves the credentials sitting in a spot that JavaScript can read. The gun and the ammunition.</p><p>We were still missing one thing: a way to point the gun at <em>everyone</em>.</p><h3>Piece #3 — The endpoint that introduced everyone (BOLA)</h3><p>The third bug was an authorization gap, and it’s the one that turned a single payload into a platform-wide weapon.</p><p>GET /api/teachers returned a paginated list of <strong>every</strong> registered teacher — all of them — to <em>any</em> authenticated teacher. Names, emails, schools, subscription status, even isAdmin flags. The endpoint checked &quot;are you logged in?&quot; but never &quot;are you allowed to see <em>this</em>?&quot;</p><p>That’s <strong>Broken Object Level Authorization</strong> (BOLA) — specifically the list-level flavor, where a collection that should have been scoped or admin-only gets handed out wholesale. By itself it’s a privacy problem: any free-tier user could harvest the whole platform’s contact list for phishing, and read off exactly which accounts were admins.</p><p>But here’s why it was the keystone of the chain. That teacher list returns every teacher’s <strong>name</strong> field. And remember what could live in a name field?</p><h3>Putting it together: one payload, every session</h3><p>Stand the three pieces up in a row and the attack writes itself. No clicks required.</p><ol><li><strong>Plant.</strong> An attacker self-registers as a teacher and sets their own profile name to a script that reads both tokens out of localStorage and sends them to a server they control. (Piece #1 — the field never sanitized it.)</li><li><strong>Deliver.</strong> Any time <em>any</em> teacher loads a page that calls GET /api/teachers, the attacker&#39;s poisoned name is in that response — and the script executes in that teacher&#39;s browser. (Piece #3 — the list delivers the payload to everyone, automatically.)</li><li><strong>Steal.</strong> The script reads the victim’s tokens straight out of localStorage. (Piece #2 — they were readable.)</li><li><strong>Persist.</strong> With the 7-day refresh token, the attacker mints new access tokens for a week, even after the victim logs out.</li><li><strong>Escalate.</strong> If the victim happens to be an admin — and the BOLA list conveniently told the attacker <em>who</em> the admins are — the stolen admin token unlocks every admin endpoint.</li></ol><p>A username took over the platform. That’s the whole story. And notice the most important property of a chain: <strong>breaking any single link collapses it.</strong> Sanitize the name field and the payload never plants. Move the refresh token to an httpOnly cookie and the script has nothing to steal. Either fix alone defuses the bomb — which is exactly why we fixed both, and the keystone too.</p><h3>What we changed</h3><p>The fixes map cleanly onto the three pieces, and the satisfying part is how much leverage each one has:</p><ul><li><strong>Encode and sanitize user input (kills #1).</strong> Validate name fields to reject control and HTML characters, sanitize on write as defense in depth, and — most importantly — encode on output so the browser always treats a name as text, never as a tag. A tightened Content-Security-Policy script-src is the third net behind those two.</li><li><strong>Get credentials out of JavaScript’s reach (kills #2).</strong> Refresh token in an httpOnly; Secure; SameSite cookie, never in localStorage or a response body. Access token in memory only — a variable that vanishes on refresh, so there&#39;s nothing persistent to grab. Add refresh-token rotation so a stolen token is single-use, plus an absolute session cap.</li><li><strong>Authorize the object, not just the session (kills #3).</strong> Gate the full teacher list behind the admin role — the same guard already protecting the genuine admin routes — and serve individual users their own data through a scoped, self-only endpoint.</li></ul><h3>The lesson worth keeping</h3><p>If there’s one thing this chain hammered home, it’s that <strong>severity is an emergent property, not a per-bug label.</strong> Scored individually, these were a high and two mediums — the kind of findings that can sit in a backlog for a quarter. Scored as a chain, they were a critical account takeover hiding in plain sight.</p><p>So when you triage your own findings, don’t just ask “how bad is this bug?” Ask “what does this bug <em>unlock</em> when it stands next to the others?” Map the links, not just the nodes. The catastrophic exploit is rarely one spectacular hole — it’s three boring ones that happen to line up.</p><p>And maybe give your profile-name field a second look while you’re at it.</p><p><em>Found this useful? The most valuable habit you can build from it is threat-modeling in chains rather than in isolation — your worst-case scenario almost always lives in the seams between findings, not inside any one of them.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=88834e1d891b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Engineering is Dead Without Product Thinking]]></title>
            <link>https://medium.com/@muhammaduzairse/software-engineering-is-dead-without-product-thinking-f7664ddec456?source=rss-eb45f0aa40ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/f7664ddec456</guid>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[business-strategy]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Muhammad Uzair]]></dc:creator>
            <pubDate>Sat, 25 Apr 2026 16:48:00 GMT</pubDate>
            <atom:updated>2026-04-25T16:48:00.965Z</atom:updated>
            <content:encoded><![CDATA[<p>The code you write is not the product. Let me say that again: <strong>your code is not the product.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GMW7wvz0vew1pUPDfmuIBw.png" /></figure><p>I’ve seen brilliant engineers write flawless code that nobody uses. Perfect architecture, clean code, zero bugs — and yet, completely irrelevant. Why? Because they built what they <em>thought</em> was needed, not what customers actually <em>wanted</em>.</p><p>This is the biggest blind spot in software engineering today.</p><h3>The Real Problem</h3><p>For years, we celebrated “full-stack engineers” and “10x developers.” We measured success by lines of code, deployment speed, and technical complexity. The culture rewarded you for shipping fast, building big, and mastering the latest framework.</p><p>But here’s the uncomfortable truth: <strong>engineering alone is dead.</strong> Not because code doesn’t matter — it absolutely does. But because code without purpose is just expensive art. It’s a beautiful house built on the wrong foundation.</p><p>Think about it. How many projects have you seen that were:</p><ul><li><strong>Technically brilliant</strong> but nobody wanted to use them</li><li><strong>Feature-rich</strong> but solving problems nobody had</li><li><strong>Well-architected</strong> but losing to simpler competitors</li><li><strong>Perfectly deployed</strong> but irrelevant to the actual market</li></ul><p>The next evolution of software engineering isn’t about coding faster or knowing more frameworks. It’s about understanding your customer, their pain, and their needs <em>before</em> you write a single line of code. It’s about <strong>thinking like a business person alongside thinking like an engineer.</strong></p><h3>Think Like a Product Owner</h3><p>Here’s the shift that matters: Stop being just an engineer. Start being a <strong>builder with business acumen.</strong></p><p>Before you write code, ask yourself these questions:</p><ul><li><strong>Who will actually use this?</strong> Not the stakeholder in the meeting. The real human on the other end. What’s their age, their pain, their workflow, their environment?</li><li><strong>What problem am I solving?</strong> For them, not for your CV or your tech stack. Is it a real problem or an imaginary one?</li><li><strong>What are my competitors doing?</strong> And more importantly, what are they <em>not</em> doing? Where’s the gap?</li><li><strong>What’s the one thing that makes this different?</strong> If you can’t answer this in one sentence, you don’t understand your product yet.</li><li><strong>How will this make their life easier?</strong> Not just faster. Easier. Better. Emotion matters. Usability matters. Delight matters.</li></ul><p>The engineers who ask these questions don’t just build features — they build solutions that people actually want to use.</p><h3>The Difference Between Coding and Creating</h3><p>Let me be clear about what I’m saying here.</p><p><strong>Coding</strong> is what you do. You write functions, manage databases, deploy servers, optimize queries. You do this well, maybe very well.</p><p><strong>Creating</strong> is why you do it. You understand the why. You know who benefits. You can articulate the value. You’ve thought about alternatives. You’ve considered the market. You know what success looks like and how to measure it.</p><p>Great engineers used to just code. Great engineers now need to understand the business they’re coding for.</p><p>This doesn’t make you a product manager. Product managers handle roadmaps, timelines, and stakeholders. But a great engineer who thinks like a product owner? That’s someone who:</p><ul><li>Asks the right questions before starting</li><li>Challenges assumptions instead of accepting them</li><li>Thinks about the user experience alongside the technical architecture</li><li>Considers business metrics alongside code metrics</li><li>Stays updated on what competitors are doing</li><li>Understands why certain decisions matter beyond the code</li></ul><h3>How Your Thinking Transforms the Product for Users</h3><p>Here’s the real magic: when you think like a product owner, the software you build becomes fundamentally different. More useful. More intuitive. More valuable.</p><p><strong>Users feel the difference immediately.</strong></p><p>When you understand your users before building, you don’t just ship features. You ship experiences. You anticipate their needs. You eliminate friction. You remove complexity. You make things delightful.</p><p>Compare two approaches:</p><p><strong>The Engineer Approach:</strong> “The requirement says add a search feature. I’ll build a search feature with all the technical bells and whistles.”</p><p><strong>The Product-Thinking Approach:</strong> “Users need to find things quickly. Let me understand how they currently search. What keywords do they use? What frustrates them? How can I make it faster? Should filters be visible or hidden? Should results be real-time or on-click? What if they misspell something?”</p><p>The second approach creates a search that users actually love using. The first creates a feature that technically works.</p><p>When you think about your user’s emotions, their workflow, their pain points — that’s when you build products people want to use. That’s when adoption skyrockets. That’s when customer satisfaction goes up. That’s when people refer others to your product.</p><p><strong>You become more than a software engineer.</strong> You become a craftsperson. A problem-solver. A value creator. Someone who genuinely improves people’s lives through what they build.</p><p>This is what separates a developer from a builder. A technician from a strategist. Someone who codes for a paycheck from someone who builds with purpose.</p><p>When users interact with software built by engineers who think like product owners, they feel it in every interaction:</p><ul><li><strong>Onboarding is smooth</strong> because you anticipated confusion</li><li><strong>Features work the way they expect</strong> because you thought about their mental models</li><li><strong>The interface feels intuitive</strong> because you obsessed over usability</li><li><strong>They accomplish their goals faster</strong> because you removed unnecessary steps</li><li><strong>They feel heard</strong> because their feedback was actually considered in the design</li></ul><p>Your thinking directly translates to better user experience. Better experience translates to better retention. Better retention translates to business growth. Business growth translates to your value as an engineer skyrocketing.</p><p>You’re not just writing code anymore. You’re designing solutions that matter.</p><h3>For Service-Based and IT Companies</h3><p>If you’re building for a client or customer, this matters <em>even more than</em> in product companies.</p><p>Your competitors aren’t sleeping. Your customer has other options. They can hire another agency, another development team, another vendor. The question isn’t “Can we build it?” — it’s “Why would they choose us over someone else?”</p><p>When you’re working in a service-based model, product thinking becomes your competitive advantage:</p><p><strong>Understand their business deeply.</strong> Not just their requirements or their technical specs. Understand their revenue model. What makes them money? Who are their customers? What’s their market? What keeps them up at night? When you understand these things, you don’t just code features — you build solutions that directly impact their bottom line.</p><p><strong>Think about their competition too.</strong> Your customer is competing in their market. When you build for them, you’re not just solving a technical problem — you’re helping them win against their competitors. The more you understand their competitive landscape, the better solutions you can propose.</p><p><strong>Show the business impact.</strong> Instead of saying “I built this feature,” say “This reduces your customer onboarding time by 40%, which means you convert 20% more leads.” This is how you become invaluable to clients.</p><p><strong>Bring market insights to the table.</strong> Your clients want to know what’s working in their industry. What are successful SaaS companies doing? What are enterprises implementing? What are startups using? When you bring this knowledge, you’re no longer just a developer — you’re a strategic partner.</p><p>Engineers in service companies who think like product owners become the ones clients want to work with. They become the ones who get retained for years. They become the ones who get referrals and testimonials. They become the ones whose opinion actually matters in decision-making.</p><h3>What Actually Needs to Change</h3><p>Engineers who think like product owners will own the next decade of software. Everyone else will gradually become commoditized.</p><p>Here’s what needs to change in how you approach your work:</p><ol><li><strong>Stop writing code in isolation.</strong> Talk to customers. Listen to them. Understand their frustrations, their workflows, their preferences. Ask why they need something, not just what they need.</li><li><strong>Learn the business.</strong> Your company’s metrics, your customer’s metrics, your competitor’s metrics. How does your product/service make money? What are the revenue drivers? What’s the unit economics?</li><li><strong>Design with empathy and intention.</strong> Features don’t matter if they don’t solve real problems in ways people actually want. A simple solution that delights is better than a complex one that confuses.</li><li><strong>Think long-term, not sprint-term.</strong> Not just about shipping fast this month, but about building something that lasts, grows, and compounds in value.</li><li><strong>Measure impact, not just output.</strong> It’s not about how many lines of code you wrote or how many features you shipped. It’s about how much value you created for customers and the business.</li><li><strong>Stay curious about the market.</strong> Read about your industry. Know what’s happening. Understand trends. This isn’t busy work — this is how you stay relevant and informed.</li></ol><h3>The Bottom Line</h3><p>The best engineers aren’t the ones with the fanciest tech stack or the most GitHub stars. They’re the ones who understand why they’re building something, who it’s for, and what success actually looks like for the people using it.</p><p>These engineers don’t just ship code. They ship value. They don’t just follow requirements. They question them. They don’t just build features. They build solutions. And most importantly, they don’t just think about the technology — they think about the business, the users, and the impact.</p><p><strong>Product thinking isn’t optional anymore. It’s essential.</strong> It’s the difference between being replaceable and being indispensable.</p><p>So the next time you’re about to start coding, pause for a moment and ask yourself these questions:</p><ul><li>Am I solving a real problem for real people?</li><li>Do I understand why this matters to them?</li><li>Have I thought about what success looks like?</li><li>Could a competitor build this better, and if so, why?</li><li>Will this still matter in a year?</li></ul><p>The difference between answering these questions and ignoring them will define your career trajectory over the next few years.</p><p>The future belongs to engineers who think like builders, not just coders.</p><p><em>Are you thinking like an engineer, or are you thinking like a builder with a mission?</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f7664ddec456" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI is Eating Software: The Last Job Standing]]></title>
            <link>https://medium.com/@muhammaduzairse/ai-is-eating-software-the-last-job-standing-1d337e0cdc82?source=rss-eb45f0aa40ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d337e0cdc82</guid>
            <dc:creator><![CDATA[Muhammad Uzair]]></dc:creator>
            <pubDate>Fri, 20 Feb 2026 21:09:44 GMT</pubDate>
            <atom:updated>2026-02-20T21:09:44.415Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Marc Andreessen</strong> said software is <strong>eating</strong> the world.</p><p>Now AI is <strong>eating</strong> software.</p><p>Every software product you use today — CRM, billing, support, analytics, scheduling — is being swallowed whole by AI that doesn’t just assist workflows. It replaces them.</p><p>You don’t need a project management app when AI manages the project. You don’t need a CRM when AI handles the relationship. You don’t need analytics dashboards when AI just tells you what to do.</p><p>The entire software layer — the interfaces, the buttons, the subscriptions — is becoming unnecessary overhead between you and the outcome you actually want.</p><h3>The Old Way is Dead</h3><p>Think about it. How much of your day is spent clicking through software interfaces?</p><p>Opening tabs. Switching between apps. Copying data from one system to another. Formatting reports. Updating spreadsheets. Managing tasks in project management tools.</p><p>All of that? It’s going away.</p><p>Not in 10 years. In the next 12–18 months.</p><p>AI doesn’t need interfaces. It doesn’t need you to click buttons or fill out forms. It just does the work and gives you the result.</p><p>The software layer we’ve spent decades building is becoming obsolete.</p><h3>So, How Do You Build in a World Like This?</h3><p>I’ve completely changed how I approach engineering. I call it <strong>compound engineering</strong> — a philosophy where each unit of engineering work makes the next one easier, not harder.</p><p>Here’s the framework:</p><p><strong>Plan → Work → Review → Compound → Repeat</strong></p><p>The ratio matters: <strong>80% planning and review. 20% execution.</strong></p><p>Let me break that down.</p><h3>80% Planning and Review</h3><p>Most developers still think the work is in typing code. It’s not.</p><p>The work is in:</p><ul><li>Understanding what needs to exist</li><li>Designing the right architecture</li><li>Making decisions about what NOT to build</li><li>Reviewing what was built and extracting patterns</li><li>Documenting knowledge so it compounds</li></ul><p>I spend most of my time here. Planning in detail. Reviewing ruthlessly. Extracting lessons. Building a knowledge system that gets smarter with every project.</p><h3>20% Execution</h3><p>This is where AI agents come in.</p><p>AI handles the grunt work:</p><ul><li>Writing the actual code</li><li>Implementing the patterns I’ve defined</li><li>Generating boilerplate and repetitive logic</li><li>Following the architectural decisions I’ve made</li></ul><p>I focus on architecture, taste, and compounding knowledge.</p><p>Every cycle, the system gets smarter:</p><ul><li>Patterns get documented</li><li>Reviews catch more edge cases</li><li>Plans get sharper and more detailed</li><li>The knowledge base grows</li></ul><h3>The Compounding Effect</h3><p>Traditional development accumulates technical debt. Every feature added makes the next one harder.</p><p>Compound engineering accumulates technical leverage. Every feature added makes the next one easier because you’ve documented the patterns, refined your approach, and built reusable knowledge.</p><p>After 10 projects using traditional development, you’re slower because of all the debt.</p><p>After 10 projects using compound engineering, you’re 10x faster because of all the leverage.</p><p>That’s the real shift.</p><h3>When AI Eats Software, Speed Isn’t Enough</h3><p>Here’s what most people get wrong: they think the winners in this AI-driven world will be the ones who build the fastest.</p><p>They won’t.</p><p>The winners will be the ones who <strong>compound the smartest</strong>.</p><p>Because when AI can generate infinite variations of software in seconds, speed becomes commoditized.</p><p>What becomes valuable is knowing WHAT to build. What SHOULD exist. What’s worth building in the first place.</p><h3>The Last Job Standing: Taste</h3><p>When AI can build anything you can describe, the bottleneck isn’t execution anymore.</p><p>It tastes.</p><p><strong>Taste is the ability to know:</strong></p><ul><li>What should exist</li><li>What problem is worth solving</li><li>What feels right vs. what feels off</li><li>What customers actually need vs. what they say they need</li><li>Which of 100 AI-generated options is the right one</li></ul><p>Taste is the one thing you can’t automate.</p><p>It’s pattern recognition born from lived experience, empathy, and an obsession with getting the details right.</p><p>You can’t prompt your way to good taste. You can’t train a model on it. It comes from:</p><ul><li>Building things and seeing what works</li><li>Talking to real users and feeling their pain</li><li>Shipping products and watching how people actually use them</li><li>Making mistakes and learning what NOT to do</li></ul><h3>The Future Belongs to Curators, Not Coders</h3><p>Let me paint you a picture of what’s coming:</p><p><strong>Old World:</strong></p><ul><li>Engineer gets a feature request</li><li>Spends days/weeks writing code</li><li>Ships the feature</li><li>Moves to the next one</li></ul><p><strong>New World:</strong></p><ul><li>Curator gets a problem to solve</li><li>Spends hours planning and designing the right solution</li><li>AI generates 10 variations in minutes</li><li>Curator picks the best one, refines it, ships it</li><li>Documents the patterns for next time</li></ul><p>The role shifts from <strong>builder</strong> to <strong>editor</strong>.</p><p>From <strong>engineer</strong> to <strong>curator</strong>.</p><p>From typing code to choosing what should exist.</p><h3>What This Means For You</h3><p>If you’re still spending most of your time writing code, you’re optimizing for the wrong thing.</p><p>The valuable skills are:</p><ul><li><strong>Architecture:</strong> Designing systems that make sense</li><li><strong>Taste:</strong> Knowing what should exist and what shouldn’t</li><li><strong>Pattern Recognition:</strong> Seeing what works and codifying it</li><li><strong>Knowledge Compounding:</strong> Building systems that get smarter over time</li><li><strong>Curation:</strong> Choosing the right solution from infinite options</li></ul><p>The most valuable skill in tech isn’t going to be building anymore.</p><p><strong>It’s going to be choosing.</strong></p><p>Choosing what to build. Choosing how to build it. Choosing which AI-generated option is right. Choosing what to ship and what to kill.</p><h3>The Shift is Already Happening</h3><p>I see it in my own work. Projects that used to take weeks now take days. But I’m not moving faster by typing more code.</p><p>I’m moving faster by:</p><ul><li>Planning better</li><li>Letting AI handle execution</li><li>Reviewing more carefully</li><li>Extracting and documenting patterns</li><li>Building leverage that compounds</li></ul><p>Every project makes the next one easier. Every decision gets documented. Every pattern gets reused. The system gets smarter.</p><p>That’s compound engineering.</p><h3>The Real Question</h3><p>So here’s what you need to ask yourself:</p><p>Are you building in a way that accumulates debt or accumulates leverage?</p><p>Are you getting faster with each project or slower?</p><p>Are you developing taste or just executing tasks?</p><p>Are you ready for a world where AI eats software and the only thing left is knowing what should exist?</p><p>Because that world isn’t coming.</p><p>It’s already here.</p><p>And the developers who win won’t be the ones who code the fastest.</p><p>They’ll be the ones who choose the smartest.</p><p><strong>The future belongs to curators, not coders. To editors, not engineers. To people who can look at infinite AI-generated possibilities and say: “This one. Ship it.”</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d337e0cdc82" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Most Developers Are Using AI Wrong (And Losing Massive Time)]]></title>
            <link>https://medium.com/@muhammaduzairse/why-most-developers-are-using-ai-wrong-and-losing-massive-time-9b7b469f49de?source=rss-eb45f0aa40ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/9b7b469f49de</guid>
            <category><![CDATA[ai-usage]]></category>
            <category><![CDATA[time-is-precious]]></category>
            <dc:creator><![CDATA[Muhammad Uzair]]></dc:creator>
            <pubDate>Fri, 20 Feb 2026 20:53:24 GMT</pubDate>
            <atom:updated>2026-02-20T20:53:24.308Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bCiaryPw-crSKsZtG4bXsA.png" /></figure><p><strong>Picture this:</strong> In 6 months to a year, developers who didn’t learn to use AI properly will be completely left behind. Not because they can’t code, but because they missed the boat on the biggest shift in how we work. And honestly? That’s already starting to happen.</p><p><strong>Here’s the reality:</strong> a lot of developers are already using AI. They have Cursor installed, they ask ChatGPT questions, and they generate some code here and there. But they’re barely scratching the surface of what’s actually possible. And that gap between “using AI a little” and “using AI properly” is costing them massive amounts of time.</p><p>If you’re using AI tools but not taking full <strong>leverage</strong> of them, you’re still working with one hand tied behind your back — you just don’t realize it yet.</p><h3>Things Have Changed FAST</h3><p>Remember 2023? Back then, building an MVP took weeks, maybe months. You’d spend days just setting up the basics, writing boilerplate, and configuring everything.</p><p>Now? I can build a complete MVP in 4–5 hours. Not a joke. A full working MVP with backend, frontend, database setup, authentication — everything.</p><p>That’s how fast things have changed with AI. And if you’re still working like it’s 2023, you’re in trouble.</p><h3>What You’re Losing</h3><p><strong>You’re wasting massive amounts of time.</strong> In 2023, spending a day or two on a feature was normal. Now with AI, that same feature takes 30 minutes. If you’re still doing it the old way, you’re literally 10x slower than you need to be.</p><p><strong>You’re becoming outdated.</strong> While you’re typing code line by line like we did in 2023, other developers are building entire MVPs in hours. The speed gap is insane.</p><p><strong>You’re less competitive.</strong> Companies now expect developers to move fast. Really fast. If you can’t build quickly with AI, someone else will take your spot.</p><h3>How I Actually Work Now</h3><p>Let me show you the difference between 2023 and now.</p><p><strong>2023:</strong> I’d spend 2–3 days just building a login system. Setting up routes, creating database models, writing authentication logic, testing everything. Multiple days of work.</p><p><strong>Now with AI:</strong> I give Cursor a detailed prompt: “Create a complete authentication system with email/password login, JWT tokens, password reset functionality, email verification, PostgreSQL database setup, and all API routes.” Done in 20 minutes.</p><p><strong>2023:</strong> Building a CRUD app for a blog? That’s a week-long project. Setup, models, controllers, views, testing.</p><p><strong>Now with AI:</strong> I describe what I need in detail to Cursor, and the entire CRUD app is ready in under an hour. I just test it and deploy.</p><p><strong>2023:</strong> Building an MVP for a simple SaaS idea? You’re looking at 2–3 weeks minimum.</p><p><strong>Now with AI,</strong> I can build a complete working MVP in 4–5 hours. Authentication, database, core features, basic UI — everything functional and ready to test with real users.</p><h3>The Prompt Engineering Secret</h3><p>Here’s the thing: AI doesn’t work well if you just say “make a login page.” That gives you trash.</p><p>You need to be super specific. And here’s my exact process:</p><p><strong>Step 1: Define the role and context first</strong></p><p>I always start by telling the AI what role it should play and giving it context. For example:</p><p>“You are an expert full-stack developer specializing in React and Node.js. I’m building a SaaS application for project management. The tech stack is: React with TypeScript, Node.js with Express, PostgreSQL database, and Tailwind CSS.”</p><p><strong>Step 2: Write the detailed prompt</strong></p><p>Then I get specific about what I want:</p><p>“Create a user dashboard component that includes:</p><ul><li>A sidebar with navigation menu</li><li>A header with user profile dropdown and notifications</li><li>Main content area with project statistics cards</li><li>A data table showing recent activities with sorting and filtering</li><li>Use TypeScript interfaces for all data</li><li>Implement proper error handling</li><li>Add loading states”</li></ul><p><strong>Step 3: Paste it into Cursor</strong></p><p>I take this complete prompt (role + context + detailed requirements) and paste it directly into Cursor. The result? Production-ready code that actually works.</p><p><strong>Bad prompt:</strong> “Create a user dashboard”</p><p><strong>My prompt with role and context:</strong> “You are an expert React developer with TypeScript expertise. Context: Building a project management SaaS app using React, TypeScript, Node.js, PostgreSQL, Tailwind CSS.</p><p>Create a user dashboard component with sidebar navigation, header with user profile dropdown, main content area showing project statistics in cards, and a data table with sorting/filtering for recent activities. Use TypeScript interfaces for all data and add proper error handling.”</p><p>See the massive difference? The second one gives me exactly what I need, first try.</p><h3>What Your Job Actually Is Now</h3><p>Code writing? That’s solved. AI does it better and faster than you can type.</p><p>Your real job now is:</p><ul><li>Understanding what the business actually needs</li><li>Designing the right solution</li><li>Writing perfect prompts with clear roles and context</li><li>Getting the best output from AI by being specific</li><li>Testing and making sure everything works together</li><li>Making smart decisions about architecture</li></ul><p>You’re not a code typist anymore. You’re a problem solver who uses AI as a tool.</p><h3>My Actual Workflow</h3><p>Here’s how I work every single day:</p><ol><li><strong>I define the role:</strong> “You are an expert backend developer specializing in Node.js and PostgreSQL.”</li><li><strong>I give context:</strong> “I’m building an e-commerce API with user authentication, product catalog, and order management.”</li><li><strong>I write detailed requirements:</strong> Exactly what I need, with tech stack, error handling, and data structures</li><li><strong>I paste the complete prompt into Cursor:</strong> Role + Context + Requirements altogether</li><li><strong>I get perfect code:</strong> It works because my prompt was complete and clear</li></ol><p>I do this for EVERYTHING. Every feature, every component, every API endpoint. And it works perfectly every time.</p><p>Look, I’m building full MVPs in 4–5 hours now. In 2023, those same MVPs would’ve taken me weeks. That’s not because I got smarter. It’s because I learned to use AI properly with the right prompts.</p><p>If you’re still coding like it’s 2023, you’re going to be left behind. Not in 5 years. In 6 months to a year, max.</p><p>The speed of development has completely changed. Either you catch up, or you get replaced by someone who did.</p><p>Your choice. But choose fast.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9b7b469f49de" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Parameter Everyone Ignores (Until Their AI Starts Hallucinating)]]></title>
            <link>https://medium.com/@muhammaduzairse/the-parameter-everyone-ignores-until-their-ai-starts-hallucinating-d6fe420fd169?source=rss-eb45f0aa40ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/d6fe420fd169</guid>
            <category><![CDATA[hallucinations]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <dc:creator><![CDATA[Muhammad Uzair]]></dc:creator>
            <pubDate>Thu, 06 Nov 2025 08:37:05 GMT</pubDate>
            <atom:updated>2025-11-06T08:37:05.483Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*wNZjN1zzi4ZSX4rKkMZ8Mg.png" /></figure><h3>The Parameter Everyone Ignores (Until Their AI Starts Hallucinating)</h3><p>If you’ve ever worked with Large Language Models, you’ve probably spent hours crafting the perfect prompt. You tweak the wording, add examples, restructure your instructions — and sometimes, it still doesn’t work.</p><p>I recently learned this lesson the hard way.</p><h3>My Hallucination Problem</h3><p>I was building a feature to generate estimated prices along with brief descriptions for products. The requirements seemed straightforward: provide accurate price estimates based on certain criteria and add helpful context.</p><p>I wrote what I thought was a solid prompt. The model returned results, but something was off. The prices were wildly inconsistent — sometimes reasonable, sometimes completely fabricated. The descriptions were creative, sure, but the numbers? Pure hallucination.</p><h3>The Debugging Journey</h3><p>Like any developer, I went straight to prompt engineering:</p><ul><li>✍️ Made my instructions more explicit</li><li>📝 Added few-shot examples</li><li>🎯 Tried different prompt structures</li><li>🔄 Experimented with chain-of-thought reasoning</li><li>⚠️ Added warnings about accuracy</li></ul><p>Hours passed. Nothing worked.</p><p>The model kept generating prices that seemed plausible at first glance but made no sense when you looked closer. It was confidently wrong — the worst kind of wrong.</p><h3>The Overlooked Culprit: Temperature</h3><p>Frustrated, I started examining the model configuration itself. That’s when I noticed it: <strong>temperature was set to 0.9</strong>.</p><p>I had been so focused on the prompt that I completely ignored the parameters controlling the model’s behavior.</p><p>I decreased the temperature to <strong>0.4</strong> — below the standard 0.7 — and ran the same prompt again.</p><p>The difference was night and day:</p><ul><li>✅ Price estimates became consistent and realistic</li><li>✅ Hallucinations dropped dramatically</li><li>✅ The model stayed grounded in reasonable ranges</li><li>✅ Descriptions remained helpful but less “creative” with facts</li></ul><h3>What Exactly is Temperature?</h3><p>Temperature is a parameter that controls randomness in the model’s output. Think of it as a creativity dial that affects how the model samples from its probability distribution of possible next tokens.</p><h3>The Technical Side</h3><p>When a language model generates text, it predicts the probability of each possible next token (word or word piece). Temperature modifies these probabilities before sampling:</p><p><strong>Temperature = 0.0</strong></p><ul><li>The model always picks the highest probability token</li><li>Completely deterministic output</li><li>Zero creativity or variation</li></ul><p><strong>Low Temperature (0.1–0.4)</strong></p><ul><li>Strongly favors high-probability tokens</li><li>More focused and conservative outputs</li><li>Minimal randomness</li></ul><p><strong>Standard Temperature (0.7–0.8)</strong></p><ul><li>Balanced probability distribution</li><li>Mix of likely and less likely choices</li><li>General-purpose setting</li></ul><p><strong>High Temperature (0.9–1.2+)</strong></p><ul><li>Flattens the probability distribution</li><li>More exploratory and diverse outputs</li><li>Higher chance of unexpected tokens</li></ul><h3>The Practical Impact</h3><p><strong>Low Temperature (0.0–0.4)</strong> is ideal for:</p><ul><li>📊 Numerical calculations and estimates</li><li>📋 Data extraction and classification</li><li>🎯 Factual question answering</li><li>💼 Structured output generation</li><li>🔍 Tasks requiring precision and consistency</li></ul><p><strong>High Temperature (0.8–1.0+)</strong> works better for:</p><ul><li>✨ Creative writing and storytelling</li><li>💭 Brainstorming and ideation</li><li>🎨 Generating diverse variations</li><li>🎭 Roleplay and character simulation</li><li>🔄 Exploring different perspectives</li></ul><h3>Why This Matters for Hallucination</h3><p>Hallucination in AI occurs when models generate plausible-sounding but false or nonsensical information. Higher temperatures increase hallucination risk because:</p><ol><li><strong>Increased Randomness</strong>: The model explores less probable tokens, including potentially incorrect ones</li><li><strong>Reduced Grounding</strong>: Less focus on the most likely (often most accurate) continuations</li><li><strong>Creative License</strong>: The model treats factual tasks like creative exercises</li></ol><p>For my pricing task, a temperature of 0.9 was treating numerical estimation like creative writing. The model was inventing prices with the same freedom it might invent plot points in a story.</p><h3>The Right Approach: Match Temperature to Task</h3><p>Here’s my updated framework for choosing temperature:</p><h3>Temperature 0.0–0.3: Precision Mode</h3><p><strong>Use when accuracy is non-negotiable</strong></p><ul><li>Mathematical calculations</li><li>Code generation for specific logic</li><li>Medical or legal information</li><li>Price quotes and estimates</li><li>Data validation</li></ul><h3>Temperature 0.4–0.6: Focused Mode</h3><p><strong>Use when you need reliable but slightly varied outputs</strong></p><ul><li>Technical documentation</li><li>Customer support responses</li><li>Educational content</li><li>Summarization tasks</li><li>Professional communications</li></ul><h3>Temperature 0.7–0.8: Balanced Mode</h3><p><strong>Use for general-purpose tasks</strong></p><ul><li>Conversational AI</li><li>Content drafting</li><li>General Q&amp;A</li><li>Mixed creative and factual tasks</li></ul><h3>Temperature 0.9–1.2: Creative Mode</h3><p><strong>Use when diversity and creativity are the goal</strong></p><ul><li>Fiction writing</li><li>Marketing copy variations</li><li>Brainstorming sessions</li><li>Character development</li><li>Poetry and artistic content</li></ul><h3>Other Parameters Worth Checking</h3><p>While temperature was my issue, other parameters also affect output quality:</p><ol><li><strong>Top-p (Nucleus Sampling)</strong></li></ol><p><strong>2. Top-k</strong></p><p><strong>3. Frequency Penalty</strong></p><p><strong>4. Presence Penalty</strong></p><h3>The Lesson I Learned</h3><p>Prompt engineering is powerful, but it’s not the only tool in your toolkit. Before spending hours refining your prompts:</p><ol><li><strong>Understand your task type</strong>: Is it factual or creative?</li><li><strong>Set appropriate parameters</strong>: Match temperature to your needs</li><li><strong>Test with different configurations</strong>: Parameters can have dramatic effects</li><li><strong>Monitor for hallucination</strong>: Especially with factual tasks</li><li><strong>Iterate on both prompts and parameters</strong>: They work together</li></ol><p>In my case, no amount of prompt engineering could overcome a misconfigured temperature setting. The model was being asked to be precise while its parameters told it to be creative.</p><h3>Conclusion</h3><p>Temperature is a small parameter with massive impact. It’s often overlooked because it seems less intuitive than prompt engineering — but ignoring it can undermine even the best prompts.</p><p>The next time your AI model produces inconsistent results or hallucinates, don’t immediately assume your prompt is the problem. Check your parameters. Sometimes the solution isn’t better instructions — it’s better configuration.</p><p><strong>My temperature settings by task type:</strong></p><ul><li>Pricing/Numbers: 0.3–0.4</li><li>Documentation: 0.5–0.6</li><li>General Content: 0.7</li><li>Creative Writing: 0.9–1.0</li></ul><p>What’s been your experience with temperature? Have you had similar “aha moments” with other parameters?</p><p><em>Have you encountered hallucination issues in your AI projects? What parameters do you typically adjust first? Share your experiences in the comments below.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d6fe420fd169" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RAG vs Fine-tuning vs Prompt Engineering: Choosing Your LLM Strategy]]></title>
            <link>https://medium.com/@muhammaduzairse/rag-vs-fine-tuning-vs-prompt-engineering-choosing-your-llm-strategy-da5f86b4a7af?source=rss-eb45f0aa40ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/da5f86b4a7af</guid>
            <dc:creator><![CDATA[Muhammad Uzair]]></dc:creator>
            <pubDate>Wed, 15 Oct 2025 07:13:47 GMT</pubDate>
            <atom:updated>2025-10-15T07:13:47.862Z</atom:updated>
            <content:encoded><![CDATA[<p>When building LLM applications with domain-specific knowledge, you face a crucial architectural decision: should you use Retrieval-Augmented Generation (RAG), fine-tune a model, or stick with prompt engineering? Each approach has distinct tradeoffs in cost, performance, and maintenance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cnEFsvrvGcYWLD2AnooiXA.png" /></figure><h3>The Three Approaches Explained</h3><p><strong>Prompt Engineering</strong> is the simplest approach where you craft instructions and provide context directly in the prompt. Think of it as having a conversation with an expert and giving them all the information they need upfront.</p><p><strong>RAG (Retrieval-Augmented Generation)</strong> combines LLMs with a search system. Your application retrieves relevant documents from a knowledge base and includes them in the prompt. It’s like giving the LLM access to a library it can reference in real-time.</p><p><strong>Fine-tuning</strong> involves training the model on your specific data, creating a specialized version. This bakes knowledge directly into the model’s parameters, similar to teaching someone a new skill through extensive practice.</p><h3>When to Use Each Approach</h3><h3>Choose Prompt Engineering when:</h3><ul><li>Your domain knowledge fits comfortably within the context window</li><li>You need quick iteration and flexibility</li><li>Your knowledge changes frequently</li><li>Budget is extremely limited</li><li>You’re building a prototype or MVP</li></ul><h3>Choose RAG when:</h3><ul><li>You have large, evolving knowledge bases (documentation, policies, databases)</li><li>Information needs to be up-to-date without retraining</li><li>You need transparency about information sources</li><li>You want to control what knowledge the model accesses</li><li>Your knowledge is too large for the context window</li></ul><h3>Choose Fine-tuning when:</h3><ul><li>You need consistent formatting or style (like specific JSON outputs)</li><li>Domain-specific terminology or jargon is critical</li><li>You require faster inference with smaller models</li><li>Your knowledge is relatively stable</li><li>You have enough quality training data (typically 1000+ examples)</li></ul><h3>Cost Comparison</h3><p>The economics differ dramatically across these approaches.</p><p><strong>Prompt Engineering</strong> has zero upfront cost but higher per-request costs if you’re including large amounts of context repeatedly. It’s the most expensive at scale if you’re constantly sending the same information.</p><p><strong>RAG</strong> requires infrastructure investment for vector databases and embedding generation, plus ongoing costs for retrieval. However, per-request costs are moderate since you only retrieve relevant chunks. Expect to spend $200–2000/month on vector database hosting depending on scale.</p><p><strong>Fine-tuning</strong> has high upfront costs for training (from hundreds to thousands of dollars per training run) but lower inference costs, especially if you can use smaller models. Once trained, you save on context window usage.</p><h3>Performance Characteristics</h3><p><strong>Prompt Engineering</strong> offers immediate results with zero latency overhead beyond the LLM call itself. However, it’s limited by context window size and can be inconsistent with complex instructions.</p><p><strong>RAG</strong> adds retrieval latency (typically 50–200ms) but handles massive knowledge bases effectively. Quality depends heavily on your retrieval system and chunking strategy. Expect 70–90% accuracy when properly tuned.</p><p><strong>Fine-tuning</strong> provides the fastest inference and most consistent outputs, especially for formatting. It excels at learning patterns and styles but can “forget” the base model’s general capabilities if overtrained. Accuracy can reach 90–95% for well-defined tasks.</p><h3>Maintenance and Iteration</h3><p><strong>Prompt Engineering</strong> requires no maintenance infrastructure but demands continuous prompt optimization. Changes are instant but can have unpredictable effects.</p><p><strong>RAG</strong> needs ongoing data pipeline maintenance, reindexing when content changes, and retrieval quality monitoring. Updates to the knowledge base are immediate once reindexed.</p><p><strong>Fine-tuning</strong> requires the most overhead with periodic retraining cycles, version management, and careful evaluation. Each update means a new training run, taking hours to days.</p><h3>The Hybrid Reality</h3><p>In production, most sophisticated systems combine these approaches. A common pattern is:</p><ul><li>Fine-tune for consistent output formatting and domain-specific behavior</li><li>Use RAG for dynamic, up-to-date information retrieval</li><li>Apply prompt engineering for task-specific instructions</li></ul><p>For example, a customer support bot might be fine-tuned on conversation style, use RAG to pull relevant help articles, and employ prompt engineering to handle edge cases.</p><h3>Making Your Decision</h3><p>Start with this decision tree:</p><ul><li><strong>Need it working today?</strong> → Start with prompt engineering</li><li><strong>Have evolving documentation?</strong> → Build RAG</li><li><strong>Need specialized behavior?</strong> → Consider fine-tuning</li><li><strong>Have $10K+ budget and stable data?</strong> → Combine fine-tuning + RAG</li><li><strong>Bootstrapping on a budget?</strong> → Prompt engineering → RAG → Fine-tuning</li></ul><h3>Final Thoughts</h3><p>The best architecture isn’t about choosing one approach but understanding when each tool fits your specific constraints around budget, latency, accuracy, and maintenance capacity.</p><p>Remember: you can always start simple and graduate to more complex solutions as your requirements and resources grow. Many successful LLM applications started with clever prompt engineering and evolved from there.</p><p><em>What approach have you found most effective for your LLM applications? Share your experiences in the comments below.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da5f86b4a7af" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Streaming vs Batch Processing for LLM Outputs: Architecture and UX Tradeoffs]]></title>
            <link>https://medium.com/@muhammaduzairse/streaming-vs-batch-processing-for-llm-outputs-architecture-and-ux-tradeoffs-5c1d266397f2?source=rss-eb45f0aa40ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/5c1d266397f2</guid>
            <dc:creator><![CDATA[Muhammad Uzair]]></dc:creator>
            <pubDate>Fri, 10 Oct 2025 07:53:23 GMT</pubDate>
            <atom:updated>2025-10-10T07:53:23.618Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jBXyqJnkUS1LBc1Jl2618Q.png" /></figure><p>When your LLM generates a response, you face a critical decision: stream tokens as they’re generated or wait for the complete response? This choice impacts user experience, system architecture, error handling, and even costs. Let’s break down when to use each approach and how to implement them effectively.</p><h3>Understanding the Two Approaches</h3><p><strong>Batch Processing</strong> waits for the entire LLM response to complete before returning anything to the user. You make an API call, wait 3–10 seconds, and get the full response at once.</p><p><strong>Streaming</strong> sends tokens to the user as soon as they’re generated by the LLM. The user sees words appearing in real-time, like someone typing. Response starts appearing in 200–500ms, even though total generation takes 5–10 seconds.</p><blockquote><em>The difference isn’t just technical — it fundamentally changes how users perceive your application’s responsiveness.</em></blockquote><h3>User Experience Impact</h3><h3>Perceived Latency</h3><p>This is where streaming shines. Humans perceive wait times differently based on feedback.</p><p><strong>Batch processing:</strong></p><ul><li>User sends message</li><li>Sees loading spinner for 5 seconds</li><li>Gets complete response</li><li><strong>Perceived wait: 5 seconds of uncertainty</strong></li></ul><p><strong>Streaming:</strong></p><ul><li>User sends message</li><li>First words appear in 300ms</li><li>Continues to see progress</li><li><strong>Perceived wait: 300ms until engagement begins</strong></li></ul><p>Studies show users rate streaming responses as “faster” even when total time is identical. The psychological principle: <strong>uncertainty and waiting feel longer than active progress.</strong></p><h3>User Engagement</h3><p><strong>Streaming advantages:</strong></p><ul><li>Users start reading immediately</li><li>Can interrupt if response goes off-track</li><li>Creates sense of AI “thinking” in real-time</li><li>Feels conversational and natural</li></ul><p><strong>Batch advantages:</strong></p><ul><li>Complete response for scanning/skimming</li><li>Clear start and end points</li><li>Easier to copy entire response</li><li>No partial information concerns</li></ul><h3>Real-World User Preferences</h3><p>ChatGPT, Claude, and most consumer AI products use streaming. Why? User testing consistently shows:</p><ul><li><strong>85%</strong> of users prefer streaming for conversational interfaces</li><li><strong>60%</strong> prefer batch for analytical/report generation</li><li><strong>70%</strong> prefer batch for code generation (want to see complete blocks)</li></ul><h3>Technical Architecture</h3><h3>Streaming Implementation</h3><p>Streaming requires different infrastructure than traditional request-response APIs.</p><p><strong>Backend architecture:</strong></p><pre>Client Request → API Gateway → LLM Service<br>                                    ↓<br>                Opens persistent connection (SSE/WebSocket)<br>                                    ↓<br>                For each token: Send immediately<br>                                    ↓<br>                Client receives and displays progressively</pre><p><strong>Key technical requirements:</strong></p><ul><li>Server-Sent Events (SSE) or WebSocket support</li><li>Chunked transfer encoding</li><li>Connection pooling management</li><li>Timeout handling for long-running connections</li></ul><p><strong>Example response format (SSE):</strong></p><pre>data: {&quot;token&quot;: &quot;Hello&quot;, &quot;index&quot;: 0}</pre><pre>data: {&quot;token&quot;: &quot; there&quot;, &quot;index&quot;: 1}</pre><pre>data: {&quot;token&quot;: &quot;!&quot;, &quot;index&quot;: 2}</pre><pre>data: {&quot;done&quot;: true}</pre><h3>Batch Implementation</h3><p>Simpler infrastructure — standard REST API patterns work perfectly.</p><p><strong>Backend architecture:</strong></p><pre>Client Request → API Gateway → LLM Service<br>                                    ↓<br>                    Waits for full completion<br>                                    ↓<br>                    Returns complete response<br>                                    ↓<br>                    Client receives and displays once</pre><p><strong>Key technical requirements:</strong></p><ul><li>Standard HTTP request-response</li><li>Request timeout configuration (typically 30–60s)</li><li>Response size limits</li><li>Error handling for timeouts</li></ul><h3>Performance Characteristics</h3><h3>Latency Breakdown</h3><p><strong>Streaming:</strong></p><ul><li>Time to first token (TTFT): 200–500ms</li><li>Time between tokens: 10–50ms</li><li>Total time: 3–10 seconds</li><li>User sees progress at: <strong>200–500ms</strong></li></ul><p><strong>Batch:</strong></p><ul><li>Processing time: 3–10 seconds</li><li>Network transfer: 100–300ms</li><li>User sees response at: <strong>3–10 seconds</strong></li></ul><blockquote><em>For a 500-word response taking 7 seconds total:</em></blockquote><ul><li><strong>Streaming:</strong> User engaged after 0.3 seconds</li><li><strong>Batch:</strong> User waiting 7 seconds</li></ul><h3>Throughput Considerations</h3><p><strong>Streaming impact on infrastructure:</strong></p><ul><li>Keeps connections open longer</li><li>Requires more concurrent connection capacity</li><li>Connection pooling becomes critical</li><li>Load balancer configuration matters</li></ul><p><strong>Batch impact:</strong></p><ul><li>Shorter connection times</li><li>Higher request turnover</li><li>Simpler load balancing</li><li>Easier to scale horizontally</li></ul><p><strong>Real numbers:</strong></p><ul><li>1000 streaming requests: Need ~500 concurrent connections</li><li>1000 batch requests: Need ~100 concurrent connections</li></ul><h3>Cost Implications</h3><p>Both approaches cost the same in LLM API fees, but infrastructure costs differ.</p><p><strong>Streaming costs:</strong></p><ul><li>Higher connection overhead</li><li>More load balancer capacity needed</li><li>WebSocket/SSE infrastructure</li><li>Monitoring more complex</li></ul><p><strong>Batch costs:</strong></p><ul><li>Lower connection overhead</li><li>Standard REST infrastructure</li><li>Simpler monitoring</li></ul><p>💰 <strong>Practical difference:</strong> At 1M requests/month, streaming might cost $200–500 more in infrastructure vs batch.</p><h3>Error Handling Complexity</h3><h3>Streaming Error Scenarios</h3><p>Streaming is harder to handle gracefully when errors occur.</p><p><strong>Mid-stream failures:</strong></p><p>User sees: <em>“The capital of France is Pa…”</em> then error.</p><p><strong>Options:</strong></p><ol><li>Display error message inline: “…Pa [Error: API timeout]”</li><li>Show error notification, keep partial response</li><li>Retry from beginning (poor UX)</li></ol><p><strong>Network interruptions:</strong></p><p>User’s connection drops mid-stream. Now you need:</p><ul><li>Client-side buffering</li><li>Resume capability</li><li>State synchronization</li></ul><p><strong>Partial response handling:</strong></p><p>What if the LLM generates incomplete code or cuts off mid-sentence?</p><ul><li>Detect incomplete responses</li><li>Mark as partial</li><li>Offer retry or continuation</li></ul><h3>Batch Error Scenarios</h3><p>Simpler to handle — either you get a response or you don’t.</p><ul><li><strong>API failure:</strong> Clear error state, user sees nothing was processed, clean retry.</li><li><strong>Timeout:</strong> Return timeout error, offer to retry with longer timeout or batch request.</li><li><strong>Invalid response:</strong> Validate complete response before showing, reject if malformed.</li></ul><h3>Use Case Guidelines</h3><h3>When to Use Streaming</h3><p><strong>Perfect for:</strong></p><ul><li>Chat interfaces (conversational AI)</li><li>Long-form content generation (articles, stories)</li><li>Real-time translation</li><li>Creative writing assistance</li><li>Customer support bots</li><li>Educational tutors</li></ul><p><strong>Why:</strong> User engagement matters more than having complete response immediately. Users can interrupt bad trajectories early.</p><h3>When to Use Batch</h3><p><strong>Perfect for:</strong></p><ul><li>Code generation (users want complete blocks)</li><li>Data analysis and reports (need full picture)</li><li>Document processing (complete results matter)</li><li>API responses consumed by other systems</li><li>Structured data generation (JSON, CSV)</li><li>Batch processing jobs</li></ul><p><strong>Why:</strong> Complete, validated responses are more important than progressive display. Often consumed programmatically, not by humans.</p><h3>Hybrid Approaches</h3><p>Many applications use both depending on context.</p><p><strong>Example: IDE assistant</strong></p><ul><li><strong>Inline suggestions:</strong> Batch (want complete code snippets)</li><li><strong>Chat explanations:</strong> Streaming (conversational)</li><li><strong>Documentation search:</strong> Batch (complete answers)</li></ul><p><strong>Example: Content platform</strong></p><ul><li><strong>Draft generation:</strong> Streaming (writers want to see progress)</li><li><strong>Final publication:</strong> Batch (needs complete validation)</li><li><strong>SEO optimization:</strong> Batch (algorithmic processing)</li></ul><h3>Implementation Patterns</h3><h3>Pattern 1: Progressive Enhancement</h3><p>Start with batch, add streaming as enhancement.</p><pre>if (supportsStreaming &amp;&amp; isInteractive) {<br>  return streamResponse();<br>} else {<br>  return batchResponse();<br>}</pre><p><strong>Benefits:</strong> Graceful degradation, simpler initial implementation, broader compatibility.</p><h3>Pattern 2: Smart Switching</h3><p>Dynamically choose based on response length and type.</p><pre>if (estimatedLength &gt; 200 words &amp;&amp; isChat) {<br>  return streamResponse();<br>} else {<br>  return batchResponse();<br>}</pre><p>Short responses load fast enough that streaming overhead isn’t worth it.</p><h3>Pattern 3: User Preference</h3><p>Let users choose their preference.</p><p>Many power users prefer batch for easier copying, while casual users prefer streaming for engagement. Provide a toggle in settings.</p><h3>Pattern 4: Context-Aware</h3><p>Different interfaces get different treatment.</p><pre>if (isMobileApp) {<br>  return streamResponse(); // Mobile users more sensitive to wait<br>} else if (isAPI) {<br>  return batchResponse(); // APIs prefer complete responses<br>} else {<br>  return streamResponse(); // Default to streaming for web<br>}</pre><h3>Advanced Streaming Techniques</h3><h3>Token Buffering</h3><p>Don’t send every single token — buffer a few for smoother display.</p><ul><li><strong>Without buffering:</strong> “H e l l o t h e r e” (jerky, 10 updates/second)</li><li><strong>With buffering:</strong> “Hello there” (smooth, 2–3 updates/second)</li></ul><p>Buffer 5–10 tokens or 100ms worth, whichever comes first.</p><h3>Smart Chunking</h3><p>Break responses at natural boundaries (sentences, paragraphs) rather than arbitrary token counts.</p><ul><li><strong>Bad:</strong> “The capital of France is Par|is. It’s known for…”</li><li><strong>Good:</strong> “The capital of France is Paris. | It’s known for…”</li></ul><h3>Optimistic UI Updates</h3><p>Show user input immediately, start streaming before API responds.</p><pre>User types → Display immediately → API call starts → Stream tokens</pre><p>Feels instant even with network latency.</p><h3>Parallel Streaming</h3><p>For multi-part responses, stream sections in parallel.</p><p>Example: Streaming a report with introduction, analysis, and conclusion sections simultaneously.</p><p><strong>Streaming chat application (100K daily users):</strong></p><ul><li>Average TTFT: 340ms</li><li>Average total time: 6.2s</li><li>User engagement: 92% read responses</li><li>Infrastructure cost: $1,200/month</li></ul><p><strong>Batch API service (100K daily requests):</strong></p><ul><li>Average latency: 5.8s</li><li>Timeout rate: 2%</li><li>Success rate: 98%</li><li>Infrastructure cost: $800/month</li></ul><p><strong>Hybrid content platform (50K users, mixed usage):</strong></p><ul><li>Streaming for 70% of requests</li><li>Batch for 30% of requests</li><li>Average perceived latency: 2.1s</li><li>Infrastructure cost: $1,000/month</li></ul><h3>The Bottom Line</h3><p>Choose <strong>streaming</strong> when human engagement and perceived responsiveness matter. Choose <strong>batch</strong> when you need complete, validated responses or when your consumer is another system.</p><p>For consumer-facing chat interfaces, streaming is almost always the right choice. For APIs, background jobs, and data processing, batch is simpler and sufficient.</p><p><strong>Don’t overthink it:</strong> start with batch if you’re building an API or analytical tool. Start with streaming if you’re building a conversational interface. You can always switch or hybridize later based on real user feedback.</p><blockquote><em>The best architecture is one that matches user expectations for your specific use case, not the one that’s technically most impressive.</em></blockquote><p><em>What’s your experience with streaming vs batch processing? Share your thoughts in the comments below!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5c1d266397f2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Choosing the Right Architecture: Hybrid Data Retrieval vs MCP Server with LLMs]]></title>
            <link>https://medium.com/@muhammaduzairse/choosing-the-right-architecture-hybrid-data-retrieval-vs-mcp-server-with-llms-ead33bb46b1e?source=rss-eb45f0aa40ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/ead33bb46b1e</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[api-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Muhammad Uzair]]></dc:creator>
            <pubDate>Wed, 08 Oct 2025 22:01:53 GMT</pubDate>
            <atom:updated>2025-10-08T22:10:26.556Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MN9QZsxBAzrLy_bJfQntbw.png" /></figure><p>In AI-powered applications, one critical decision is how to architect data retrieval systems. Should you build a multi-tiered hybrid approach with databases, APIs, and AI fallbacks? Or leverage the emerging Model Context Protocol (MCP) with Large Language Models? This article explores both approaches to help you decide.</p><h3>Understanding the Two Approaches</h3><h3>Approach 1: The Hybrid Multi-Tier System</h3><p>The hybrid approach uses a cascading three-tier system:</p><p><strong>Tier 1: Local Database (Elasticsearch/Vector Database)</strong> Your primary data source with optimized fast retrieval. Vector databases like Pinecone, Weaviate, or Elasticsearch enable semantic search, finding relevant information even without exact keyword matches.</p><p><strong>Tier 2: External APIs (RapidAPI)</strong> When local data lacks answers, query external APIs. RapidAPI provides access to thousands of services — weather, financial data, and more — without storing everything locally.</p><p><strong>Tier 3: AI Generation (LLM Fallback)</strong> Last resort: when neither database nor APIs help, use LLMs like GPT-4 or Claude to generate responses.</p><h4>Approach 2: MCP Server with LLM Integration</h4><p>MCP creates a unified interface where an LLM orchestrates all data access. The MCP server bridges your LLM and data sources, letting AI decide when to query databases versus generating responses. <strong>Every query uses your OpenAI API key</strong>, as the LLM acts as the intelligent coordinator for all operations.</p><p><strong>MCP Without Database:</strong> You can also use MCP without database integration, relying purely on LLM knowledge and external APIs. This offers the simplest setup but highest per-query costs.</p><h3>Hybrid Architecture Deep Dive</h3><h4>Key Components</h4><p><strong>Query Router:</strong> Analyzes queries and determines optimal tier using keyword matching, ML classifiers, or intent detection.</p><p><strong>Database Layer:</strong> Handles semantic searches with sub-second response times, scaling to millions of documents efficiently.</p><p><strong>API Layer:</strong> Manages external calls with rate limiting, caching, and fallback mechanisms.</p><p><strong>LLM Layer:</strong> Generates responses when data unavailable, with prompt engineering and cost tracking.</p><h3>Advantages</h3><p><strong>Cost Optimization:</strong> Database queries cost fractions of a cent; LLM calls cost several cents. For thousands of daily queries, this compounds into major savings.</p><p><strong>Performance:</strong> Database queries return in 50–200ms versus 3–8 seconds for LLM calls. Critical for user experience.</p><p><strong>Predictability:</strong> Deterministic logic at each tier. You control exactly what happens and can debug independently.</p><p><strong>Data Quality:</strong> Curated database ensures accuracy. External APIs provide verified data. Only uncertain queries use AI generation.</p><p><strong>Scalability:</strong> Each tier scales independently based on needs and budget.</p><h3>Challenges</h3><p><strong>Complexity:</strong> Three separate systems mean more code, multiple failure modes, and complex monitoring.</p><p><strong>Integration Overhead:</strong> Each tier needs custom code, error handling, and data normalization.</p><p><strong>Query Classification:</strong> Determining the right tier isn’t always straightforward. Misrouting can cascade through the system.</p><p><strong>Maintenance:</strong> Must maintain database schemas, API clients, LLM prompts, and caching strategies.</p><h3>MCP Architecture Deep Dive</h3><h4>What is MCP?</h4><p>MCP enables LLMs to interact with external data sources through a unified interface. You define “tools” the LLM can call instead of building custom integrations.</p><h4>Key Components</h4><p><strong>MCP Server:</strong> Middleware exposing data sources as tools — database queries, file access, API integration, and custom computations.</p><p><strong>LLM Orchestrator:</strong> Uses OpenAI’s function calling to receive queries, decide which tools to use, chain multiple calls, and synthesize results.</p><p><strong>Tool Definitions:</strong> JSON schemas describing available tools with names, descriptions, and parameters.</p><h4>How It Works</h4><p>User submits query → Sent to LLM (via your OpenAI API) with tool descriptions → LLM decides which tools to invoke → MCP server executes tools → Results sent back to LLM → LLM synthesizes natural language response.</p><h4>Advantages</h4><p><strong>Simplified Architecture:</strong> Single integration point with consistent error handling and reduced developer cognitive load.</p><p><strong>Intelligent Routing:</strong> LLM naturally understands intent — no separate classification logic needed. Handles ambiguous queries gracefully.</p><p><strong>Rapid Development:</strong> Add tools by writing simple functions. LLM handles orchestration automatically.</p><p><strong>Flexibility:</strong> Handles unexpected queries, chains multiple tool calls, and adapts to new data sources easily.</p><p><strong>Natural Experience:</strong> Context-aware conversational interactions with follow-up question capability.</p><h4>Challenges</h4><p><strong>Higher Costs:</strong> Every query involves LLM API calls — for understanding, tool selection, and synthesis. Can be 10–100x more expensive than direct queries.</p><p><strong>Increased Latency:</strong> LLM processing adds 3–8 seconds total versus sub-second database responses.</p><p><strong>Unpredictability:</strong> LLM behavior isn’t always consistent. Same query might use different tools. Debugging is challenging.</p><p><strong>Tool Selection Reliability:</strong> LLM might skip relevant sources or over-rely on generation.</p><p><strong>Context Limits:</strong> Large datasets can overflow context windows, requiring careful chunking.</p><h3>The Prompt Caching Reality</h3><p>OpenAI offers prompt caching to reduce costs by caching static prompt portions. However, <strong>this provides limited benefits when prompts change frequently</strong>:</p><p><strong>Why It Often Disappoints:</strong></p><ul><li>Only system instructions and tool definitions cache (not user queries)</li><li>Changing context invalidates cache</li><li>Dynamic applications see only 10–20% savings, not theoretical 50%</li><li>Requires 1,024+ token minimum to work</li></ul><p><strong>Better Alternatives:</strong></p><ul><li>Response caching for identical queries</li><li>Semantic caching using vector similarity</li><li>Smaller models (GPT-4-mini) for simple queries</li><li>Query batching when possible</li></ul><h3>Cost Comparison (1000 queries/day)</h3><p><strong>Hybrid Approach:</strong></p><ul><li>70% database ($0.001 each) = $0.70</li><li>20% APIs ($0.01 each) = $2.00</li><li>10% LLM ($0.05 each) = $5.00</li><li><strong>Total: $231/month</strong></li></ul><p><strong>MCP with Database:</strong></p><ul><li>100% through LLM ($0.08 each) = $80.00</li><li><strong>Total: $2,400/month</strong></li></ul><p><strong>MCP Without Database:</strong></p><ul><li>100% through LLM ($0.06 each) = $60.00</li><li><strong>Total: $1,800/month</strong></li></ul><p><strong>MCP with Prompt Caching:</strong></p><ul><li>20% reduction = $64.00/day</li><li><strong>Total: $1,920/month</strong></li></ul><p><strong>Hybrid is approximately 10x cheaper</strong>, even versus optimized MCP.</p><h3>Performance Comparison</h3><p><strong>Hybrid Average Response Time:</strong> ~500ms</p><ul><li>70% queries: 50–200ms (database)</li><li>20% queries: 200–800ms (API)</li><li>10% queries: 2–5s (LLM)</li></ul><p><strong>MCP Average Response Time:</strong> ~5s</p><ul><li>100% queries: 3–8s (LLM + tools)</li></ul><p><strong>Hybrid is approximately 10x faster</strong> on average.</p><h3>When to Choose Each Approach</h3><h3>Choose Hybrid When:</h3><ul><li>Cost is a primary concern (tight margins, high volume)</li><li>Performance is critical (user-facing apps)</li><li>Predictability required (financial, medical, legal)</li><li>80%+ queries satisfied by database lookups</li><li>High-traffic applications needing caching</li></ul><h3>Choose MCP When:</h3><ul><li>Development speed matters (startups, MVPs)</li><li>Queries are complex and varied</li><li>Natural language interaction is core</li><li>Data sources change frequently</li><li>Budget allows higher per-query costs</li><li>No proprietary database needed</li></ul><h3>Choose MCP Without Database When:</h3><ul><li>Minimal data needs</li><li>External APIs provide most information</li><li>Simplest architecture desired</li><li>Quick deployment over cost optimization</li></ul><h3>The Hybrid-MCP Approach</h3><p>Combine both strategies: use a query classifier to route by complexity. Simple queries hit database directly. Moderate queries use MCP with limited tools. Complex queries get full MCP capabilities.</p><p><strong>Benefits:</strong></p><ul><li>Cost optimization (cheap for simple, smart for complex)</li><li>Performance balance</li><li>Gradual migration path</li><li>Maximum flexibility</li></ul><h3>Implementation Recommendations</h3><p><strong>Start with Hybrid if:</strong> Existing database infrastructure, well-understood query patterns, cost/performance priorities, strong backend team.</p><p><strong>Start with MCP if:</strong> Building from scratch, evolving requirements, natural language core, AI-first team, no database needed.</p><p><strong>Implement Hybrid-MCP if:</strong> Need both efficiency and flexibility, mixed query complexity, sophisticated routing investment, long-term scalability focus.</p><h3>Conclusion</h3><p><strong>Choose Hybrid</strong> for cost-sensitive, high-performance applications with predictable patterns.</p><p><strong>Choose MCP</strong> for rapid development, complex queries, and conversational interfaces where speed matters more than cost.</p><p><strong>Choose Hybrid-MCP</strong> when you need both and have engineering resources for sophisticated routing.</p><p>The landscape evolves rapidly. MCP is emerging while hybrid is battle-tested. Start with what your team knows, then evolve as needs mature. The right architecture keeps you in business long enough to build the next one.</p><p><em>What architecture are you using? Share your experiences in the comments below.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ead33bb46b1e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot Test — Library Management API]]></title>
            <link>https://medium.com/@muhammaduzairse/spring-boot-test-library-management-api-2c65071ab1e9?source=rss-eb45f0aa40ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/2c65071ab1e9</guid>
            <category><![CDATA[java-spring-boot]]></category>
            <category><![CDATA[spring-boot-api]]></category>
            <dc:creator><![CDATA[Muhammad Uzair]]></dc:creator>
            <pubDate>Wed, 03 Sep 2025 07:06:31 GMT</pubDate>
            <atom:updated>2025-09-03T07:06:31.157Z</atom:updated>
            <content:encoded><![CDATA[<h3>Spring Boot Test — Library Management API</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DYWB0vDlJI03IXvunoal8Q.png" /></figure><p>In this comprehensive tutorial, we’ll explore how to solve a HackerRank-style problem by building REST APIs for a library management system using Spring Boot and JPA. This example demonstrates essential backend development skills that are commonly tested in technical assessments.</p><p>HackerRank frequently includes backend role assessments where candidates must design REST APIs and showcase their knowledge of API architecture, database integration, and Spring Boot fundamentals.</p><h3>Problem Statement</h3><p>Let’s imagine we need to create a library management system where we can manage book records. Here’s an example of a book data JSON object:</p><pre>{<br>  &quot;id&quot;: 1,<br>  &quot;title&quot;: &quot;The Great Gatsby&quot;,<br>  &quot;author&quot;: &quot;F. Scott Fitzgerald&quot;,<br>  &quot;isbn&quot;: &quot;978-0-7432-7356-5&quot;,<br>  &quot;category&quot;: &quot;fiction&quot;,<br>  &quot;availableCopies&quot;: 5,<br>  &quot;totalCopies&quot;: 5,<br>  &quot;publishedYear&quot;: 1925<br>}</pre><p>The REST service must expose the /books endpoint, which allows for managing the collection of book records in the following way:</p><p><strong>POST request to /books:</strong></p><ul><li>Creates a new book record</li><li>Expects a JSON book object without an id property as the body payload</li><li>Adds the given book object to the collection and assigns a unique integer id</li><li>The first created book must have id 1, the second one 2, and so on</li><li>Response code is 201, and the response body is the created book object</li></ul><p><strong>GET request to /books:</strong></p><ul><li>Returns a collection of all books</li><li>Response code is 200, and the response body is an array of all book objects ordered by their ids in increasing order</li><li>Optionally accepts query parameters category and author, for example /books/?category=fiction&amp;author=Shakespeare</li><li>All parameters are optional. When present, only objects matching the parameters are returned</li></ul><p><strong>GET request to /books/{id}:</strong></p><ul><li>Returns a book with the given id</li><li>If the matching book exists, response code is 200 and the response body is the matching book object</li><li>If there is no book with the given id, response code is 404</li></ul><p><strong>DELETE, PUT, PATCH request to /books/{id}:</strong></p><ul><li>Response code is 405 because the API does not allow deleting or modifying books for any id value</li></ul><h3>Prerequisites</h3><ol><li>Set up Spring Boot starter app using <a href="https://start.spring.io/">https://start.spring.io/</a></li><li>Download and set up a database or use H2 DB (no extra configuration needed)</li><li>Install your preferred IDE (Eclipse, IntelliJ IDEA, VS Code)</li></ol><h3>Designing the Schema</h3><p>For the given JSON structure, let’s create a table or entity in Spring Boot. Entities in Spring Boot are class representations of database tables.</p><pre>@Entity<br>@Table(name = &quot;books&quot;)<br>public class Book {</pre><pre>    @Id<br>    @GeneratedValue(strategy = GenerationType.IDENTITY)<br>    private Integer id;<br>    <br>    @Column(nullable = false)<br>    private String title;<br>    <br>    @Column(nullable = false)<br>    private String author;<br>    <br>    @Column(unique = true)<br>    private String isbn;<br>    <br>    private String category;<br>    <br>    @Column(name = &quot;available_copies&quot;)<br>    private Integer availableCopies;<br>    <br>    @Column(name = &quot;total_copies&quot;)<br>    private Integer totalCopies;<br>    <br>    @Column(name = &quot;published_year&quot;)<br>    private Integer publishedYear;</pre><pre>    public Book() {}</pre><pre>    // Constructors, getters, and setters<br>    public Book(String title, String author, String isbn, String category, <br>                Integer availableCopies, Integer totalCopies, Integer publishedYear) {<br>        this.title = title;<br>        this.author = author;<br>        this.isbn = isbn;<br>        this.category = category;<br>        this.availableCopies = availableCopies;<br>        this.totalCopies = totalCopies;<br>        this.publishedYear = publishedYear;<br>    }</pre><pre>    // Getters and Setters<br>    public Integer getId() { return id; }<br>    public void setId(Integer id) { this.id = id; }<br>    <br>    public String getTitle() { return title; }<br>    public void setTitle(String title) { this.title = title; }<br>    <br>    public String getAuthor() { return author; }<br>    public void setAuthor(String author) { this.author = author; }<br>    <br>    public String getIsbn() { return isbn; }<br>    public void setIsbn(String isbn) { this.isbn = isbn; }<br>    <br>    public String getCategory() { return category; }<br>    public void setCategory(String category) { this.category = category; }<br>    <br>    public Integer getAvailableCopies() { return availableCopies; }<br>    public void setAvailableCopies(Integer availableCopies) { this.availableCopies = availableCopies; }<br>    <br>    public Integer getTotalCopies() { return totalCopies; }<br>    public void setTotalCopies(Integer totalCopies) { this.totalCopies = totalCopies; }<br>    <br>    public Integer getPublishedYear() { return publishedYear; }<br>    public void setPublishedYear(Integer publishedYear) { this.publishedYear = publishedYear; }<br>}</pre><p>Next, I’ll create a JPA Repository corresponding to this table to retrieve rows from the database:</p><pre>@Repository<br>public interface BookRepository extends JpaRepository&lt;Book, Integer&gt; {<br>    List&lt;Book&gt; findByCategory(String category);<br>    List&lt;Book&gt; findByAuthor(String author);<br>    List&lt;Book&gt; findByCategoryAndAuthor(String category, String author);<br>}</pre><h3>Service Layer</h3><p>Now I’ll create a Service class responsible for accessing the database and handling business logic:</p><pre>package com.library.management.service;</pre><pre>import java.util.List;<br>import java.util.Optional;<br>import java.util.stream.Collectors;</pre><pre>import org.modelmapper.ModelMapper;<br>import org.springframework.beans.factory.annotation.Autowired;<br>import org.springframework.stereotype.Service;</pre><pre>import com.library.management.dto.BookDTO;<br>import com.library.management.model.Book;<br>import com.library.management.repository.BookRepository;</pre><pre>@Service<br>public class BookService {</pre><pre>    @Autowired<br>    private BookRepository bookRepository;</pre><pre>    private static final ModelMapper modelMapper = new ModelMapper();</pre><pre>    public BookDTO createNewBook(BookDTO bookDto) {<br>        bookDto.setId(null); // Ensure ID is null for new records<br>        <br>        Book bookEntity = modelMapper.map(bookDto, Book.class);<br>        bookEntity = bookRepository.save(bookEntity);<br>        <br>        return modelMapper.map(bookEntity, BookDTO.class);<br>    }</pre><pre>    public List&lt;BookDTO&gt; getAllBooks() {<br>        List&lt;Book&gt; books = bookRepository.findAll();<br>        return books.stream()<br>                   .map(book -&gt; modelMapper.map(book, BookDTO.class))<br>                   .collect(Collectors.toList());<br>    }</pre><pre>    public List&lt;BookDTO&gt; filterBooks(String category, String author) {<br>        List&lt;Book&gt; books;</pre><pre>        if (category != null &amp;&amp; author != null) {<br>            books = bookRepository.findByCategoryAndAuthor(category, author);<br>        } else if (category != null) {<br>            books = bookRepository.findByCategory(category);<br>        } else if (author != null) {<br>            books = bookRepository.findByAuthor(author);<br>        } else {<br>            books = bookRepository.findAll();<br>        }</pre><pre>        return books.stream()<br>                   .map(book -&gt; modelMapper.map(book, BookDTO.class))<br>                   .collect(Collectors.toList());<br>    }</pre><pre>    public BookDTO getBookById(Integer id) {<br>        Optional&lt;Book&gt; bookOptional = bookRepository.findById(id);<br>        <br>        if (bookOptional.isPresent()) {<br>            return modelMapper.map(bookOptional.get(), BookDTO.class);<br>        }<br>        return null;<br>    }</pre><pre>    public boolean bookExists(Integer id) {<br>        return bookRepository.existsById(id);<br>    }<br>}</pre><p>The Service class includes these key methods:</p><ol><li>createNewBook(BookDTO bookDto) - Creates a new book record</li><li>getAllBooks() - Retrieves all books</li><li>filterBooks(String category, String author) - Filters books by category and/or author</li><li>getBookById(Integer id) - Retrieves a specific book by ID</li></ol><h3>Data Transfer Object (DTO)</h3><p>Let’s create a DTO class to handle data transfer between layers:</p><pre>package com.library.management.dto;</pre><pre>public class BookDTO {<br>    private Integer id;<br>    private String title;<br>    private String author;<br>    private String isbn;<br>    private String category;<br>    private Integer availableCopies;<br>    private Integer totalCopies;<br>    private Integer publishedYear;</pre><pre>    public BookDTO() {}</pre><pre>    // Getters and Setters<br>    public Integer getId() { return id; }<br>    public void setId(Integer id) { this.id = id; }<br>    <br>    public String getTitle() { return title; }<br>    public void setTitle(String title) { this.title = title; }<br>    <br>    public String getAuthor() { return author; }<br>    public void setAuthor(String author) { this.author = author; }<br>    <br>    public String getIsbn() { return isbn; }<br>    public void setIsbn(String isbn) { this.isbn = isbn; }<br>    <br>    public String getCategory() { return category; }<br>    public void setCategory(String category) { this.category = category; }<br>    <br>    public Integer getAvailableCopies() { return availableCopies; }<br>    public void setAvailableCopies(Integer availableCopies) { this.availableCopies = availableCopies; }<br>    <br>    public Integer getTotalCopies() { return totalCopies; }<br>    public void setTotalCopies(Integer totalCopies) { this.totalCopies = totalCopies; }<br>    <br>    public Integer getPublishedYear() { return publishedYear; }<br>    public void setPublishedYear(Integer publishedYear) { this.publishedYear = publishedYear; }<br>}</pre><h3>Controller Layer</h3><p>Let’s expose these service methods through a REST controller:</p><pre>package com.library.management.controller;</pre><pre>import java.util.List;</pre><pre>import org.springframework.beans.factory.annotation.Autowired;<br>import org.springframework.http.HttpStatus;<br>import org.springframework.http.ResponseEntity;<br>import org.springframework.web.bind.annotation.*;</pre><pre>import com.library.management.dto.BookDTO;<br>import com.library.management.service.BookService;</pre><pre>@RestController<br>@RequestMapping(path = &quot;/books&quot;)<br>public class BookController {<br>    <br>    @Autowired<br>    private BookService bookService;</pre><pre>    @PostMapping<br>    public ResponseEntity&lt;BookDTO&gt; createBook(@RequestBody BookDTO bookDto) {<br>        BookDTO createdBook = bookService.createNewBook(bookDto);<br>        return new ResponseEntity&lt;&gt;(createdBook, HttpStatus.CREATED);<br>    }</pre><pre>    @GetMapping<br>    public ResponseEntity&lt;List&lt;BookDTO&gt;&gt; getAllBooks(<br>            @RequestParam(required = false) String category,<br>            @RequestParam(required = false) String author) {<br>        <br>        List&lt;BookDTO&gt; books;<br>        <br>        if (category != null || author != null) {<br>            books = bookService.filterBooks(category, author);<br>        } else {<br>            books = bookService.getAllBooks();<br>        }<br>        <br>        return ResponseEntity.ok(books);<br>    }</pre><pre>    @GetMapping(&quot;/{id}&quot;)<br>    public ResponseEntity&lt;BookDTO&gt; getBookById(@PathVariable Integer id) {<br>        BookDTO book = bookService.getBookById(id);<br>        <br>        if (book != null) {<br>            return new ResponseEntity&lt;&gt;(book, HttpStatus.OK);<br>        } else {<br>            return new ResponseEntity&lt;&gt;(HttpStatus.NOT_FOUND);<br>        }<br>    }</pre><pre>    @DeleteMapping(&quot;/{id}&quot;)<br>    public ResponseEntity&lt;Void&gt; deleteBook(@PathVariable Integer id) {<br>        return new ResponseEntity&lt;&gt;(HttpStatus.METHOD_NOT_ALLOWED);<br>    }</pre><pre>    @PutMapping(&quot;/{id}&quot;)<br>    public ResponseEntity&lt;Void&gt; updateBook(@PathVariable Integer id) {<br>        return new ResponseEntity&lt;&gt;(HttpStatus.METHOD_NOT_ALLOWED);<br>    }</pre><pre>    @PatchMapping(&quot;/{id}&quot;)<br>    public ResponseEntity&lt;Void&gt; patchBook(@PathVariable Integer id) {<br>        return new ResponseEntity&lt;&gt;(HttpStatus.METHOD_NOT_ALLOWED);<br>    }<br>}</pre><h3>Maven Dependencies (pom.xml)</h3><p>Here are the essential dependencies needed for this project:</p><pre>&lt;dependencies&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>        &lt;artifactId&gt;spring-boot-starter-web&lt;/artifactId&gt;<br>    &lt;/dependency&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>        &lt;artifactId&gt;spring-boot-starter-data-jpa&lt;/artifactId&gt;<br>    &lt;/dependency&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>        &lt;artifactId&gt;spring-boot-starter-test&lt;/artifactId&gt;<br>        &lt;scope&gt;test&lt;/scope&gt;<br>    &lt;/dependency&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;com.h2database&lt;/groupId&gt;<br>        &lt;artifactId&gt;h2&lt;/artifactId&gt;<br>        &lt;scope&gt;runtime&lt;/scope&gt;<br>    &lt;/dependency&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;org.modelmapper&lt;/groupId&gt;<br>        &lt;artifactId&gt;modelmapper&lt;/artifactId&gt;<br>        &lt;version&gt;3.1.1&lt;/version&gt;<br>    &lt;/dependency&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>        &lt;artifactId&gt;spring-boot-starter-validation&lt;/artifactId&gt;<br>    &lt;/dependency&gt;<br>&lt;/dependencies&gt;</pre><h3>Application Configuration (application.properties)</h3><p>Configure your database and server settings:</p><pre>server.port=8080<br>server.address=0.0.0.0</pre><pre># H2 Database configuration<br>spring.datasource.url=jdbc:h2:mem:librarydb<br>spring.datasource.driverClassName=org.h2.Driver<br>spring.datasource.username=sa<br>spring.datasource.password=</pre><pre># JPA/Hibernate properties<br>spring.jpa.database-platform=org.hibernate.dialect.H2Dialect<br>spring.jpa.hibernate.ddl-auto=create-drop<br>spring.jpa.show-sql=true<br>spring.h2.console.enabled=true</pre><h3>Testing the API</h3><p>Once your application is running, you can test the endpoints:</p><p><strong>Create a book (POST /books):</strong></p><pre>curl -X POST http://localhost:8080/books \<br>  -H &quot;Content-Type: application/json&quot; \<br>  -d &#39;{<br>    &quot;title&quot;: &quot;To Kill a Mockingbird&quot;,<br>    &quot;author&quot;: &quot;Harper Lee&quot;,<br>    &quot;isbn&quot;: &quot;978-0-06-112008-4&quot;,<br>    &quot;category&quot;: &quot;fiction&quot;,<br>    &quot;availableCopies&quot;: 3,<br>    &quot;totalCopies&quot;: 3,<br>    &quot;publishedYear&quot;: 1960<br>  }&#39;</pre><p><strong>Get all books (GET /books):</strong></p><pre>curl http://localhost:8080/books</pre><p><strong>Filter by category (GET /books?category=fiction):</strong></p><pre>curl &quot;http://localhost:8080/books?category=fiction&quot;</pre><p><strong>Get book by ID (GET /books/1):</strong></p><pre>curl http://localhost:8080/books/1</pre><h3>Key Features Implemented</h3><ol><li><strong>Complete CRUD Operations</strong>: Create and Read operations with proper HTTP status codes</li><li><strong>Query Parameter Filtering</strong>: Support for filtering by category and author</li><li><strong>Proper Error Handling</strong>: Returns 404 for non-existent resources and 405 for unsupported operations</li><li><strong>Database Integration</strong>: Uses JPA with H2 database for persistence</li><li><strong>Clean Architecture</strong>: Separated concerns with Entity, DTO, Repository, Service, and Controller layers</li><li><strong>Model Mapping</strong>: Uses ModelMapper for converting between entities and DTOs</li></ol><p>This implementation demonstrates essential Spring Boot concepts that are frequently tested in backend assessments. The modular design makes it easy to extend with additional features like validation, pagination, and more complex filtering options.</p><h3>Conclusion</h3><p>This library management API showcases the fundamental patterns and practices needed for building robust REST APIs with Spring Boot. The clear separation of concerns, proper use of HTTP status codes, and comprehensive endpoint coverage make this an excellent example for technical interviews and assessments.</p><p>The solution demonstrates proficiency in Spring Boot, JPA, REST API design, and database integration — all crucial skills for backend development roles.</p><p><em>Follow me for more Spring Boot tutorials and backend development insights!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2c65071ab1e9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scaling Systems: Strategies for Building Robust Architectures]]></title>
            <link>https://medium.com/@muhammaduzairse/scaling-systems-strategies-for-building-robust-architectures-6eb91b69a010?source=rss-eb45f0aa40ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/6eb91b69a010</guid>
            <category><![CDATA[system-scalability]]></category>
            <category><![CDATA[system-maintainability]]></category>
            <category><![CDATA[robust-architectures]]></category>
            <category><![CDATA[scaling-strategies]]></category>
            <dc:creator><![CDATA[Muhammad Uzair]]></dc:creator>
            <pubDate>Mon, 15 Jul 2024 06:10:12 GMT</pubDate>
            <atom:updated>2024-07-15T06:10:12.647Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UGNybRv5Txmuwhnc8kKuKQ.jpeg" /></figure><h4>1. Understanding Web Architecture</h4><p>Before scaling our system, it’s crucial to grasp the data flow to evaluate scalability effectively.</p><p>A web application operates like a two-part system. On one end, backend languages (like Java, Python) manage data and business logic. On the other, HTML and JavaScript create interactive, user-friendly interfaces.</p><p>As user demand grows, a single server isn’t sufficient. Multiple servers become necessary: one for handling web/mobile traffic and another for managing the database. This division allows each part to be scaled independently as needed.</p><p>Users navigate websites by entering distinct domains like freshsurf.com. The Domain Name System (DNS), typically provided by external services, translates this domain into an Internet Protocol (IP) address. With the IP address, browsers or apps send Hypertext Transfer Protocol (HTTP) requests to your web server, which then responds with HTML pages or JSON data for rendering.</p><h4>2. Database Management</h4><p><strong>2.1 Relational Databases:</strong> Relational databases like PostgreSQL or MySQL are preferred for their reliability. They organize data into tables and support SQL operations, making them ideal for structured data.</p><p><strong>2.2 Non-Relational Databases:</strong> When dealing with vast amounts of unstructured data, non-relational databases like MongoDB, DynamoDB, Cassandra, or Redis are beneficial. They excel in scenarios requiring low latency and high scalability.</p><h4>3. Server Scaling</h4><p><strong>3.1 User Requests:</strong> User interactions, such as clicks or form submissions, send requests to a server, which processes them and prepares responses.</p><p><strong>3.2 The Server:</strong> A server is a robust computer that stores data, processes requests, and sends responses, ensuring smooth operation.</p><p><strong>3.3 Need for Server Scaling:</strong></p><ul><li><strong>Multiple Requests:</strong> Scaling helps distribute the workload among multiple servers, ensuring quick response times.</li><li><strong>Handling Peaks:</strong> During high-traffic events, server scaling prevents slowdowns or crashes.</li><li><strong>Future-Proofing:</strong> Scaling prepares applications for growth without compromising performance.</li></ul><p><strong>3.4 Types of Server Scaling:</strong></p><ul><li><strong>Vertical Scaling:</strong> Enhancing the capacity of existing servers by upgrading CPU, RAM, or storage.</li><li><strong>Horizontal Scaling:</strong> Adding more servers to distribute the load, increasing capacity, redundancy, and fault tolerance.</li></ul><h4>4. Load Balancer</h4><p>A load balancer acts as a traffic manager for web servers, distributing incoming requests to ensure smooth operation.</p><p><strong>4.1 Communication Data-Flow:</strong></p><ul><li><strong>Public IP Address:</strong> Used by external users to access the web application.</li><li><strong>Private IP Address:</strong> Assigned to internal web servers for efficient load distribution.</li></ul><h4>5. Database Replication</h4><p>Database replication involves creating and maintaining duplicate copies of a database to ensure data consistency and availability.</p><p><strong>5.1 How Database Replication Works:</strong></p><ul><li><strong>Setup Multiple Copies:</strong> Start with a master database and create replicas.</li><li><strong>Continuous Updates:</strong> Changes in the master database are copied to replicas.</li><li><strong>Read and Write Distribution:</strong> Read operations are distributed among replicas, while write operations go to the master.</li><li><strong>Synchronization:</strong> Regular updates ensure all databases have current information.</li></ul><p><strong>Common Strategies:</strong></p><ul><li><strong>Master-Slave Replication:</strong> Master handles write operations, while slaves handle read operations.</li></ul><h4>6. <strong>Using Cache</strong></h4><p>Caches store frequently accessed data to speed up retrieval.</p><p><strong>6.1 Client/Browser-Side Caching:</strong></p><ul><li><strong>Browser Cache:</strong> Stores web page resources locally for faster subsequent visits.</li><li><strong>Local and Session Storage:</strong> Saves data on the device for persistent or session-limited storage.</li></ul><p><strong>6.2 Data Flow (Client-Side Cache):</strong> The browser checks its cache before requesting resources from the server, speeding up page loading.</p><p><strong>6.3 Server-Side Caching:</strong></p><ul><li><strong>Content Delivery Network (CDN) Caching:</strong> Distributes content globally to reduce latency.</li><li><strong>Database Query Result Caching:</strong> Stores results of frequent queries to improve performance.</li><li><strong>Object Caching:</strong> Uses in-memory caching systems like Redis or Memcached.</li></ul><p><strong>6.4 Data Flow (Server-Side Caching):</strong> CDNs and query result caches optimize performance by delivering cached content from the nearest server and reducing database load.</p><h4>7. Message Queue</h4><p>A message queue manages communication between services, ensuring reliable and asynchronous data transfer.</p><p><strong>7.1 What is a Message Queue?</strong> It allows services to communicate asynchronously, with messages stored in memory for quick access.</p><p><strong>7.2 Architecture:</strong></p><ul><li><strong>Producers:</strong> Generate messages and publish them to the queue.</li><li><strong>Consumers:</strong> Fetch and process messages from the queue.</li></ul><p><strong>7.3 Real-Life Data Flow:</strong></p><p>In an e-commerce platform, message queues play a crucial role in managing communication between different parts of the system. When a customer places an order on the website, the web server doesn’t handle all the steps needed to fulfill the order directly. Instead, it sends the order details to a message queue.</p><p>The message queue acts like a middleman, temporarily holding the order information. This allows the web server to quickly move on to handling other customer requests, ensuring the website remains fast and responsive.</p><p>Meanwhile, the backend processes, such as inventory management and order fulfillment, can retrieve the order details from the message queue at their own pace. This decoupling ensures that even if the backend processes are busy or experience delays, the web server isn’t held up, and customer experience remains smooth.</p><p>This approach enhances the reliability and efficiency of the communication between the web server and the backend processes, making sure that orders are processed correctly without slowing down the system.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6eb91b69a010" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>