<?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 Ingila  on Medium]]></title>
        <description><![CDATA[Stories by Ingila  on Medium]]></description>
        <link>https://medium.com/@ingila185?source=rss-bf13c92cf145------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*JsFFy381Pc82eoLOHVlXnA.jpeg</url>
            <title>Stories by Ingila  on Medium</title>
            <link>https://medium.com/@ingila185?source=rss-bf13c92cf145------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 22:20:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ingila185/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[NVIDIA GPU Servers Explained: DGX vs HGX vs PCIe vs MGX (And Which One Your Enterprise Actually…]]></title>
            <link>https://medium.com/@ingila185/nvidia-gpu-servers-explained-dgx-vs-hgx-vs-pcie-vs-mgx-and-which-one-your-enterprise-actually-3d74c7f7f736?source=rss-bf13c92cf145------2</link>
            <guid isPermaLink="false">https://medium.com/p/3d74c7f7f736</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Ingila ]]></dc:creator>
            <pubDate>Thu, 23 Jul 2026 19:20:57 GMT</pubDate>
            <atom:updated>2026-07-23T19:26:43.708Z</atom:updated>
            <content:encoded><![CDATA[<h3>NVIDIA GPU Servers Explained: DGX vs HGX vs PCIe vs MGX (And Which One Your Enterprise Actually Needs)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9BfLJBFPRDWYsodlITDzUg.png" /><figcaption>NVDIA AI</figcaption></figure><p>If your organization is planning any kind of AI initiative in 2026 — training models, running inference at scale, or standing up an internal AI platform — you will eventually hit the same question every enterprise hits: <strong>which GPU server do we actually buy?</strong></p><p>It sounds like a hardware question. It isn’t. It’s a business decision disguised as one, and getting it wrong is expensive in a way that doesn’t show up until months later — in cloud bills that don’t match the performance you expected, in infrastructure that doesn’t scale the way your roadmap assumed, or in a data center team quietly overwhelmed by a system nobody scoped properly.</p><p>I’m currently working through NVIDIA’s AI Infrastructure and Operations certification, and one thing has become clear: most of the confusion around “AI infrastructure” isn’t really about AI. It’s about a handful of concrete hardware decisions that most technical teams — and even more business stakeholders — have never had explained to them plainly. This article is that explanation.</p><h3>Why GPU Servers Became a Boardroom Decision, Not Just an IT One</h3><p>A few years ago, “we need more compute” meant adding a few servers to a rack. Today, it means evaluating a GPU server ecosystem that includes NVIDIA, Cisco, Dell, HPE, IBM, Lenovo, and every major cloud provider — each offering multiple form factors, each with different assumptions about your scale, your budget, and your team’s technical maturity.</p><p>That shift happened for a structural reason: <strong>CPUs simply cannot keep up with modern AI workloads.</strong> State-of-the-art AI models have grown by roughly three orders of magnitude in just the last few years, and that growth trajectory shows no sign of slowing. The compute required to train and run these models is only achievable through GPU-based accelerated computing — a full-stack combination of specialized hardware, software, and frameworks working together, not a single chip upgrade.</p><p>This is also, increasingly, a <strong>power and planning problem, not just a technical one.</strong> Data centers now account for a meaningful share of global energy usage, and that figure is projected to keep climbing. Data centers are power-constrained, and they take years to plan and build. Which means the GPU server decision you make this year is one your organization will be living with — and optimizing around — for years afterward.</p><p>That’s the real stakes of this decision. Here’s what you’re actually choosing between.</p><h3>The Four GPU Server Form Factors, Explained for Decision-Makers</h3><h3>1. NVIDIA DGX H100</h3><p>The DGX H100 is a fully integrated hardware and software solution, designed for organizations that want to stand up serious AI capability without building a large in-house infrastructure team from scratch.</p><p><strong>Best fit for:</strong> Enterprises early in their AI infrastructure journey, or those who want a turnkey foundation for an “AI center of excellence” rather than assembling one piece by piece.</p><h3>2. NVIDIA HGX H100</h3><p>The HGX H100 combines H100 Tensor Core GPUs with high-speed interconnects to form some of the most powerful servers available today. This is the form factor for organizations where AI isn’t a side initiative — it’s core to the product or business model.</p><p><strong>Best fit for:</strong> Companies running AI workloads at real production scale, where raw performance and interconnect speed directly affect the business’s ability to compete.</p><h3>3. NVIDIA H100 PCIe</h3><p>The H100 PCIe card offers the largest PCIe card memory bandwidth available — over 2,000 GB per second — while remaining a form factor that slots into existing data center infrastructure rather than requiring a full rebuild.</p><p><strong>Best fit for:</strong> Enterprises with existing data center investments who want a meaningful performance upgrade without a wholesale infrastructure overhaul.</p><h3>4. NVIDIA MGX</h3><p>MGX is a modular reference design built for a wide range of use cases, from remote visualization to supercomputing at the edge. It’s designed specifically to improve ROI and reduce time to market by letting infrastructure evolve as needs change.</p><p><strong>Best fit for:</strong> Organizations that know they need to scale AI capability but aren’t yet certain what “final scale” looks like — MGX is the option that protects you from over-committing early.</p><h3>It’s Not Just NVIDIA — This Is Now Standard Enterprise Infrastructure</h3><p>One thing worth correcting: GPU-based AI infrastructure is not a niche NVIDIA product line anymore. Nearly every major data center server vendor — Cisco, Dell, HPE, IBM, Lenovo, and others — now offers GPU-based AI systems, typically supporting between 2 and 16 GPUs per server, interconnected to form larger parallel processing systems. Every major cloud provider has also adopted NVIDIA GPUs, extending accelerated computing into the cloud for organizations that don’t want to own hardware at all.</p><p>This matters for decision-makers because it means the real choice isn’t “NVIDIA or not.” It’s: <strong>on-prem or cloud, which form factor, and at what scale</strong> — and those three decisions interact with each other more than most procurement processes account for.</p><h3>Where GPU Servers Actually Get Used (Beyond AI Training)</h3><p>A common misconception is that GPU servers exist purely for training large AI models. In practice, the workloads span a much wider range:</p><ul><li><strong>Compute-intensive workloads</strong> — AI training and inference, data analytics, and High Performance Computing (HPC)</li><li><strong>General-purpose workloads</strong> — visualization, rendering, virtual workstations, and deep learning</li><li><strong>High-density virtualization</strong> — virtual desktop infrastructure and workstation consolidation</li><li><strong>Enterprise and industrial edge deployments</strong> — controlled environments and rugged industrial settings</li><li><strong>Desktop and mobile workstations</strong> — supporting design, content creation, and data science work</li></ul><p>If your organization is doing any of the above, you’re already a GPU server buyer — whether or not “AI strategy” has been the label attached to that spending.</p><h3>The Real Cost of Getting This Decision Wrong</h3><p>Here’s the pattern I see most often when working with enterprises on infrastructure decisions: the GPU server purchase gets made based on benchmarks and specs, without a clear read on how the organization’s actual workloads will use that hardware over the next 24–36 months.</p><p>The result isn’t usually “the wrong hardware.” It’s <strong>the right hardware, architected wrong</strong> — paying premium GPU prices for infrastructure that’s quietly underutilized, or hitting a scaling wall sooner than expected because the form factor didn’t leave room to grow.</p><p>This is exactly why the DGX/HGX/PCIe/MGX decision deserves more scrutiny than it typically gets. It’s not a hardware spec sheet exercise. It’s a multi-year infrastructure bet.</p><h3>Where to Go From Here</h3><p>If you’re evaluating GPU infrastructure for your organization right now, the questions worth answering before you talk to any vendor are:</p><ol><li>Is AI a core function of your business, or a supporting capability?</li><li>Do you have an internal infrastructure team, or do you need something closer to turnkey?</li><li>Are you building on existing data center investment, or starting fresh?</li><li>How confident are you in your scale projections 24 months out?</li></ol><p>The answers to those four questions point toward a form factor far more reliably than a benchmark comparison chart does.</p><p><em>I’m an AI-first software engineer with 12+ years building production systems in FinTech and enterprise SaaS, currently completing NVIDIA’s AI Infrastructure and Operations certification. I work with enterprises evaluating AI infrastructure decisions before they become expensive to undo. If you’re navigating this decision for your organization, I’d be glad to talk it through. Reach me out on </em><a href="https://www.linkedin.com/in/ingila-ejaz/">https://www.linkedin.com/in/ingila-ejaz/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d74c7f7f736" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unlocking True Vertical Scalability in .NET: Slashing API Latency from 10s to 3s on Azure AKS]]></title>
            <link>https://medium.com/@ingila185/unlocking-true-vertical-scalability-in-net-slashing-api-latency-from-10s-to-3s-on-azure-aks-e4581efb7820?source=rss-bf13c92cf145------2</link>
            <guid isPermaLink="false">https://medium.com/p/e4581efb7820</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Ingila ]]></dc:creator>
            <pubDate>Sat, 18 Jul 2026 14:03:57 GMT</pubDate>
            <atom:updated>2026-07-18T14:14:07.583Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L9PbNA1rdBBjqSuRgggZcg.png" /><figcaption>Real-world demonstration of NUMA Contention</figcaption></figure><p>As backend engineers, we are often taught that the ultimate solution for handling increased load is to “throw more hardware at the problem.” But what happens when upgrading your cloud infrastructure actually makes your application <em>slower</em>?</p><p>I recently tackled a high-throughput C# data-processing API deployed on Azure Kubernetes Service (AKS) that had hit a hard performance ceiling. It was averaging a 10-second response time under peak load. When I tried to vertically scale the AKS pods by giving them more compute, performance actually degraded.</p><p>Instead of moving faster, the system suffered from deep resource contention. Under high-core environments, the application spent more time managing CPU thread context switches and fighting over shared synchronous locks than executing actual business logic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8hwiffZ27cdwj-fKCnvIkA.png" /><figcaption>Mission Critical System Halting with increased resources</figcaption></figure><p>With the help of .NET concurrency optimizations, I was able to fix this issue -ultimately dropping response times from <strong>10 seconds down to a highly responsive 3 seconds</strong> (a 70% optimization).</p><p>Here is a look behind the scenes at how I diagnosed the problem, re-architected the pipeline, and discovered a fascinating new scaling boundary along the way.</p><h3>AI-Driven Profiling &amp; Benchmarking</h3><p>Rather than guessing where the bottlenecks lay, I built a highly intentional, data-driven diagnostic workflow:</p><ol><li><strong>BenchmarkDotNet:</strong> I isolated the core execution paths using the standard .NET Benchmark library to establish a precise, repeatable performance baseline.</li><li><strong>GitHub Copilot @profiler:</strong> I used the @profiler agent to investigate the application&#39;s runtime behavior. The agent generated a comprehensive profiling report that immediately highlighted the lowest-risk, highest-gain improvements — specifically pinpointing severe thread pool starvation and intense lock contention on synchronous critical paths.</li></ol><h3>Agentic Coding with Cursor and Grok 4.5</h3><p>To safely refactor the core execution pipeline without introducing structural regressions, I collaborated with <strong>Cursor’s Plan Mode powered by Grok 4.5</strong>. Read more about how Grok 4.5 makes my development easier <a href="https://www.linkedin.com/pulse/balancing-chaos-why-cursors-grok-45-ultimate-complex-workflows-ejaz-bepmf">here</a>.</p><p>It allowed me to aggressively cross-question the AI’s proposed designs. Together, we simulated concurrent edge cases, evaluated lock-free alternatives, and verified that the new execution model would scale predictably under heavy multi-core environments.</p><h3>Parallelism in C#</h3><p>With the benchmrks in place, I completely re-engineered the data-processing algorithm:</p><ul><li><strong>Transition to TPL Dataflow:</strong> I migrated shared mutable states to the Task Parallel Library (TPL), utilizing components like ActionBlock and TransformBlock to pass immutable messages through separate execution stages without blocking locks.</li><li><strong>Dynamic Concurrency Control:</strong> I enforced fine-grained parallelism dynamically tied to the container environment, ensuring the application could safely expand its thread usage based on the allocated AKS compute envelope:</li></ul><pre>var processingBlock = new ActionBlock&lt;DataPayload&gt;(<br>    async payload =&gt; await ProcessDataAsync(payload),<br>    new ExecutionDataflowBlockOptions<br>    {<br>        // Dynamically scales based on the allocated AKS core count<br>        MaxDegreeOfParallelism = Environment.ProcessorCount * 2 <br>    });</pre><p>When I deployed the optimized microservice back to Azure AKS and monitored it, I observed a highly interesting scaling curve:</p><ul><li><strong>Baseline Resources (8,000 mcores):</strong> The new version initially took <strong>12 seconds</strong> (a slight increase from 10s due to the foundational architectural overhead of asynchronous orchestration). Initially, it looked like a loss.</li><li><strong>Vertically Scaled Resources (16,000 mcores):</strong> The moment I doubled the compute envelope, the architecture shined. Response times plummeted smoothly to <strong>3 seconds or less</strong>. The system was finally scaling vertically!</li><li><strong>Excessive Resources (24,000 to 32,000 mcores):</strong> Curiously, performance began to degrade again at these massive core counts.</li></ul><h3>Why did performance degrade with too many resources?</h3><p>In high-compute container environments, this is a known distributed systems phenomenon typically caused by <a href="https://www.geeksforgeeks.org/computer-organization-architecture/computer-organization-amdahls-law-and-its-proof/"><strong>Amdahl’s Law</strong></a> and <a href="https://gist.github.com/andrewloux/ec9184229ec9fdab6ad5eb78ff2c97fb"><strong>NUMA (Non-Uniform Memory Access) </strong></a><strong>architecture switching</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/976/1*K43GQD5D8neYQRxFsdEn9w.png" /><figcaption>Demonstration of Amdahl’s Law</figcaption></figure><p>When a container spans too many physical CPU sockets or virtual cores, the overhead of the operating system coordinating thread scheduling across distinct hardware cache lines (inter-core communication latency) outpaces the computational work being done. In short: there is an absolute sweet spot for vertical scaling, and I found mine perfectly at 16,000 mcores.</p><h3>Key Takeaways for Tech Leaders &amp; Architects:</h3><ul><li><strong>Infrastructure Can’t Fix Friction:</strong> If your code suffers from architectural thread contention, upgrading your hardware will only make it fight itself faster.</li><li><strong>Cross-Question Your Tools:</strong> Using architectural planning layers like Cursor’s Plan Mode to vet designs <em>before</em> generation saves days of iterative debugging down the road.</li><li><strong>Find Your Compute Sweet Spot:</strong> More cores do not equal linear speed forever. Test your scaling boundaries to find the exact peak efficiency zone for your cloud budget.</li></ul><p>How are you leveraging modern AI agent workflows to resolve deep system bottlenecks in your production stack? Let’s discuss in the comments! 👇</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4581efb7820" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Just Upgraded My Portfolio from Next.js 14 to Next.js 16 and Felt Like a Child Who Knows Nothing]]></title>
            <link>https://javascript.plainenglish.io/i-just-upgraded-my-portfolio-from-next-js-14-to-next-js-16-and-felt-like-a-child-who-knows-nothing-886fca732c41?source=rss-bf13c92cf145------2</link>
            <guid isPermaLink="false">https://medium.com/p/886fca732c41</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Ingila ]]></dc:creator>
            <pubDate>Thu, 04 Jun 2026 12:01:42 GMT</pubDate>
            <atom:updated>2026-06-04T12:01:42.031Z</atom:updated>
            <content:encoded><![CDATA[<p><em>My honest journey through incremental framework upgrades, breaking changes, and lessons learned.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8IVHMEMf9c1kU3K7EIQIfA.png" /><figcaption>Image of a developer working</figcaption></figure><h3>Introduction</h3><p>When I started this morning, my <a href="https://next-js-portfolio-two-ebon.vercel.app/en">Next.js portfolio</a> was running smoothly on version 14. By afternoon, after upgrading to version 16, I was debugging 404 errors, dealing with deprecated middleware patterns, and questioning every life choice that led me to this moment.</p><p>But here’s the thing: upgrading Next.js isn’t as scary as it seems. It’s just a series of small, manageable steps — kind of like learning to walk again, but digitally.</p><p>In this article, I’ll walk you through my exact upgrade journey from Next.js 14 → 15 → 16, the unexpected hurdles I hit, the features that impressed me, and the breaking changes that caught me off guard.</p><h3>Part 1: The Incremental Path — Why Skipping Versions Is Risky</h3><p>Let me be clear: <strong>I didn’t jump directly from 14 to 16</strong>. That would have been chaos.</p><p>The safest approach is to upgrade incrementally:</p><ol><li><strong>14 → 15</strong> (one major version at a time)</li><li><strong>15 → 16</strong> (then proceed to the next)</li></ol><p>Why? Because each version introduces breaking changes, and doing them one step at a time makes it easier to identify which upgrade broke what.</p><h3>The Upgrade Process</h3><h3>Step 1: Next.js 14 → 15</h3><pre>npm install next@15</pre><p>This initial upgrade went smoothly for me. The main things that happened:</p><ul><li>React dependencies updated automatically</li><li>Build process remained largely the same</li><li>Most of my existing code continued to work</li></ul><p><strong>Key learning</strong>: Update React and React-DOM at the same time:</p><pre>npm install react@latest react-dom@latest</pre><h3>Step 2: Next.js 15 → 16</h3><p>This is where things got interesting.</p><pre>npm install next@latest</pre><h3>Part 2: The New Features That Made Me Say “Finally!”</h3><h3>1. Turbopack is Now Default</h3><p>Next.js 16 ships with <strong>Turbopack</strong> as the default bundler instead of Webpack. This wasn’t my choice — it just happened.</p><p><strong>The benefit</strong>: My initial build time decreased from 22 seconds to 11 seconds. That’s a 50% improvement.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*-mrYqz-wFalZ7VhcBwScNA.png" /></figure><p>Turbopack is written in Rust and is significantly faster for development builds. For production builds, you might still use the old behavior, but the development experience is noticeably snappier.</p><h3>2. Enhanced React 19 Support</h3><p>With Next.js 16, React 19 support is more mature. My dependencies now look like:</p><pre>{<br>  &quot;react&quot;: &quot;^19.2.5&quot;,<br>  &quot;react-dom&quot;: &quot;^19.2.5&quot;<br>}</pre><p>React 19 brings:</p><ul><li>Server Components improvements</li><li>Better error boundaries</li><li>More predictable state management</li><li>The new use() hook for cleaner async code</li></ul><h3>3. Improved Image Optimization</h3><p>The next/image component in version 16 has better automatic format detection and responsive image handling. Since I have a portfolio with lots of project screenshots, this should help with performance.</p><h3>4. Better TypeScript Integration</h3><p>During the build process, Next.js 16 automatically reconfigured my tsconfig.json with better defaults:</p><pre>{<br>  &quot;compilerOptions&quot;: {<br>    &quot;jsx&quot;: &quot;preserve&quot;,<br>    &quot;jsxImportSource&quot;: &quot;react&quot;<br>  }<br>}</pre><p>This means better type checking and IDE autocomplete out of the box.</p><h3>Part 3: The Breaking Changes That Broke Me (And How I Fixed Them)</h3><h3>🚨 Breaking Change #1: Middleware is Deprecated</h3><p><strong>The Warning Message:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/1*-cpSFn75h7jkExoOtDmEzA.png" /></figure><p>This was the big one. My project uses next-intl for internationalization (supporting English and German), and the middleware is critical for routing requests to the correct locale.</p><p><strong>The Problem:</strong><br>Next.js ran a codemod to automatically convert middleware to proxy patterns:</p><pre>npx @next/codemod@canary middleware-to-proxy . </pre><p>After running this, my routes started returning 404 errors:</p><ul><li>/en/certifications → 404</li><li>/de/certifications → 404</li><li>All locale-based routes → 404</li></ul><p><strong>The Solution:</strong><br>I discovered that next-intl library still relies on middleware. The codemod conversion doesn&#39;t work well with i18n setups. So I:</p><ol><li><strong>Kept my middleware.ts file intact:</strong></li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*R5R62LFjES2B9oZIPAUCeg.png" /></figure><ol><li><strong>Updated next-intl to the latest version:</strong></li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/1*yqEpDKvsQijweuh4GQeaQQ.png" /></figure><ol><li><strong>Cleared the build cache and rebuilt:</strong></li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*mCqhDlITde4xbBhz1wPO2w.png" /></figure><p><strong>The Takeaway</strong>: While middleware is supposedly “deprecated,” it still works perfectly in Next.js 16 and is necessary for i18n routing with next-intl. The library maintainers haven&#39;t migrated to the new proxy pattern yet, and that&#39;s okay.</p><h3>🚨 Breaking Change #2: Missing Dependencies</h3><p>When I added recharts for data visualization, I encountered:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*BWx8DkF9NXALiGzpb8tOGQ.png" /></figure><p>Recharts has a dependency on react-is that wasn&#39;t automatically installed as a peer dependency.</p><p><strong>The Fix:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/887/1*vTQvFpNveXEa2vcFmezprA.png" /></figure><p><strong>The Lesson</strong>: When adding third-party libraries with Next.js 16, double-check their peer dependencies. The ecosystem is still catching up.</p><h3>Part 4: What I Actually Built (Real-World Example)</h3><p>To test all these changes, I added a skills chart component using Recharts:</p><pre>import {<br>  BarChart,<br>  Legend,<br>  XAxis,<br>  YAxis,<br>  CartesianGrid,<br>  Tooltip,<br>  Bar,<br>} from &quot;recharts&quot;;<br>import { techSkills } from &quot;../api/skills&quot;;<br><br>// Transform skill data into chart format<br>const data = techSkills.frontend.map((skill) =&gt; ({<br>  name: skill.name,<br>  years: parseFloat(skill.years),<br>}));<br><br>const BarChartExample = ({ isAnimationActive = true }) =&gt; (<br>  &lt;BarChart<br>    layout=&quot;vertical&quot;<br>    style={{<br>      width: &quot;100%&quot;,<br>      maxWidth: &quot;700px&quot;,<br>      maxHeight: &quot;70vh&quot;,<br>      aspectRatio: 1.618,<br>    }}<br>    data={data}<br>  &gt;<br>    &lt;CartesianGrid strokeDasharray=&quot;3 3&quot; /&gt;<br>    &lt;XAxis type=&quot;number&quot; /&gt;<br>    &lt;YAxis dataKey=&quot;name&quot; type=&quot;category&quot; width={100} /&gt;<br>    &lt;Tooltip /&gt;<br>    &lt;Legend /&gt;<br>    &lt;Bar dataKey=&quot;years&quot; fill=&quot;#8884d8&quot; isAnimationActive={isAnimationActive} /&gt;<br>  &lt;/BarChart&gt;<br>);<br><br>export default BarChartExample;</pre><p>The source data structure (which remained unchanged):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*xqehI3fbFe-PLdQ05Td3zQ.png" /></figure><p>This example shows how Next.js 16 handles client-side components, external libraries, and data transformations seamlessly.</p><h3>Part 5: A Checklist for Your Next.js Upgrade</h3><p>Based on my experience, here’s what you should do when upgrading:</p><h3>Pre-Upgrade</h3><ul><li>[ ] Commit your current work to git</li><li>[ ] Document your current version: npm list next</li><li>[ ] Check all test files pass</li><li>[ ] Review the official <a href="https://nextjs.org/docs/upgrading">Next.js upgrade guide</a></li></ul><h3>During Upgrade</h3><ul><li>[ ] Upgrade incrementally (14→15, then 15→16)</li><li>[ ] Run npm install next@15 first</li><li>[ ] Then run npm install next@latest for 16</li><li>[ ] Update React dependencies: npm install react@latest react-dom@latest</li><li>[ ] Clear build cache: rm -r .next</li><li>[ ] Run npm run build to catch compilation errors</li></ul><h3>Post-Upgrade</h3><ul><li>[ ] Test all major routes in development</li><li>[ ] Check console for deprecation warnings</li><li>[ ] Verify third-party libraries are compatible</li><li>[ ] Test with actual users if possible</li><li>[ ] Review performance metrics (build time, bundle size)</li><li>[ ] Update documentation if needed</li></ul><h3>Part 6: The Performance Impact</h3><p>Here’s what changed for my project:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*ftGYyYPiP8KNM4RZe5dSPQ.png" /></figure><p>That’s a significant improvement in developer experience. Faster builds mean faster feedback loops, which means more productive development sessions.</p><h3>Part 7: Should You Upgrade? (The Honest Answer)</h3><p><strong>TL;DR: Yes, but do it incrementally.</strong></p><h3>Reasons to upgrade:</h3><p>✅ Turbopack performance improvements<br>✅ Better React 19 support<br>✅ Improved image optimization<br>✅ Better TypeScript defaults<br>✅ Security updates and bug fixes<br>✅ Future-proofs your project</p><h3>Reasons to wait:</h3><p>⚠️ If you’re on a tight deadline with a stable project<br>⚠️ If you use many third-party libraries that aren’t updated yet<br>⚠️ If you have heavy customization (custom webpack config, etc.)</p><p>For most projects, the benefits outweigh the risks.</p><h3>Conclusion: Feeling Like a Child Who Knows Nothing</h3><p>When I started this upgrade journey, I felt lost. Deprecated features, 404 errors, missing dependencies — it all seemed overwhelming.</p><p>But here’s what I learned:</p><ol><li><strong>Modern framework upgrades aren’t as scary as they seem.</strong> They’re just a series of small, manageable steps.</li><li><strong>The ecosystem matters.</strong> Libraries like next-intl still rely on middleware, and that&#39;s fine. Not everything needs to change just because the framework says it&#39;s &quot;deprecated.&quot;</li><li><strong>Performance wins are real.</strong> A 50% faster build time isn’t just a nice-to-have — it genuinely improves your daily workflow.</li><li><strong>The documentation is your friend.</strong> When things broke, the official Next.js error messages and docs pointed me in the right direction.</li><li><strong>Incremental upgrades prevent disasters.</strong> Jumping two major versions at once would have been a nightmare. Taking it one step at a time made debugging straightforward.</li></ol><p>Next.js 16 isn’t revolutionary — it’s evolutionary. It’s the framework maturing, getting faster, and becoming more reliable. And that’s exactly what we need as developers.</p><p>So yes, I felt like a child who knows nothing when I started. But after working through the problems, I realized I wasn’t lost — I was just learning.</p><p>And that’s been the most valuable part of this upgrade.</p><h3>Resources</h3><ul><li><a href="https://nextjs.org/blog">Next.js 16 Release Notes</a></li><li><a href="https://nextjs.org/docs/upgrading">Next.js Upgrade Guide</a></li><li><a href="https://next-intl.dev/">next-intl Documentation</a></li><li><a href="https://turbo.build/pack">Turbopack Documentation</a></li><li><a href="https://react.dev/blog/2024/12/19/react-19">React 19 What’s New</a></li></ul><p><em>This article is based on real upgrade experiences and best practices for Next.js development. Your mileage may vary depending on your specific setup and dependencies.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=886fca732c41" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/i-just-upgraded-my-portfolio-from-next-js-14-to-next-js-16-and-felt-like-a-child-who-knows-nothing-886fca732c41">I Just Upgraded My Portfolio from Next.js 14 to Next.js 16 and Felt Like a Child Who Knows Nothing</a> was originally published in <a href="https://javascript.plainenglish.io/">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI vs Generative AI vs Predictive AI vs Agentic AI]]></title>
            <link>https://medium.com/@ingila185/ai-vs-generative-ai-vs-predictive-ai-vs-agentic-ai-f2864af86109?source=rss-bf13c92cf145------2</link>
            <guid isPermaLink="false">https://medium.com/p/f2864af86109</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Ingila ]]></dc:creator>
            <pubDate>Fri, 29 May 2026 20:10:08 GMT</pubDate>
            <atom:updated>2026-05-29T20:10:08.507Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R8KiqtrCLqsf9AApdAGVhA.png" /><figcaption>The evolution of AI</figcaption></figure><p>When people talk about Artificial Intelligence today they often put different tools in the same group. It is like putting a kitchen blender and a personal assistant app in the same category just because they both have buttons. One makes a smoothie the other helps you manage your schedule so you can get things done. They are completely different.</p><p>If you are still thinking of Artificial Intelligence as one thing you are missing out on how technology is really changing. The market has moved past using terms to describe everything.</p><p>To help you understand what is going on and make the right technology decisions for your business lets look at the four types of Artificial Intelligence that are changing the way we work with real examples of how they are being used: <strong>Traditional Artificial Intelligence, Predictive Artificial Intelligence, Generative Artificial Intelligence,</strong> and the next big thing, <strong>Agentic Artificial Intelligence</strong>.</p><p><strong>Artificial Intelligence</strong></p><p>Think of Artificial Intelligence as a group. It includes any machine or software that can do things that normally require intelligence. It uses rules, data processing and algorithms to do tasks that used to require human brains.</p><p>For a time Traditional Artificial Intelligence just did what it was told. It looked at the data you gave it followed the rules and gave you a result. It did not do anything less.</p><p><strong>Use Cases</strong></p><ul><li><strong>Basic Automation:</strong> Sorting IT tickets into folders based on keywords.</li><li><strong>Simple Classification:</strong> Spam filters that send emails to the junk folder because they match rules.</li></ul><p><strong>Predictive AI</strong></p><p>Before we started using Artificial Intelligence to create things we used it to try to predict the future. Predictive Artificial Intelligence does not create anything it just looks at the past to try to figure out what will happen next.</p><p>It looks at a lot of data finds patterns and calculates the chances of what will happen next using machine learning and regression models. In short, it answers the question <em>”What is likely to happen?”</em></p><p><strong>Use Cases</strong></p><ul><li><strong>Financial Risk and Fraud Detection: </strong>Banks scanning transactions in time to flag suspicious activity.</li><li><strong>Supply Chain Forecasting:</strong> Retailers predicting when they will run out of stock based on sales and other factors.</li></ul><p><strong>Generative AI</strong></p><p>This is the Artificial Intelligence that has been getting a lot of attention. Tools like <em>ChatGPT</em>, <em>Midjourney </em>and <em>Claude </em>have changed the way we create content.</p><p>It uses Deep Learning and Large Language Models to create things. Text, code, images or audio. Based on what you ask for.</p><p>The caveat is that Generative Artificial Intelligence only does what you ask it to do. It operates on an one-request one-response loop. You ask it to do something it does it. It will not log into your software to execute the plan it just created. In short, it answers the question <em>”Can you create this for me?”</em></p><p><strong>Use Cases</strong></p><ul><li><strong>Content Creation:</strong> Digital agencies using tools to create high-quality blog posts, landing pages and email marketing campaigns.</li><li><strong>Product Design: </strong>A fashion brand using Generative Artificial Intelligence to create clothing line designs based on customer feedback.</li><li><strong>Software Engineering:</strong> Developers using Artificial Intelligence to draft code refactor syntax or write unit tests.</li></ul><p><strong>Agentic Artificial Intelligence</strong></p><p>This is the big thing in Artificial Intelligence. If the past few years have been about creating content the focus now is on getting things done. According to data from Gartner less than 1% of businesses used Agentic Artificial Intelligence in 2024 but that number is expected to increase to 33% by 2028.</p><p>Agentic Artificial Intelligence does not just wait for instructions. It uses Large Language Models and external tools to form a loop: <em>Perceive, Reason, Act, Learn.</em></p><p>The Game Changer of asking Artificial Intelligence to write a grocery list Agentic Artificial Intelligence goes to the online store buys the groceries tracks the shipping updates your calendar and changes the order if something is out of stock. It operates on its own handles steps and adapts when things change. In short, It answers the question <em>”Can you get this done?”</em></p><p><strong>Use Cases</strong></p><ul><li><strong>Autonomous Workflow and Supply Chain Management: </strong>A logistics engine that adjusts delivery routes rewrites schedules and places orders with suppliers on its own.</li><li><strong>Next-Gen Customer Support: </strong>Autonomous agents that understand customer intent navigate systems, process refunds and update databases without human intervention.</li><li><strong>Dynamic Health and Patient Monitoring: </strong>Smart medical devices that collect patient data track patterns and alert healthcare providers when something is wrong.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9C77gECXVT2aoPSZP-lYPQ.png" /><figcaption>AI Vs Predictive AI Vs Generative AI Vs Agentic AI</figcaption></figure><p><strong>How They Work Together in Business</strong></p><p>Smart businesses are not choosing between these technologies they are using them together. Think about an e-commerce brand managing its operations:</p><ul><li><strong>Predictive AI </strong>predicts that customer churn will increase month.</li><li><strong>Generative AI</strong> creates an email campaign to try to keep customers.</li><li><strong>Agentic AI </strong>sends the email, monitors responses processes refunds and schedules follow-up calls.</li></ul><p><strong>The Takeaway</strong></p><p>Generative Artificial Intelligence helped us create faster. Agentic Artificial Intelligence gives us the power to automate the execution of our plans.</p><p>As a business leader the question is no longer just <em>“How can we use Artificial Intelligence to create things“</em> The real advantage lies in asking: <em>”What processes are we ready to hand over to agents?”</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f2864af86109" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Your API Needs Rate Limiting (And How to Actually Code It)]]></title>
            <link>https://medium.com/@ingila185/why-your-api-needs-rate-limiting-and-how-to-actually-code-it-bc86f2bcb29b?source=rss-bf13c92cf145------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc86f2bcb29b</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[social-media]]></category>
            <dc:creator><![CDATA[Ingila ]]></dc:creator>
            <pubDate>Fri, 10 Apr 2026 16:19:58 GMT</pubDate>
            <atom:updated>2026-04-10T16:19:58.826Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EjOHqEylBQ1rYot7uxpURA.png" /><figcaption>Image of a developer’s workspace by Gemini</figcaption></figure><p>If you’ve ever seen a service go down because a single user’s script went rogue, you already know why rate limiting is non-negotiable. It’s not just about stopping “bad actors”; it’s about making sure one chatty client doesn’t starve everyone else of resources.</p><p>In my experience, the “best” algorithm depends entirely on your infrastructure and how much “burst” you’re willing to tolerate. Let’s break down the three most common ways to handle this in Node.js.</p><h3>1. The Simple Path: Fixed Window</h3><p>This is the “good enough” approach. You give a user <strong>X</strong> requests every <strong>Y</strong> minutes. It’s easy to build, but it has a notorious flaw: users can double their limit if they time their requests right at the edge of a window.</p><pre>class FixedWindow {<br>  constructor(limit, windowMs) {<br>    this.limit = limit;<br>    this.windowMs = windowMs;<br>    this.resetTime = Date.now() + windowMs;<br>    this.count = 0;<br>  }<br>isAllowed() {<br>    const now = Date.now();<br>    <br>    // Reset if the window has passed<br>    if (now &gt; this.resetTime) {<br>      this.resetTime = now + this.windowMs;<br>      this.count = 0;<br>    }<br>    if (this.count &lt; this.limit) {<br>      this.count++;<br>      return true;<br>    }<br>    return false;<br>  }<br>}</pre><h3>2. Smoothing Traffic: The Leaky Bucket</h3><p>Think of this as a buffer. No matter how fast requests come in, they leave the “bucket” and hit your database at a steady, predictable pace. It’s great for protecting legacy systems that can’t handle spikes.</p><ul><li><strong>The Catch:</strong> If your bucket is small, legitimate users might get dropped during a quick burst, even if your server isn’t actually stressed.</li></ul><pre>class LeakyBucket {<br>  constructor(capacity, leakRatePerMs) {<br>    this.capacity = capacity;<br>    this.leakRate = leakRatePerMs;<br>    this.currentLevel = 0;<br>    this.lastCheck = Date.now();<br>  }<br>isAllowed() {<br>    const now = Date.now();<br>    const elapsed = now - this.lastCheck;<br>    <br>    // Gradually empty the bucket based on time<br>    this.currentLevel = Math.max(0, this.currentLevel - (elapsed * this.leakRate));<br>    this.lastCheck = now;<br>    if (this.currentLevel &lt; this.capacity) {<br>      this.currentLevel++;<br>      return true;<br>    }<br>    return false;<br>  }<br>}</pre><h3>3. The Gold Standard: Token Bucket</h3><p>Most modern APIs (like Stripe or AWS) use a version of this. You hand out “tokens” at a fixed rate. As long as a user has a token, they can burst. If they run out, they wait. It’s the most flexible because it rewards well-behaved users with the ability to occasionally go fast.</p><blockquote><strong><em>Pro Tip:</em></strong><em> In production, you wouldn’t keep this in local memory like these examples. You’d use </em><strong><em>Redis</em></strong><em>. Redis allows you to share these counters across multiple server instances, which is essential if you’re horizontal scaling.</em></blockquote><h3>4. Solving the “Boundary Problem”: Sliding Window</h3><p>If you need high precision, you use a <strong>Sliding Window</strong>. Instead of rigid blocks of time, you look back at the last 60 seconds from <em>this exact millisecond</em>.</p><p>The math looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/791/1*w_Z7omsqzza9r5iUgvIzeg.png" /></figure><p>This prevents the “double-request” exploit of the Fixed Window while staying much more memory-efficient than keeping a log of every single timestamp.</p><h3>Final Thoughts</h3><p>If you’re just starting out, <strong>Fixed Window</strong> is fine. If you’re building something that needs to be “fair,” go with <strong>Token Bucket</strong>.</p><p>Whatever you choose, don’t reinvent the wheel for a production app. Use something like express-rate-limit for simple cases, or a Redis-based Lua script if you&#39;re handling serious scale.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc86f2bcb29b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Profiling Your Monolith with GitHub Copilot’s Performance Agent]]></title>
            <link>https://medium.com/@ingila185/profiling-your-monolith-with-github-copilots-performance-agent-73bb490f6fee?source=rss-bf13c92cf145------2</link>
            <guid isPermaLink="false">https://medium.com/p/73bb490f6fee</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Ingila ]]></dc:creator>
            <pubDate>Wed, 08 Apr 2026 07:55:49 GMT</pubDate>
            <atom:updated>2026-04-08T07:55:49.474Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qziXkStblkHx3KwJg-TkaA.png" /><figcaption>Github Copilot image generated by Nano Banana</figcaption></figure><p>Performance bottlenecks are the silent killers of monolithic applications. As legacy systems grow, finding that one inefficient query or memory leak in a large codebase feels like finding a needle in a haystack.</p><p>With the release of the <strong>GitHub Copilot Performance Agent</strong> in Visual Studio 2022 (v17.14+), you can now use AI to find and fix these issues automatically. Here is how to use this tool to improve your monoliths.</p><p>Scaling a monolith often leads to “Code Bloat.” Traditional profiling tools are powerful, but they are often difficult to learn. The GitHub Copilot Performance Agent acts as a guided “Performance Engineer” right inside your IDE.</p><h3>Basic Definitions: What are we measuring?</h3><p>Before we start, let’s define three key metrics the profiler tracks:</p><ul><li><strong>CPU Usage:</strong> The amount of work the processor is doing. High CPU usage often means your code has complex calculations or “infinite loops.”</li><li><strong>Allocation:</strong> The process of or reserving memory for your data. If your app “allocates” too much memory too quickly, it slows down because of <strong>Garbage Collection (GC)</strong>.</li><li><strong>Wall Clock Time:</strong> The total time a user waits for a task to finish.</li></ul><h3>Step 1: The Setup</h3><p>To follow along, ensure you have:</p><ul><li><strong>Visual Studio 2022 (version 17.14 or later).</strong></li><li><strong>GitHub Copilot Subscription.</strong></li></ul><h3>Step 2: Initiating a Profiling Session</h3><p>You no longer need to find complex menus. You can simply talk to your code.</p><ol><li><strong>Open Copilot Chat:</strong> (Ctrl+Alt+I).</li><li><strong>Use the @Profiler Command:</strong> Type the prompt below in the chat window.</li></ol><pre>@Profiler Please evaluate the performance of this code</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/351/0*6Wxspk9O1M50W1w0" /><figcaption>Github Profiler Agent GPT-5</figcaption></figure><p><strong>3. Confirm Execution:</strong> Copilot will ask for permission to start. Click <strong>Confirm</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/262/1*nsPzn00Ggo8C4epRAXpZVQ.jpeg" /><figcaption>Github Profiler Step 3</figcaption></figure><p>The agent will run your app, collect data, and identify “hot paths” — the parts of your code that take the most time or memory.</p><h3>Step 3: Automated Benchmarking</h3><p>For a monolith, you must prove that a change actually makes the app faster. When the agent finds a bottleneck, it uses <strong>BenchmarkDotNet</strong> to test the old code against the new code.</p><h3>Example: The “Materialization” Problem</h3><p>In many monoliths, developers accidentally load too much data into memory.</p><p><strong>The Inefficient Code:</strong></p><pre>// This loads 100,000 rows into memory BEFORE filtering<br>var people = db.People.ToList(); <br>var results = people.Where(p =&gt; p.Age &gt; 50).ToList();</pre><p><strong>The Copilot Optimization:</strong></p><pre>// This filters the data on the Database side (SQL), loading only what is needed<br>var results = db.People<br>    .AsNoTracking()<br>    .Where(p =&gt; p.Age &gt; 50)<br>    .ToList();</pre><h3>Step 4: Applying Optimizations</h3><p>Once the agent finishes the test, it shows you the results in the <strong>Output Window</strong>. It might report a “33% gain in efficiency.”</p><p>You can then:</p><ul><li><strong>Preview the changes</strong> in a side-by-side view.</li><li><strong>Click “Keep”</strong> to merge the faster code into your project.</li></ul><h3>Pro-Tip: Handling Large Files</h3><p>Monoliths often have very long files. If your chat history gets too long, the Performance Agent uses <strong>Smart Summarization</strong>. It will summarize your progress and start a fresh chat so the AI doesn’t get confused by too much information.</p><h3>Conclusion</h3><p>Profiling a monolith shouldn’t be a manual chore. By using the <strong>@Profiler</strong> agent, you can stop guessing where the lag is and start fixing it with data-driven results.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=73bb490f6fee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coding with the Tides: My Seafaring Software Journey]]></title>
            <link>https://medium.com/@ingila185/coding-with-the-tides-my-seafaring-software-journey-b817a8e4498c?source=rss-bf13c92cf145------2</link>
            <guid isPermaLink="false">https://medium.com/p/b817a8e4498c</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[work]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Ingila ]]></dc:creator>
            <pubDate>Sun, 01 Feb 2026 12:46:03 GMT</pubDate>
            <atom:updated>2026-02-01T12:46:03.718Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*LajsYFReIpVJXbrCZoUZPQ.gif" /><figcaption>Coding at the beach</figcaption></figure><p>As a software consultant, my work revolves around problem-solving, crafting elegant code, and ensuring seamless integration for diverse clients. For years, the traditional office model dictated where and how I worked. But something shifted. The digital age, coupled with evolving work methodologies, opened up a new vista: remote work. And it’s not just about “workation” — it’s about a fundamental transformation in productivity, well-being, and professional impact.</p><p>Today, I often find myself at my desk, the rhythmic sound of waves replacing the usual office hum. Yes, that’s right. I’m merging PRs and committing code, all while being just steps away from the sea. This isn’t a vacation; this is my workspace. And it embodies the profound benefits of remote working that I want to share.</p><h3>Beyond the Beach: The True Power of Remote Work</h3><p>While the image of coding by the ocean is certainly appealing, the advantages of remote work extend far beyond picturesque backdrops. For software professionals, in particular, it unlocks a new level of efficiency and job satisfaction.</p><p><strong>1. Uninterrupted Focus &amp; Deep Work:</strong> The nature of software development demands intense concentration. Context switching, frequent interruptions, and open-plan office distractions can severely hamper productivity. Remote work, especially when managed effectively, provides the autonomy to design an environment conducive to deep work. I can structure my day to align with my peak concentration times, leading to higher quality code and more robust solutions.</p><p><strong>2. Global Talent Pool &amp; Diverse Perspectives:</strong> As a consultant, I collaborate with teams and clients worldwide. Remote working shatters geographical barriers, allowing companies to tap into a truly global talent pool. This diversity of thought, experience, and cultural perspective enriches projects and leads to more innovative outcomes. For individual consultants, it means access to a wider range of challenging and rewarding engagements.</p><p><strong>3. Enhanced Work-Life Integration (Not Just “Balance”):</strong> “Work-life balance” often implies a rigid separation. Remote work, however, fosters integration. It allows for flexibility to attend to personal needs, pursue hobbies, or simply take a mental break without the rigid constraints of a commute or fixed hours. For me, a quick walk by the sea isn’t a distraction; it’s a reset button that fuels creativity and problem-solving. This isn’t about working less; it’s about working smarter and living fuller.</p><p><strong>4. Reduced Commute, Increased Productivity:</strong> The hours spent commuting are often unproductive and draining. Eliminating this daily ritual frees up significant time and energy. This reclaimed time can be reinvested into professional development, personal well-being, or simply getting an earlier start on complex coding tasks, leading to a tangible increase in overall output.</p><p><strong>5. Autonomy and Ownership:</strong> Remote work inherently places a greater emphasis on individual autonomy and ownership of tasks. This fosters a sense of trust and responsibility, which can be incredibly motivating for software professionals. When you’re empowered to manage your time and workflow, you often rise to the occasion, delivering superior results.</p><h3>Making Remote Work Work</h3><p>Of course, remote work isn’t without its challenges. It requires discipline, effective communication strategies, and the right tools. Here’s what I’ve found essential:</p><ul><li><strong>Robust Communication Tools:</strong> Leveraging platforms like Slack, Microsoft Teams, and video conferencing is crucial for seamless team collaboration.</li><li><strong>Version Control Systems (VCS):</strong> Git and GitHub/GitLab are non-negotiable for collaborative coding, allowing me to merge PRs and commit code efficiently from anywhere.</li><li><strong>Defined Workspaces:</strong> Even if it’s a corner of a room or, in my case, a well-equipped outdoor setup, having a dedicated workspace signals to your brain (and others) that it’s “work time.”</li><li><strong>Self-Discipline and Time Management:</strong> Structuring your day, setting boundaries, and taking regular breaks are vital to avoid burnout.</li></ul><h3>The Future is Flexible</h3><p>Remote working is no longer a perk; it’s a powerful methodology that is reshaping the modern workforce, particularly in the tech industry. For software consultants like myself, it’s an opportunity to optimize productivity, embrace flexibility, and deliver exceptional value to clients, regardless of geographical location. My office may shift from a bustling city to a tranquil coastline, but my commitment to clean code and effective solutions remains constant.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b817a8e4498c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond the Current State: A Deep Dive into the Event Sourcing Pattern]]></title>
            <link>https://medium.com/@ingila185/beyond-the-current-state-a-deep-dive-into-the-event-sourcing-pattern-0a1644a238b2?source=rss-bf13c92cf145------2</link>
            <guid isPermaLink="false">https://medium.com/p/0a1644a238b2</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Ingila ]]></dc:creator>
            <pubDate>Sun, 28 Dec 2025 10:00:37 GMT</pubDate>
            <atom:updated>2025-12-28T10:00:37.112Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UoBqOHLIq9RjCUbGhg9_GA.png" /><figcaption>Image of working space generated by Nano Banana</figcaption></figure><p>In traditional application design, we treat databases as the “final word” on the current state of our business objects. When a user updates their profile or a product price changes, we perform an UPDATE operation, overwriting the previous values. While this works for simple CRUD (Create, Read, Update, Delete) applications, it discards the journey that led to the current state.</p><p>In mission-critical systems, the “how” and “why” of data changes are often as important as the data itself. This is where the <strong>Event Sourcing Pattern</strong> becomes essential.</p><h3>The Limitations of State-Based Storage</h3><p>Most applications focus on <strong>Current State Storage</strong>. For instance, in a NoSQL product catalog, we store the name, description, and price. When a price changes from $100 to $120, the $100 value is gone forever.</p><p>For a product description, this loss of history might be negligible. However, consider these scenarios where state-based storage fails:</p><ol><li><strong>Banking:</strong> A customer sees a balance of $500 but no transaction history. Without the “events” (deposits, withdrawals, transfers), the balance is unverifiable and unauditable.</li><li><strong>Inventory Management:</strong> You see 100 items in stock at 9:00 AM and 50 items at 5:00 PM. Did you sell 50 items? Or did you sell 150 and receive 100 returns? Without the delta, you cannot optimize your supply chain.</li></ol><h3>What is Event Sourcing?</h3><p>Event Sourcing is an architectural pattern that defines the state of an entity as a sequence of <strong>immutable events</strong>. Instead of storing a single row representing a “Bank Account,” you store a log of every transaction that ever occurred on that account.</p><h3>Core Characteristics:</h3><ul><li><strong>Immutability:</strong> Once an event is appended to the log, it can never be changed or deleted.</li><li><strong>Append-Only:</strong> New changes are simply new entries at the end of the log.</li><li><strong>State Reconstruction:</strong> To find the current state of an entity, the system “replays” all events in the order they occurred.</li></ul><blockquote><strong><em>Analogy:</em></strong><em> Event sourcing is like Version Control (Git) for your data. Each event represents a “commit” or a delta from the previous state.</em></blockquote><h3>Architectural Implementation: Where to Store Events?</h3><p>Choosing the right “Event Store” depends on your query requirements and throughput needs.</p><h3>1. Relational Databases</h3><p>You can store events in a structured table. This is highly effective for auditing and complex analytical queries.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-YYianKPBjrR5k1yVhk6PA.png" /><figcaption>Example of Orders table</figcaption></figure><p><strong>Pros:</strong> Excellent for tracking progressions across multiple entities (e.g., “How many orders were delayed on Tuesday?”).</p><h3>2. Message Brokers (e.g., Apache Kafka, RabbitMQ)</h3><p>Message brokers are designed for high-throughput event streaming and maintaining strict ordering.</p><p><strong>Pros:</strong> High scalability and easy integration for downstream microservices.</p><p><strong>Cons:</strong> Performing complex queries across the entire stream is more difficult than in a traditional SQL database.</p><h3>Solving Performance Bottlenecks</h3><p>Event sourcing offers a massive advantage in <strong>Write Performance</strong>. In state-based systems, high-concurrency updates to a single row (like a popular product’s inventory) lead to database locking and contention.</p><p>With Event Sourcing, every write is an <strong>append-only</strong> operation. There are no locks on existing data, drastically reducing contention and increasing write throughput.</p><h3>Strategies for Efficient Reads</h3><p>Replaying thousands of events to get a balance is inefficient. We solve this using two primary methods:</p><ol><li><strong>Snapshots:</strong> At specific intervals (e.g., every 100 events or every month), the system records the current state. To get the balance, you start from the latest snapshot and only replay the subsequent events.</li><li><a href="https://medium.com/@ingila185/cqrs-and-saga-the-essential-patterns-for-high-performance-microservice-4f23a09889b4"><strong>CQRS </strong></a><strong>(Command Query Responsibility Segregation):</strong> We separate the “Write” side (appending events) from the “Read” side. A dedicated Read Service consumes the events and maintains a materialized view (often in an in-memory database) optimized for fast queries.</li></ol><h3>The Trade-off</h3><p>The combination of Event Sourcing and CQRS provides a robust framework for auditing, high-performance writes, and scalable reads. However, it introduces a specific challenge: <strong>Eventual Consistency</strong>. Because the read-side is updated asynchronously from the event log, there may be a slight delay before a write is reflected in a query.</p><p>For systems where the audit trail, historical correction, and write-speed are paramount — such as FinTech, E-commerce logistics, and Healthcare — Event Sourcing is the gold standard.</p><h3><strong>Conclusion</strong></h3><ul><li><strong>The Shift in Data Storage:</strong> Unlike traditional databases that only store the “current state” (overwriting previous data), Event Sourcing stores a chronological log of <strong>immutable events</strong> that describe every change to an entity.</li><li><strong>Problem Solved:</strong> It addresses the need for complete history in domains like banking and inventory, where knowing <em>how</em> a state was reached is critical for <strong>auditing, corrections, and visualization</strong>.</li><li><strong>State Reconstruction:</strong> The “current state” of an object is determined by <strong>replaying</strong> all recorded events from the beginning. This acts like version control for data.</li></ul><p><strong>Storage Options:</strong></p><ul><li><strong>Databases:</strong> Good for complex queries and cross-entity analytics.</li><li><strong>Message Brokers:</strong> Optimized for high-volume event streaming and maintaining strict event order.</li></ul><p><strong>High Performance:</strong> Event sourcing improves <strong>write performance</strong> by using “append-only” operations, which eliminate the database locking and contention issues often found in state-based updates.</p><p><strong>Optimization Strategies:</strong></p><ul><li><strong>Snapshots:</strong> Periodic “state captures” that prevent the need to replay thousands of events from scratch.</li><li><strong>CQRS (Command Query Responsibility Segregation):</strong> Separating the write-side (events) from the read-side (current state) for maximum efficiency.</li></ul><p><strong>The Trade-off:</strong> While the combination of Event Sourcing and CQRS provides superior auditing and performance, it introduces <strong>eventual consistency</strong>, meaning the read-side might have a slight delay in reflecting the most recent events.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0a1644a238b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CQRS and Saga: The Essential Patterns for High-Performance Microservice]]></title>
            <link>https://medium.com/@ingila185/cqrs-and-saga-the-essential-patterns-for-high-performance-microservice-4f23a09889b4?source=rss-bf13c92cf145------2</link>
            <guid isPermaLink="false">https://medium.com/p/4f23a09889b4</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[backend-development]]></category>
            <dc:creator><![CDATA[Ingila ]]></dc:creator>
            <pubDate>Mon, 03 Nov 2025 19:34:59 GMT</pubDate>
            <atom:updated>2025-11-03T19:34:59.683Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RMwv0SaTHwaX_d8vwFgxvw.png" /><figcaption>EDA Image</figcaption></figure><p>Microservices bring incredible agility — allowing teams to move fast and deploy independently. But this architectural freedom comes with a significant trade-off: <strong>data consistency</strong>. When you split your monolithic database into many small, separate databases, you lose the built-in guarantee of <strong>ACID transactions</strong>.</p><p>This is where the <strong>Saga Pattern</strong> and <strong>Command Query Responsibility Segregation (CQRS)</strong> step in. These aren’t just buzzwords; they are essential architectural patterns that keep your distributed system reliable and performant. Let’s dive into how they work and why they’re crucial.</p><h3>The Saga Pattern: Restoring Transactional Integrity</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/987/1*AANYl3AUDp44OI2w-l0Aaw.png" /><figcaption>Saga Pattern</figcaption></figure><p>In a monolith, a transaction is an <strong>atomic</strong> operation. It either fully succeeds or fully fails. In microservices, a business process often has to touch several services, each with its own database. How do you ensure that all these changes are coordinated and reversed if one fails?</p><p>The <strong>Saga Pattern</strong> is the answer. A saga is a sequence of <strong>local transactions</strong> where each successful transaction in one service triggers the next step in the sequence.</p><h4>Handling Failure with Compensation</h4><p>If any local transaction fails, the saga initiates a set of <strong>compensating transactions</strong>. These are actions designed to logically undo the changes made by the preceding successful local transactions, effectively ensuring the entire business process is rolled back to a consistent state.</p><h4>Two Ways to Implement a Saga</h4><p><strong>Orchestration (The Conductor):</strong></p><ul><li>A central, dedicated <strong>Orchestrator Service</strong> manages the entire workflow’s state and sequence.</li><li>It sends commands to microservices in order and is responsible for triggering compensating actions if a service reports a failure. This approach centralizes the flow logic, making it easier to monitor and control.</li></ul><p><strong>Choreography (The Dance):</strong></p><ul><li>There is <strong>no central orchestrator</strong>. Instead, microservices communicate with each other <strong>asynchronously</strong> using a <strong>message broker</strong> (like Kafka or RabbitMQ).</li><li>A service completes its local transaction and publishes an <strong>event</strong>. Other services consume this event to execute their next step. This offers higher decoupling but can make the overall flow harder to trace and debug.</li></ul><h3>CQRS: Separating Reads and Writes for Performance</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/783/1*o1FaerZrPg-xQM5Dryalag.png" /><figcaption>CQRS Pattern</figcaption></figure><p>The acronym <strong>CQRS</strong> stands for <strong>Command Query Responsibility Segregation</strong>. It’s a fundamental shift in how you structure your data access layers. Instead of one model handling everything, CQRS splits your application into two distinct parts:</p><ul><li><strong>Commands:</strong> Write operations (create, update, delete).</li><li><strong>Queries:</strong> Read operations (fetch data).</li></ul><p>In a CQRS setup, you typically have separate data models, and often, <strong>separate physical databases</strong>, for commands and queries. The Query database holds a read-optimized copy of the data from the Command database.</p><h4>The Role of Event-Driven Architecture (EDA)</h4><p>How do you keep the two databases in sync? Through <strong>Event-Driven Architecture</strong>.</p><ol><li>A <strong>Command Service</strong> successfully updates its write database.</li><li>It publishes an <strong>event</strong> to a message broker.</li><li>A <strong>Query Service</strong> consumes that event and updates its own read database with the new information.</li></ol><h4>Why Go to the Trouble? The Benefits of Segregation</h4><p>CQRS might seem complex, but the benefits in large-scale, high-traffic systems are significant:</p><ul><li><strong>Massive Scalability:</strong> You can scale your <strong>Query Service</strong> independently of your Command Service. Since most applications are <strong>read-heavy</strong>, you can spin up many more Query service instances and optimize them specifically for read speed.</li><li><strong>Optimal Data Modeling: </strong>The Command database can be modeled for <strong>write efficiency</strong> and transactional integrity.</li><li>The Query database can be structured specifically for <strong>read efficiency</strong> - using flat tables, pre-joined data, or even a different database technology (e.g., a graph database or a document store) to provide the perfect data structure for complex user-facing reports.</li><li><strong>Tackling Cross-Service Joins:</strong> In microservices, performing joins often requires slow, cascading <strong>API calls</strong>. With CQRS, you can use the event stream to build a Query database that already contains the required <strong>joined and aggregated data</strong> from multiple source services, making query latency negligible.</li><li><strong>Clean Architecture:</strong> It enforces a strong <strong>Separation of Concerns</strong>. All the complex logic (validation, authorization, business rules) stays in the Command side, leaving the Query side lean, simple, and purely focused on data presentation.</li></ul><h4>The Crucial Trade-Off: Eventual Consistency</h4><p>The trade-off you must accept with CQRS is <strong>eventual consistency</strong>. Because the synchronization relies on events flowing through a message broker, there’s a short delay.</p><blockquote><strong>Crux:</strong> Users might temporarily see <strong>stale data</strong> in the Query database immediately after a write operation until the event is processed.</blockquote><p>If your application can tolerate this small lag (and most can), CQRS is a powerful tool to achieve unparalleled performance and independent evolution of your read and write models.</p><p>These two patterns - <strong>Saga</strong> for transactional integrity and <strong>CQRS</strong> for read/write optimization - are cornerstone techniques for any serious architect building robust, high-performance microservices.</p><h3>Conclusion:</h3><p>The journey into microservices fundamentally shifts the architectural challenge from managing complex code to managing <strong>distributed data and workflow</strong>. The days of relying on an easy, implicit ACID guarantee from a single database are gone.</p><p>Instead, modern architects must <strong>explicitly design</strong> for consistency and performance.</p><ul><li>The <strong>Saga Pattern</strong> is your strategy for achieving <strong>transactional integrity</strong> across decoupled services, ensuring that even when a process fails, the system returns to a known, stable state using compensating transactions.</li><li>The <strong>CQRS Pattern</strong> is your tool for <strong>optimization and independent scaling</strong>, freeing your data models from the restrictive “one size fits all” approach of a traditional architecture. It allows you to tune your read model for peak performance and your write model for integrity.</li></ul><p>While these patterns — especially the resulting <strong>eventual consistency</strong> with CQRS — require careful consideration, they are non-negotiable for building systems that are truly <strong>resilient, scalable, and responsive</strong> to high-traffic demands. Mastering the Saga and CQRS patterns is not just about adopting new technology; it’s about adopting a mature, strategic mindset for building the next generation of enterprise-level software.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f23a09889b4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Architecting for Agility: Understanding Event-Driven Architectures (EDA)]]></title>
            <link>https://medium.com/@ingila185/architecting-for-agility-understanding-event-driven-architectures-eda-4d3553df8bd9?source=rss-bf13c92cf145------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d3553df8bd9</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Ingila ]]></dc:creator>
            <pubDate>Tue, 21 Oct 2025 16:21:37 GMT</pubDate>
            <atom:updated>2025-10-21T16:21:37.642Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cdYqlAPO6p9wbMnYClTRGA.png" /><figcaption>Event Driven Architecture Image by Gemini</figcaption></figure><p>For senior engineers and system architects, moving beyond the limitations of the traditional request-response model is key to building <strong>scalable</strong> and <strong>resilient</strong> distributed systems. <strong>Event-Driven Architecture (EDA)</strong> provides the necessary paradigm shift, centering system logic around immutable facts rather than direct service calls.</p><h3>The Core Concept: The Event</h3><p>At its essence, an <strong>Event</strong> is a digital record of a significant occurrence within a system. It’s not a command telling a service what to do, but a notification that a state change <em>has already happened</em>.</p><ul><li><strong>Fact, Action, State Change:</strong> An event simply states a truth, such as UserSignedUp or InventoryUpdated.</li><li><strong>Immutability:</strong> Events are historical records. Once created, they are permanent and cannot be altered. This property is crucial for <strong>auditing</strong> and <strong>replayability</strong>.</li><li><strong>Durability and Multi-Consumption:</strong> Events are typically stored indefinitely in a log (via a broker), allowing them to be consumed multiple times by different services, both immediately and in the future.</li></ul><h3>EDA Participants: Decoupling the Pipeline</h3><p>The EDA model achieves its characteristic loose coupling by introducing a central intermediary that eliminates direct service awareness:</p><ol><li><strong>Event Producer (Publisher):</strong> A service that generates an event when its state changes. The publisher operates under a “<strong>fire and forget</strong>” model — it emits the event and immediately moves on, with no knowledge of or dependency on downstream consumers.</li><li><strong>Event Consumer:</strong> A service that subscribes to specific event types and reacts to them by executing its own unique business logic. A single event can trigger actions in many independent consumers.</li><li><strong>Message Broker (Router/Bus):</strong> The critical middleware (e.g., Kafka, RabbitMQ) responsible for reliably routing events from producers to all interested consumers. It ensures <strong>reliable delivery</strong> and provides the durably stored event log.</li></ol><h3>EDA vs. Request-Response: A Communication Comparison</h3><p>The fundamental difference between EDA and the common synchronous <strong>Request-Response (R-R)</strong> model lies in communication flow and dependency management.</p><h4>1. Communication Style</h4><p><strong>FeatureRequest-Response Model (Synchronous)Event-Driven Model (Asynchronous)Flow</strong>Sender waits for receiver’s response. <strong>Blocking.</strong>Publisher emits event and proceeds. <strong>Non-blocking.Failure</strong>Receiver failure immediately blocks and fails the sender’s transaction.Publisher is insulated from consumer failures, improving system <strong>fault tolerance</strong> and <strong>throughput</strong>.</p><h4>2. Inversion of Control (IOC)</h4><p>In the R-R model, the caller must know the callee’s API and endpoint, leading to tight coupling. If multiple services need an update, the sender must manage multiple specific API calls.</p><p>In EDA, the <strong>Inversion of Control</strong> is complete:</p><ul><li>The <strong>Publisher</strong> is only aware of the broker and the event contract.</li><li><strong>Consumers</strong> are only aware of the broker and the event contract.</li><li>This extreme lack of awareness between services is the definition of <strong>loose coupling</strong>, allowing services to be deployed, scaled, and updated independently.</li></ul><h3>A Transactional Flow Example</h3><p>Consider a user initiating a service subscription, a process that must be highly resilient:</p><ol><li><strong>User Action:</strong> User initiates subscription.</li><li><strong>Producer Action:</strong> The Subscription Service validates the request, persists its new internal state, and <strong>publishes</strong> a SubscriptionInitiated event. (It’s done, the user is immediately unblocked).</li><li><strong>Parallel Consumption:</strong></li></ol><ul><li><strong>Payment Service</strong> consumes the event, executes payment, and <strong>publishes</strong> a PaymentProcessed event.</li><li><strong>Recommendation Service</strong> <em>also</em> consumes SubscriptionInitiated, pre-seeds a user profile, and waits for PaymentProcessed</li><li><strong>Chained Reaction:</strong> The <strong>Notification Service</strong> consumes PaymentProcessed and sends the final confirmation email.</li></ul><p>This flow is resilient. If the Notification Service is temporarily offline, the event simply remains in the broker until the service recovers and processes it, without requiring the Subscription or Payment services to retry or fail the entire user transaction.</p><h3>High-Impact Use Cases for EDA</h3><p>EDA is particularly effective in scenarios demanding high scale, resilience, and real-time data processing:</p><ul><li><strong>Reliable Delivery/Financials:</strong> Systems where message loss is unacceptable (e.g., money transfers, ledger updates). The persistent event log ensures transactional integrity.</li><li><strong>Fire-and-Forget Workflows:</strong> Asynchronous tasks like generating complex reports, processing background media, or indexing new content, where the user does not expect an immediate API response.</li><li><strong>Data Streams and IoT:</strong> Handling infinite streams of data points (e.g., mobile location data, sensor telemetry). EDA is the natural fit for this high-velocity, continuous data intake.</li><li><strong>Anomaly Detection:</strong> Analyzing streams of events (e.g., requests per second, login attempts) to detect patterns in real-time. A consumer can identify when a threshold is crossed and automatically trigger a scaling or security action.</li><li><strong>System-Wide Broadcasting:</strong> Efficiently propagating state changes across a large number of microservices, such as invalidating a caching layer or updating a product catalog.</li></ul><p>By adopting EDA, teams shift their focus from tightly coordinated API interactions to building autonomous, reactive services that communicate through auditable, durable facts.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d3553df8bd9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>