<?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 Zaina Hala on Medium]]></title>
        <description><![CDATA[Stories by Zaina Hala on Medium]]></description>
        <link>https://medium.com/@zaina-hala?source=rss-d0d035e00f1d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*lxTcqmyR6BrgD7EyJwO7Jg.png</url>
            <title>Stories by Zaina Hala on Medium</title>
            <link>https://medium.com/@zaina-hala?source=rss-d0d035e00f1d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 16:54:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@zaina-hala/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[The Database Query That Quietly Runs 1,000 Times]]></title>
            <link>https://medium.com/backend-engineers-club/the-database-query-that-quietly-runs-1-000-times-ee09e062609a?source=rss-d0d035e00f1d------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee09e062609a</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[backend-development]]></category>
            <dc:creator><![CDATA[Zaina Hala]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 19:50:12 GMT</pubDate>
            <atom:updated>2026-11-14T06:51:35.777Z</atom:updated>
            <content:encoded><![CDATA[<h4>Your ORM is hiding something</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-0vRBc0lRPn4CNR9EwyusQ.png" /><figcaption>Same data, two very different trips: 101 queries vs. one</figcaption></figure><p><strong>The 30-second version:</strong></p><p>Your app looks fine on your laptop.</p><p>Then real users arrive, and one page starts crawling.</p><p>Nothing is broken. No errors. No crashes.</p><p>The cause is often a single innocent line of code that asks the database the same question hundreds of times. Engineers call it the <strong>N+1 query problem</strong>, and it lives in almost every app built with an ORM.</p><p>If you write code, this will save you hours. If you don’t, you’ll finally understand why “the website is slow” is rarely about the website.</p><p>Let’s open it up.</p><h3>A Waiter Who Makes 100 Trips</h3><p>Imagine a restaurant with 100 tables.</p><p>A good waiter takes everyone’s order, walks to the kitchen once, and comes back with a full tray.</p><p>A bad waiter takes one order, walks to the kitchen, comes back. Takes the next order. Walks to the kitchen again. And again. And again.</p><p>Both waiters deliver the same food.</p><p>One of them makes 1 trip. The other makes 100.</p><p>That second waiter is exactly what your code does during an N+1 problem. The food is your data. The kitchen is your database. And every trip costs time.</p><h3>What It Looks Like in Real Code</h3><p>Let’s use Django, but stay with me even if you don’t use it. Every ORM has the same trap.</p><p>Say you run an online store. You have orders, and every order belongs to a customer.</p><pre># models.py<br>class Customer(models.Model):<br>    name = models.CharField(max_length=100)<br><br>class Order(models.Model):<br>    customer = models.ForeignKey(Customer, on_delete=models.CASCADE)<br>    total = models.DecimalField(max_digits=10, decimal_places=2)</pre><p>Now you build a page that lists the latest 100 orders with the customer’s name.</p><pre># views.py<br>def order_list(request):<br>    orders = Order.objects.all()[:100]<br>    return render(request, &quot;orders.html&quot;, {&quot;orders&quot;: orders})</pre><pre>&lt;!-- orders.html --&gt;<br>{% for order in orders %}<br>  &lt;p&gt;{{ order.customer.name }} paid {{ order.total }}&lt;/p&gt;<br>{% endfor %}</pre><p>Clean. Readable. Looks perfect.</p><p>Here’s what actually happens.</p><h3>Counting the Trips</h3><p><strong>Query 1:</strong> Django fetches 100 orders.</p><pre>SELECT * FROM order LIMIT 100;</pre><p>So far so good.</p><p>Then the template loops. On every single row, it touches order.customer.name.</p><p>The customer wasn’t loaded. So Django quietly goes back to the database.</p><pre>SELECT * FROM customer WHERE id = 7;<br>SELECT * FROM customer WHERE id = 12;<br>SELECT * FROM customer WHERE id = 3;<br>...</pre><p>One query for every order.</p><p><strong>1 query for the list + 100 queries for the customers = 101 queries.</strong></p><p>That’s where the name comes from. <strong>N</strong> queries for the items, plus the <strong>1</strong> you started with.</p><h3>“But Each Query Is Fast”</h3><p>Yes. That’s what makes this bug so sneaky.</p><p>On your laptop, the database sits right next to your code. Each query might finish in a fraction of a millisecond. 101 of them still feel instant.</p><p>In production, things change:</p><ul><li>The database is on another machine, so every query crosses a network.</li><li>Other users are hitting the same database at the same time.</li><li>Your list grows from 100 rows to 1,000.</li></ul><p>Do the math with a simple example. If each round trip takes 2 ms, then 1,001 queries means about 2 seconds spent just walking to the kitchen.</p><p>The data itself was tiny. The trips were the problem.</p><p><strong>Slow apps are often not doing too much work. They’re doing small work too many times.</strong></p><h3>Why ORMs Make This So Easy to Miss</h3><p>Here’s the part nobody tells beginners.</p><p>ORMs are lazy on purpose.</p><p>When you write Order.objects.all(), Django doesn&#39;t touch the database yet. It waits until you actually use the data. And when it loads an order, it doesn&#39;t load the customer, the items, or anything else attached to it.</p><p>Why? Because loading everything every time would be wasteful. Most of the time you don’t need it.</p><p>This is called <strong>lazy loading</strong>, and it’s a good default.</p><p>The problem is what happens next. When you finally ask for order.customer, the ORM doesn&#39;t complain. It doesn&#39;t warn you. It just politely runs another query and hands you the result.</p><p>From your side, it looks like reading a property.</p><p>From the database’s side, it’s another knock on the door.</p><p>Think of it like a library that only gives you a book’s title. Every time you want to read a page, you walk back to the front desk and ask for it. One page is fine. A whole book this way takes all day.</p><p>The code reads beautifully. The cost is invisible. That combination is exactly why this bug survives code reviews, passes tests, and ships to production.</p><h3>The Fix Is Usually One Line</h3><p>You tell the ORM up front what you’re going to need.</p><p>For a single related object (a foreign key), Django gives you select_related:</p><pre>orders = Order.objects.select_related(&quot;customer&quot;)[:100]</pre><p>Now Django uses a SQL JOIN and pulls orders and customers together.</p><pre>SELECT order.*, customer.*<br>FROM order<br>JOIN customer ON order.customer_id = customer.id<br>LIMIT 100;</pre><p><strong>101 queries become 1.</strong></p><p>Same page. Same output. One trip to the kitchen.</p><h3>When There Are Many Related Things</h3><p>What if each order has many items?</p><p>A JOIN would repeat the order data for every item and blow up the result. So Django has a second tool: prefetch_related.</p><pre>orders = Order.objects.prefetch_related(&quot;items&quot;)[:100]</pre><p>This runs two queries instead of one:</p><ol><li>Get the 100 orders.</li><li>Get all items for those orders in one go, using WHERE order_id IN (...).</li></ol><p>Django then matches them up in Python.</p><p><strong>Two trips, no matter how many orders you have.</strong></p><p>A quick rule you can remember:</p><ul><li><strong>Pointing to one thing</strong> (ForeignKey, OneToOne): use select_related</li><li><strong>Pointing to many things</strong> (reverse ForeignKey, ManyToMany): use prefetch_related</li></ul><h3>The Trap Inside the Fix</h3><p>You added prefetch_related. You feel great.</p><p>Then you write this:</p><pre>for order in orders:<br>    paid_items = order.items.filter(status=&quot;paid&quot;)</pre><p>And the query count jumps right back up.</p><p>Why? Because .filter() creates a brand new query. Django can&#39;t reuse the items it already loaded, so it goes back to the database for every order. You&#39;re back to N+1, just wearing a different outfit.</p><p>The fix is to tell Django about the filter up front, using a Prefetch object:</p><pre>from django.db.models import Prefetch<br><br>orders = Order.objects.prefetch_related(<br>    Prefetch(<br>        &quot;items&quot;,<br>        queryset=Item.objects.filter(status=&quot;paid&quot;),<br>        to_attr=&quot;paid_items&quot;,<br>    )<br>)[:100]<br><br>for order in orders:<br>    order.paid_items  # already loaded, no new query</pre><p>Same result. Still two queries total.</p><p><strong>If you prefetch something, filter it in the prefetch, not in the loop.</strong></p><h3>It’s Not Just a Django Thing</h3><p>Every major ORM has the same trap and the same escape hatch.</p><ul><li><strong>Rails:</strong> includes</li><li><strong>SQLAlchemy:</strong> joinedload or selectinload</li><li><strong>Prisma:</strong> include</li><li><strong>Laravel:</strong> with</li></ul><p>Different names. Same idea.</p><p>Load what you need before the loop, not inside it.</p><h3>The Hidden Version in Your API</h3><p>Templates aren’t the only place this happens.</p><p>APIs are even worse, because there’s no page to look at. Just a JSON response that takes a little too long.</p><p>Here’s a common Django REST Framework setup:</p><pre>class CustomerSerializer(serializers.ModelSerializer):<br>    class Meta:<br>        model = Customer<br>        fields = [&quot;id&quot;, &quot;name&quot;]<br><br>class OrderSerializer(serializers.ModelSerializer):<br>    customer = CustomerSerializer()<br><br>    class Meta:<br>        model = Order<br>        fields = [&quot;id&quot;, &quot;total&quot;, &quot;customer&quot;]</pre><p>Nested serializers are clean and readable.</p><p>They also loop over every order and touch order.customer one by one. That&#39;s our waiter again.</p><p>The fix lives in the view, not the serializer:</p><pre>class OrderViewSet(viewsets.ReadOnlyModelViewSet):<br>    serializer_class = OrderSerializer<br><br>    def get_queryset(self):<br>        return Order.objects.select_related(&quot;customer&quot;)</pre><p>Here’s the rule I’d tape to every backend developer’s monitor:</p><p><strong>Every nested serializer needs a matching select_related or prefetch_related in the view.</strong></p><p>If you add one without the other, you’ve probably just added an N+1.</p><p>And it gets sneakier as your API grows. A mobile app asks for 20 orders. A dashboard asks for 500. An export job asks for 50,000. The same endpoint, the same bug, getting worse with every client that uses it.</p><h3>Don’t Overcorrect</h3><p>Once people learn about N+1, a new habit appears.</p><p>They add select_related to everything. Every relation. Every view. Just in case.</p><p>That’s a different problem.</p><p>JOINs aren’t free. Pulling in five related tables you never use means bigger queries, more memory, and more data crossing the network. You fixed the many-trips problem by carrying a tray that’s too heavy to lift.</p><p>A few habits keep you balanced:</p><ul><li><strong>Load only the relations the page actually uses.</strong> If the template shows the customer’s name, you need customer. You don&#39;t need customer__address__country.</li><li><strong>Fetch only the columns you need</strong> when tables are wide:</li></ul><pre>orders = Order.objects.select_related(&quot;customer&quot;).only(<br>    &quot;id&quot;, &quot;total&quot;, &quot;customer__name&quot;<br>)</pre><ul><li><strong>Measure before and after.</strong> If a change doesn’t reduce queries or time, it’s not an optimization. It’s just more code.</li></ul><p>The goal was never “as few queries as possible.”</p><p><strong>The goal is the right number of trips, with the right amount on the tray.</strong></p><h3>How to Catch It Before Your Users Do</h3><p>The scary part about N+1 is that it doesn’t throw an error. You have to go looking.</p><p><strong>1. Watch your query count.</strong></p><p>Tools like Django Debug Toolbar show how many queries each page runs. If a simple list page shows 50, 100, or 300 queries, you’ve found one.</p><p><strong>2. Count queries in the shell.</strong></p><p>With DEBUG = True, Django records every query:</p><pre>from django.db import connection<br><br>len(connection.queries)</pre><p>Run your code, check the number, and see if it grows with your data.</p><p><strong>3. Lock it in with a test.</strong></p><p>This is the one most teams skip, and it’s the one that saves you later.</p><pre>class OrderListTest(TestCase):<br>    def test_order_list_query_count(self):<br>        with self.assertNumQueries(1):<br>            list(Order.objects.select_related(&quot;customer&quot;)[:100])</pre><p>If someone removes select_related six months from now, the test fails. The bug never reaches production again.</p><h3>The Bigger Lesson</h3><p>ORMs are wonderful. They let you think in objects instead of SQL.</p><p>But they also hide the cost of every line you write.</p><p>order.customer.name looks like reading a variable. Underneath, it can be a network call to another machine.</p><p>The engineers who build fast systems aren’t always the ones who know the most tricks. They’re the ones who keep asking one simple question:</p><p><strong>“How many times am I going to the kitchen?”</strong></p><h3>Try This Today</h3><ul><li>Open the slowest list page in your app.</li><li>Count the queries it runs.</li><li>Look for any loop that touches a related field.</li><li>Add select_related or prefetch_related.</li><li>Check your API views for nested serializers without a matching fix.</li><li>Write one assertNumQueries test so it stays fixed.</li></ul><p>Six small steps. It might be the easiest speed boost you ever ship.</p><p><em>Thanks for reading. If this helped, a clap helps it reach more engineers, and you can follow me at </em><a href="https://zaina-hala.medium.com/"><strong><em>@zaina-hala</em></strong></a><em> for more posts on the foundations under the buzzwords.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee09e062609a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/backend-engineers-club/the-database-query-that-quietly-runs-1-000-times-ee09e062609a">The Database Query That Quietly Runs 1,000 Times</a> was originally published in <a href="https://medium.com/backend-engineers-club">Backend Engineers Club</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The SQL Execution Order Everyone Gets Half Right]]></title>
            <link>https://medium.com/backend-engineers-club/the-sql-execution-order-everyone-gets-half-right-01cb233e764d?source=rss-d0d035e00f1d------2</link>
            <guid isPermaLink="false">https://medium.com/p/01cb233e764d</guid>
            <category><![CDATA[database-optimization]]></category>
            <category><![CDATA[sofware-engineering]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[sql]]></category>
            <dc:creator><![CDATA[Zaina Hala]]></dc:creator>
            <pubDate>Mon, 03 Aug 2026 20:30:50 GMT</pubDate>
            <atom:updated>2026-08-03T20:30:50.174Z</atom:updated>
            <content:encoded><![CDATA[<h4>Where the real bottleneck actually hides</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*owczHMe1SOAZQ7IAXhyv4Q.png" /><figcaption>SQL’s Hidden OFFSET Bottleneck</figcaption></figure><p>I once spent an afternoon “optimizing” a query by rewriting OFFSET 50000 LIMIT 20 into something cleverer, convinced the LIMIT was the problem. It wasn&#39;t. The OFFSET was silently forcing Postgres to scan and throw away 50,000 rows before it even got to the part I cared about. That&#39;s the moment I actually sat down and learned how SQL is evaluated — not how it reads.</p><p>Most engineers write SQL top to bottom: SELECT, FROM, WHERE, GROUP BY, ORDER BY. That’s the order for <em>humans</em>. The database doesn’t care about your reading order. It has its own sequence, and if you don’t know it, you’ll optimize the wrong line every time.</p><h3>The order your query actually runs in</h3><ol><li><strong>FROM / JOIN</strong> — build the working set</li><li><strong>WHERE</strong> — filter rows</li><li><strong>GROUP BY</strong> — bucket what’s left</li><li><strong>HAVING</strong> — filter the buckets</li><li><strong>SELECT</strong> — pick the columns</li><li><strong>DISTINCT</strong> — dedupe</li><li><strong>ORDER BY</strong> — sort</li><li><strong>LIMIT / OFFSET</strong> — trim the final result</li></ol><p>Think of it like a factory line. Every station only works on what survived the station before it. If your WHERE clause lets 10 million rows through, every station downstream — grouping, sorting, deduping — pays the tax for all 10 million, whether you needed them or not. <strong>The earlier you cut, the less work every later stage has to do.</strong> That part is genuinely important, and it&#39;s why &quot;optimize early&quot; is good advice.</p><h3>Where it gets more interesting than the checklist version</h3><h4><strong>WHERE beats HAVING — but not for the reason people repeat.</strong></h4><p>HAVING runs after grouping, which means the engine has already done the expensive part (aggregating) before it even looks at your HAVING condition. If a condition doesn’t depend on an aggregate, putting it in WHERE means rows get excluded <em>before</em> grouping — smaller groups, less work, done.</p><h4><strong>The “use a subquery to filter before the JOIN” trick is mostly obsolete.</strong></h4><p>This used to matter a lot more than it does today. Postgres, MySQL 8+, and SQL Server all do <em>predicate pushdown</em> — the optimizer looks at your WHERE clause and, if it can, shoves the filter down into the JOIN itself automatically, regardless of how you wrote the query. Your manual subquery and a plain WHERE clause frequently produce the <em>identical</em> execution plan. Where it still matters: window functions, aggregates inside a subquery, or certain outer joins — cases where the optimizer genuinely can’t push the filter past the subquery boundary. Check your EXPLAIN plan before assuming your rewrite did anything.</p><h4><strong>LIMIT and OFFSET are not performance-neutral — this is the part worth remembering.</strong></h4><p>It’s tempting to think “they run last, so they can’t affect speed.” Two things break that assumption:</p><ul><li>ORDER BY indexed_column LIMIT 10 can let the engine stop early. If it&#39;s scanning in index order already, it grabs the first 10 matches and quits — it never touches the rest of the table. That&#39;s a real, measurable win, not a no-op.</li><li>OFFSET is the opposite story. OFFSET 50000 doesn&#39;t teleport past the first 50,000 rows — the database still has to <em>produce</em> and then discard every one of them before returning row 50,001. On a small table, you won&#39;t notice. On a table with millions of rows, deep pagination with OFFSET is one of the most common silent performance killers in production APIs. If you&#39;re paginating past page 20 or so, keyset pagination (WHERE id &gt; last_seen_id LIMIT 20) will almost always beat OFFSET, because it lets the index do the skipping instead of the engine.</li></ul><h3>The actual takeaway</h3><p>Knowing the execution order isn’t about memorizing a list — it’s about knowing which station in the factory line is doing unnecessary work. Filter as early as possible. Move conditions out of HAVING when they don’t need the aggregate. Don’t assume a manual query rewrite beats the optimizer — check the plan. And if your pagination is getting slower as users scroll further, the LIMIT was never the suspect. Look at the OFFSET.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=01cb233e764d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/backend-engineers-club/the-sql-execution-order-everyone-gets-half-right-01cb233e764d">The SQL Execution Order Everyone Gets Half Right</a> was originally published in <a href="https://medium.com/backend-engineers-club">Backend Engineers Club</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hidden Engineering Behind Every AI Model: Storage, Compute, and the Data Pipeline Nobody Talks…]]></title>
            <link>https://pub.towardsai.net/the-hidden-engineering-behind-every-ai-model-storage-compute-and-the-data-pipeline-nobody-talks-6e9558c9ce67?source=rss-d0d035e00f1d------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e9558c9ce67</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Zaina Hala]]></dc:creator>
            <pubDate>Fri, 10 Jul 2026 15:01:01 GMT</pubDate>
            <atom:updated>2026-07-10T15:01:01.890Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Hidden Engineering Behind Every AI Model: Storage, Compute, and the Data Pipeline Nobody Talks About</h3><h4>AI runs on plumbing, not magic.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*__5dDph8uEL1mkad89WtiA.png" /><figcaption>AI Runs on Plumbing</figcaption></figure><p>When people talk about artificial intelligence, they talk about models. GPT. Claude. Gemini. The breakthroughs. The benchmarks. The capabilities that seem to border on science fiction.</p><p>What they almost never talk about is the <strong>engineering underneath.</strong></p><p>Here’s the truth that every machine learning engineer knows but nobody writes Medium articles about: the model is the easy part. The hard part — the part that takes 80% of the time, 90% of the budget, and causes 95% of the failures — is everything that happens <em>before</em> and <em>around</em> the model.</p><p>The data pipeline. The storage architecture. The compute orchestration. The feature engineering. The monitoring. The infrastructure that quietly feeds, trains, serves, and keeps alive the AI systems the world is so excited about.</p><p>I’m a computer engineer, and I think this invisible layer deserves its own spotlight. Because understanding how AI <em>really</em> works means understanding the plumbing — not just the faucet.</p><h3>The Iceberg Problem</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XE-OG-AL2McHXcQyKKJ1vg.png" /><figcaption>The AI Iceberg</figcaption></figure><p>Imagine an iceberg. The part above the water — the visible 10% — is the AI model itself. The architecture. The parameters. The training algorithm. That’s what gets published in papers, featured in demos, and discussed on Twitter.</p><p>The other 90% — the massive structure hidden beneath the surface — is infrastructure:</p><ul><li><strong>Data collection and ingestion</strong> — Where does the training data come from? How is it gathered?</li><li><strong>Data cleaning and preparation</strong> — How do you remove duplicates, fix errors, handle missing values, and structure raw data into something usable?</li><li><strong>Storage architecture</strong> — Where does all this data live? How is it organized, versioned, and accessed at speed?</li><li><strong>Feature engineering</strong> — How do you transform raw data into the specific inputs a model needs?</li><li><strong>Compute orchestration</strong> — How do you coordinate thousands of GPUs across days or weeks of training?</li><li><strong>Model serving</strong> — How do you deploy a trained model so millions of people can use it simultaneously?</li><li><strong>Monitoring and observability</strong> — How do you know the model is still performing correctly after deployment?</li></ul><p>Every single one of these is a deep engineering discipline. And if any of them breaks, the model doesn’t work — no matter how brilliant the algorithm is.</p><h3>Stage 1: Data Collection — Garbage In, Garbage Out (At Scale)</h3><p>Every AI model starts with data. And the scale of data required for modern models is staggering.</p><p>A large language model like GPT-4 or Claude was trained on <strong>trillions of tokens</strong> — essentially, trillions of words scraped from books, websites, code repositories, scientific papers, and public datasets. A vision model might train on billions of images. A multimodal model needs both, plus audio, video, and structured data.</p><p>But raw data is messy. The internet is full of duplicates, spam, outdated information, toxic content, copyrighted material, and outright nonsense. Collecting data at scale is easy. Collecting <em>good</em> data at scale is an engineering nightmare.</p><p><strong>Web crawling</strong> systems visit billions of web pages, extract text, and store it in raw format. But a significant percentage of what they collect is junk — repeated boilerplate, navigation menus, ads, cookie notices, and auto-generated content.</p><p><strong>Deduplication</strong> algorithms compare every piece of text against every other piece to remove near-identical content. At trillion-token scale, this is computationally expensive and requires specialized data structures like MinHash and locality-sensitive hashing.</p><p><strong>Quality filtering</strong> uses classifiers — often smaller AI models themselves — to score content quality. Low-quality, toxic, or irrelevant content gets filtered out. High-quality, informative content gets kept.</p><blockquote><strong><em>The uncomfortable truth:</em></strong><em> Organizations frequently report that they use AI in at least one business function, yet the vast majority don’t see real bottom-line results. The bottleneck is rarely the model — it’s the brittle, legacy data infrastructure feeding it.</em></blockquote><h3>Stage 2: The Data Pipeline — The Assembly Line Nobody Sees</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vslK_VdIBk3Pd4wNVdBYtQ.png" /><figcaption>From Raw Data to Training Dataset</figcaption></figure><p>Once data is collected, it needs to move. Continuously. Reliably. At massive scale.</p><p>A <strong>data pipeline</strong> is the system that transports data from where it’s created to where it’s needed — through a series of transformations along the way. Think of it as a factory assembly line, but instead of physical parts, raw data enters one end and training-ready datasets emerge from the other.</p><h4>The Evolution: ETL → ELT → Real-Time Streaming</h4><p>The data pipeline world has gone through three major eras:</p><p><strong>ETL (Extract, Transform, Load)</strong> was the original approach. Extract data from sources, transform it into the right format, then load it into a data warehouse. This worked for traditional business intelligence — monthly reports, quarterly summaries. But it was slow and rigid.</p><p><strong>ELT (Extract, Load, Transform)</strong> flipped the order. Load the raw data first into cheap cloud storage (a data lake), then transform it on demand using the massive compute power of modern cloud engines like Snowflake or Databricks. This was faster and more flexible.</p><p><strong>In 2026, the frontier is hybrid architectures</strong> — continuous event-streaming merged with ELT. Systems like Apache Kafka stream data in real time, while batch processing handles historical analysis. This combination — sometimes called a “medallion architecture” — lets organizations run both real-time AI inference and large-scale model training from the same data infrastructure.</p><h4>What a Modern AI Data Pipeline Actually Looks Like</h4><p>A single data field being onboarded into a production pipeline might touch six subsystems that must stay perfectly synchronized:</p><ol><li><strong>Configuration registries</strong> — defining what data exists and where it lives</li><li><strong>Routing logic</strong> — deciding which data goes to which processing step</li><li><strong>DAG composition</strong> — organizing the processing steps into a directed acyclic graph (a dependency tree)</li><li><strong>Validation rules</strong> — checking data quality at every stage</li><li><strong>Code generation</strong> — automatically producing the processing code</li><li><strong>Automation scripts</strong> — orchestrating the entire flow</li></ol><p>Tools like <strong>Apache Airflow</strong> manage this orchestration, scheduling jobs, tracking data lineage (where every piece of data came from and what happened to it), and alerting engineers when something breaks.</p><blockquote><strong><em>2026 development:</em></strong><em> AI itself is now being used to generate, optimize, and self-heal data pipelines. Meta’s engineering team recently published how they used AI to map the “tribal knowledge” — undocumented institutional expertise — embedded in their massive data pipelines, making the entire system more maintainable and less dependent on individual engineers who happen to remember how things work.</em></blockquote><h3>Stage 3: Storage Architecture — Where All This Data Lives</h3><p>Training a frontier AI model requires storing and accessing <strong>petabytes</strong> of data. That’s millions of gigabytes. The storage layer needs to be fast enough to keep thousands of GPUs fed with data without any of them sitting idle.</p><h4>The Storage Stack</h4><p><strong>Object storage</strong> (like Amazon S3 or Google Cloud Storage) holds raw data cheaply and at virtually unlimited scale. It’s slow to access randomly but perfect for storing training datasets that are read sequentially.</p><p><strong>Data lakes and lakehouses</strong> organize raw data with metadata and schema, making it searchable and governable. A lakehouse combines the flexibility of a data lake with the structure and query performance of a data warehouse.</p><p><strong>Feature stores</strong> are specialized databases that hold pre-computed “features” — the specific data inputs that machine learning models consume. A feature store like <strong>Feast</strong> ensures that the exact same features used during training are served during inference. This consistency is critical — even a small mismatch can cause silent model degradation.</p><p><strong>Vector databases</strong> store the mathematical representations (embeddings) that AI models use internally. When a language model retrieves information using RAG (Retrieval-Augmented Generation), it’s querying a vector database to find the most semantically similar content. In 2026, vector databases are scaling to billions and even trillions of vectors, requiring architectures that can grow without constant restructuring.</p><h4>The GPU Feeding Problem</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4L4tGNsGGwofanYwVlrLAA.png" /><figcaption>GPU Feeding Problem</figcaption></figure><p>Here’s a fundamental challenge that defines modern AI storage: GPUs are fast. Insanely fast. A cluster of thousands of GPUs can process data faster than most storage systems can deliver it.</p><p>If the storage can’t feed data to the GPUs quickly enough, the most expensive hardware on the planet sits idle — waiting. This is called a <strong>throughput bottleneck</strong>, and it’s one of the most expensive problems in AI infrastructure.</p><p>The solution involves high-performance parallel file systems, NVMe flash storage, and sophisticated prefetching algorithms that predict which data the GPUs will need next and load it in advance. The storage system must sustain throughput rates measured in terabytes per second — continuously, for weeks.</p><h3>Stage 4: Compute Orchestration — Conducting the GPU Orchestra</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eNl--yymhEqu0Tv7qxbUvw.png" /><figcaption>GPU Orchestra</figcaption></figure><p>Training a large AI model isn’t like running a program on your laptop. It’s more like coordinating a symphony orchestra with thousands of musicians — each GPU is a player, and they all need to play in perfect synchronization.</p><h4>How Distributed Training Works</h4><p>No single GPU has enough memory to hold an entire frontier model. So the model and its data are split across thousands of GPUs using techniques like:</p><p><strong>Data parallelism</strong> — Each GPU gets a copy of the full model but processes a different slice of the training data. After each step, the GPUs synchronize their results.</p><p><strong>Model parallelism</strong> — The model itself is split across GPUs. Different layers or components of the neural network live on different machines.</p><p><strong>Pipeline parallelism</strong> — The model is divided into stages, and different micro-batches of data flow through the stages like products on an assembly line.</p><p>In practice, modern training runs use a combination of all three — and managing this coordination is a massive software engineering challenge.</p><h4>The Orchestration Layer</h4><p><strong>Kubernetes</strong> — the container orchestration platform — has been extended with GPU-specific features to manage AI workloads across massive clusters. Specialized schedulers allocate GPU resources, manage job queues, and handle failures.</p><p>Because training runs last days or weeks, <strong>fault tolerance</strong> is critical. If one GPU out of a thousand fails, the system must detect it, reroute the work, and continue training without losing progress. <strong>Checkpointing</strong> — periodically saving the model’s state to storage — ensures that a hardware failure doesn’t waste weeks of compute.</p><blockquote><strong><em>The scale in 2026:</em></strong><em> Google announced at Next ’26 that their Virgo Network can connect over one million TPUs across multiple data center sites into a single training cluster. We’re entering the era where training clusters span not just racks or buildings — but entire campuses.</em></blockquote><h3>Stage 5: Model Serving — From Lab to Production</h3><p>Training a model is expensive. Serving it — making it available to millions of users — is a completely different engineering problem.</p><h4>Training vs. Inference: Different Demands</h4><p><strong>Training</strong> needs maximum throughput — processing as much data as possible, as fast as possible, for days or weeks. Latency doesn’t matter much; nobody is waiting for a real-time response during training.</p><p><strong>Inference</strong> (serving the model to users) needs minimum latency — responding to each request in milliseconds. When you type a message to an AI chatbot, you expect a response to start appearing almost immediately. Behind the scenes, the model needs to process your input, generate tokens one at a time, and stream them back — all within a strict time budget.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZAQ1X64iDhiAF__zLDoAEA.png" /><figcaption>Training vs Serving</figcaption></figure><h4>The Serving Stack</h4><p>Serving a large model at scale requires:</p><p><strong>Load balancers</strong> that distribute millions of requests across multiple instances of the model running on different GPU servers.</p><p><strong>Auto-scaling systems</strong> that spin up more GPU instances during peak demand and scale down during quiet periods — because GPU time is extremely expensive and overprovisioning wastes thousands of dollars per hour.</p><p><strong>Caching layers</strong> that store common responses to avoid recomputing them from scratch.</p><p><strong>Quantization and optimization</strong> — techniques that compress models to run faster and on less powerful hardware without significantly degrading quality. A model might be trained in 32-bit precision but served in 8-bit or even 4-bit, dramatically reducing memory and compute requirements.</p><blockquote><strong><em>The specialized chip frontier:</em></strong><em> Google’s new TPU 8i is engineered specifically for inference, tripling on-chip memory and doubling interconnect bandwidth to minimize latency for agentic AI workflows. The era of “one chip fits all” is over — training and inference increasingly run on purpose-built silicon.</em></blockquote><h3>Stage 6: Monitoring — Keeping the Machine Alive</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tj3mD6pHwd29Vc3hgXJIvw.png" /><figcaption>Model Health Feedback Loop</figcaption></figure><p>A model in production isn’t a “set it and forget it” system. It’s a living piece of infrastructure that degrades over time.</p><p><strong>Model drift</strong> happens when the real-world data changes but the model stays the same. A model trained on 2024 data might give increasingly wrong answers in 2026 because the world has changed — new products, new terminology, new patterns.</p><p><strong>Data drift</strong> occurs when the incoming data distribution shifts from what the model was trained on. If a fraud detection model was trained on transaction patterns from one region and starts receiving data from a completely different market, its accuracy will drop.</p><p><strong>Monitoring systems</strong> continuously track model performance — accuracy, latency, error rates, confidence scores — and alert engineering teams when metrics degrade below acceptable thresholds. Some advanced systems automatically trigger retraining pipelines when drift is detected.</p><p><strong>Observability</strong> goes deeper than monitoring. Every inference request can be logged with its inputs, outputs, and the model’s internal confidence. This creates an audit trail for debugging, compliance, and continuous improvement.</p><h3>Why This Matters More Than the Model</h3><p>Here’s the thing that the AI discourse consistently gets wrong: <strong>the model is not the product. The system is the product.</strong></p><p>The most sophisticated neural network in the world is useless without a pipeline to feed it data, storage to hold that data, compute to train it, infrastructure to serve it, and monitoring to keep it healthy.</p><p>The organizations that are winning in AI in 2026 aren’t necessarily the ones with the most advanced models. They’re the ones with the most robust <em>infrastructure</em> — the ones who invested in data quality, pipeline reliability, and operational excellence long before they worried about model architecture.</p><p>A recent finding puts this starkly: 78% of organizations now use AI in at least one business function, but the overwhelming majority don’t see real business value from it. The gap isn’t the algorithm. It’s the plumbing.</p><p>The next time someone shows you a mind-blowing AI demo, remember: behind that demo are data engineers building pipelines, storage architects designing systems to feed GPUs at terabytes per second, infrastructure engineers coordinating thousands of processors, and operations teams monitoring it all around the clock.</p><p>The model gets the applause. The infrastructure does the work.</p><h3>🙌 If This Changed How You Think About AI…</h3><p>Thank you for reading this entire deep dive! This article took extensive research, and your support is what makes the next one happen.</p><p>Here’s how you can help and I genuinely mean every word:</p><p>👏 <strong>Hold down the clap button until it hits 50</strong> — each clap signals to Medium’s algorithm that this article deserves to reach more engineers, data scientists, and tech enthusiasts who need to hear the infrastructure side of the AI story.</p><p>➕ <strong>Follow me</strong> on Medium <a href="https://medium.com/@elsa-andrea">@elsa-andrea</a> — I publish weekly deep dives on the real engineering behind AI, cloud, infrastructure, and modern systems. I write about the parts that matter but rarely make headlines.</p><p>💬 <strong>Share or repost this article</strong> with someone who thinks AI is “just the model.” Let’s spread some love for the data engineers and infrastructure teams who make it all work.</p><p>Every single clap, follow, and comment fuels my motivation to keep researching and writing these pieces. Knowing that someone out there read 2,000+ words about data pipelines and storage architecture — and actually enjoyed it — is the best feeling in the world. You’re the reason I write. 💙</p><p><strong>Coming up next:</strong> <em>Edge Computing Explained: Why Your Data Is Moving Closer to You</em> — follow me so you don’t miss it!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e9558c9ce67" width="1" height="1" alt=""><hr><p><a href="https://pub.towardsai.net/the-hidden-engineering-behind-every-ai-model-storage-compute-and-the-data-pipeline-nobody-talks-6e9558c9ce67">The Hidden Engineering Behind Every AI Model: Storage, Compute, and the Data Pipeline Nobody Talks…</a> was originally published in <a href="https://pub.towardsai.net/">Towards AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Platform Engineering vs DevOps: Why Your Team Is Making the Switch in 2026]]></title>
            <link>https://pub.towardsai.net/platform-engineering-vs-devops-why-your-team-is-making-the-switch-in-2026-00eee308957f?source=rss-d0d035e00f1d------2</link>
            <guid isPermaLink="false">https://medium.com/p/00eee308957f</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <dc:creator><![CDATA[Zaina Hala]]></dc:creator>
            <pubDate>Wed, 29 Apr 2026 22:01:01 GMT</pubDate>
            <atom:updated>2026-04-29T22:01:01.676Z</atom:updated>
            <content:encoded><![CDATA[<h4>DevOps didn’t fail. It outgrew itself.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EHCn6TGJCICxGTs74BClVQ.png" /><figcaption>DevOps vs Platform Engineering Evolution</figcaption></figure><p>There’s a quiet revolution happening inside engineering organizations right now — and if you’re a developer, you’ve probably already felt it.</p><p>For over a decade, DevOps was the gold standard. Break down the silos. Automate the pipelines. “You build it, you run it.” It was brilliant. It changed everything.</p><p>But somewhere along the way, “you build it, you run it” quietly turned into “you build it, you run it, you monitor it, you debug the Kubernetes manifest at 2 AM, you manage the Terraform state, you rotate the secrets, you update the Helm charts, and you also write features — eventually.”</p><p>That’s not collaboration. That’s cognitive overload.</p><p>And that’s exactly why 2026 is the year <strong>platform engineering</strong> stops being a buzzword and starts becoming the default operating model for serious engineering teams.</p><p>I’m a computer engineer, and I’ve watched this shift unfold from the infrastructure side. So let’s break down what’s actually happening, why DevOps is hitting its limits, what platform engineering really is, and whether your team should care.</p><h3>The Problem Nobody Wants to Admit About DevOps</h3><p>DevOps emerged in 2009 as a cultural movement. The idea was simple and powerful: developers and operations teams should stop throwing code over the wall to each other and start collaborating. Share responsibility. Automate everything. Ship fast and fix fast.</p><p>And it worked. Beautifully. For years.</p><p>But here’s what happened as companies scaled: the toolchains exploded. A modern cloud-native stack in 2026 might include Kubernetes, Docker, Terraform, Helm, ArgoCD, GitHub Actions, Prometheus, Grafana, Vault, Open Policy Agent, multiple cloud providers, and a dozen internal scripts held together with hope and YAML.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xdX4QS7REEO4T3lkwA8vKA.png" /><figcaption>Cognitive Overload in DevOps</figcaption></figure><p>Every developer on the team is expected to understand all of this. Not just their application code — the entire operational stack beneath it.</p><p>The result? <strong>Three problems that DevOps alone can’t solve:</strong></p><p><strong>1. Cognitive overload.</strong> Developers spend more time wrestling with infrastructure than writing business logic. Every tool switch costs 15–23 minutes of refocusing time. Multiply that across an organization and entire workdays vanish into context switching.</p><p><strong>2. Tribal knowledge.</strong> Infrastructure expertise concentrates in a handful of senior engineers who become the default escalation point for everything — deployments, permissions, incidents, architecture decisions. When those people leave, the knowledge leaves with them.</p><p><strong>3. Inconsistency at scale.</strong> When every team makes its own infrastructure choices, you end up with dozens of slightly different CI/CD pipelines, deployment patterns, and security configurations. Governance becomes a nightmare. Onboarding new engineers takes weeks instead of days.</p><p>DevOps gave teams autonomy. But autonomy without guardrails, at scale, creates chaos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-bvjsdT8U_ElbGVEI7RukQ.png" /><figcaption>DevOps Scaling Failure Points</figcaption></figure><h3>So What Is Platform Engineering, Really?</h3><p>Platform engineering is the discipline of building <strong>Internal Developer Platforms (IDPs)</strong> — centralized, self-service systems that give developers everything they need to build, deploy, and operate applications without drowning in infrastructure complexity.</p><p>Here’s the simplest way I can explain it:</p><blockquote><strong><em>DevOps says:</em></strong><em> “Developers and operations should collaborate and share tools.”</em></blockquote><blockquote><strong><em>Platform engineering says:</em></strong><em> “Let’s build a dedicated team that creates a </em>product<em> — a platform — that makes collaboration effortless.”</em></blockquote><p>The key word is <strong>product</strong>. A platform engineering team treats its internal developer platform the same way a product team treats a customer-facing application. It has a roadmap. It has users (developers). It has feedback loops. It has a goal: make developers’ lives easier so they can focus on what matters — shipping features.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0-O53uqQyYi_eXZtJ53YbA.png" /><figcaption>What Is Platform Engineering</figcaption></figure><p>What does an IDP actually look like in practice? It typically includes:</p><p><strong>Self-service infrastructure.</strong> A developer can spin up a staging environment, provision a database, or deploy a service in minutes — through a portal or a CLI — without filing a ticket or waiting for ops.</p><p><strong>Golden Paths.</strong> These are opinionated, pre-built workflows that represent the “recommended way” to do things. Need to deploy a new microservice? Follow the golden path: it handles the container build, the Kubernetes config, the CI/CD pipeline, the monitoring setup, and the security scanning — all baked in.</p><p><strong>Abstracted complexity.</strong> Developers don’t need to write raw Terraform or Kubernetes manifests. The platform exposes high-level, simple interfaces that hide the infrastructure details. You describe <em>what</em> you want; the platform figures out <em>how</em>.</p><p><strong>Built-in governance.</strong> Security policies, compliance checks, and best practices are embedded directly into the platform. Every service deployed through the IDP is automatically compliant — no manual audits, no scattered policies.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ic_JnNUhqY2OcHNvhQAXcg.png" /><figcaption>Internal Developer Platform Architecture</figcaption></figure><h3>The Kitchen Analogy That Makes It Click</h3><p>Abby Bangser, a well-known platform engineering advocate, used a brilliant cooking analogy that I think captures this perfectly. Let me build on it:</p><p><strong>Traditional IT (pre-DevOps):</strong> You want to cook dinner, but you have to submit a request for ingredients and tools. Someone in provisioning might send you a frying pan — but it could take days, and it might not be the right size. You wait. You’re frustrated. You make do.</p><p><strong>DevOps:</strong> You get access to the full kitchen. You can grab any ingredient, use any tool, cook anything you want. Freedom! But now <em>you</em> have to maintain the kitchen. You’re growing your own herbs, forging your own pans, cleaning the oven, and still expected to cook a great meal. It’s empowering — and exhausting.</p><p><strong>Platform engineering:</strong> A dedicated team designs and maintains a <em>world-class kitchen</em>. The herbs are pre-grown and organized. The pans are selected and maintained. The oven is pre-heated. The recipes (golden paths) are tested and optimized. You walk in, grab what you need, and focus entirely on cooking an amazing meal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DHh3vujEBWk2OeWomJ498A.png" /><figcaption>DevOps vs Platform Kitchen Analogy</figcaption></figure><p>You still own the cooking. But the kitchen is no longer your problem.</p><h3>What a Platform Engineer Actually Does</h3><p>This raises an obvious question: if platform engineers aren’t DevOps engineers with a new title, what <em>are</em> they?</p><p>Platform engineers are <strong>internal product builders</strong>. Their “customers” are the developers inside their own company. Their daily work involves:</p><p><strong>Talking to developers</strong> to understand pain points, bottlenecks, and unmet needs. What’s slowing them down? What tasks are repetitive? Where do they get stuck?</p><p><strong>Designing and building the IDP</strong> — creating self-service interfaces, automating provisioning, building templates, writing documentation, and integrating tools into a cohesive platform.</p><p><strong>Maintaining golden paths</strong> — continuously improving the recommended workflows based on usage data and developer feedback.</p><p><strong>Embedding security and compliance</strong> into the platform so that governance is automatic, not an afterthought.</p><p><strong>Evangelizing the platform internally</strong> — onboarding teams, running demos, gathering feedback, and iterating. Just like any product team would.</p><p>This is a fundamentally different job than a DevOps engineer who manages pipelines and responds to incidents for specific applications. Platform engineers work <em>across</em> the entire organization, building infrastructure that every team benefits from.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8BUEetdVJDWMqZJD0kwOAw.png" /><figcaption>Platform Engineer as Product Builder</figcaption></figure><p>And the market reflects this. Platform engineers now command an average salary of roughly $193,000 in North America — about 27% higher than DevOps professionals. That premium reflects the specialized skills and strategic impact of the role.</p><h3>“Does This Mean DevOps Is Dead?”</h3><p>No. And anyone telling you that is selling something.</p><p>Platform engineering doesn’t replace DevOps. It <strong>evolves</strong> it. DevOps principles — collaboration, automation, continuous improvement, shared ownership — are still at the core. Platform engineering is the <em>implementation layer</em> that makes those principles sustainable at scale.</p><p>Think of it this way:</p><blockquote><em>DevOps is the </em><strong><em>philosophy</em></strong><em>. Platform engineering is the </em><strong><em>product</em></strong><em> that makes the philosophy work when you have 50, 500, or 5,000 developers.</em></blockquote><p>Small teams (under 20 developers) often don’t need a dedicated platform team. DevOps practices with shared tooling work fine at that scale. But once you cross 50+ developers, the complexity compounds. Pipelines diverge. Standards erode. Knowledge silos form. That’s when platform engineering becomes not just helpful — but necessary.</p><p>The organizations succeeding in 2026 aren’t choosing between DevOps and platform engineering. They’re using platform engineering to make DevOps sustainable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nLyf7jSyK52Wu3ulqs800g.png" /><figcaption>DevOps vs Platform Engineering Relationship</figcaption></figure><h3>The Numbers That Tell the Story</h3><p>The shift isn’t just philosophical — it’s measurable:</p><p><strong>Gartner predicts</strong> that by the end of 2026, over 80% of large software engineering organizations will have dedicated platform engineering teams — up from 45% in 2022.</p><p><strong>High-maturity platform teams report</strong> 40–50% reductions in developer cognitive load — meaning developers spend significantly less time on infrastructure and more time on features.</p><p><strong>Developer onboarding</strong> drops from weeks to days when a mature IDP provides self-service environments and pre-configured toolchains.</p><p><strong>Deployment frequency</strong> increases because golden paths remove the friction that slows teams down — inconsistent configs, manual approvals, and scattered tooling.</p><p><strong>The salary premium</strong> for platform engineers over DevOps engineers (roughly 27%) signals that the market values this specialization — and expects it to grow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QQyqhmrkoXWGXttiQZaGbw.png" /><figcaption>Platform Engineering Impact Metrics</figcaption></figure><h3>What Comes Next: AI Meets Platform Engineering</h3><p>Here’s the frontier that’s emerging right now in 2026: <strong>AI-powered platforms</strong>.</p><p>Platform engineering teams are beginning to integrate AI agents directly into their IDPs. These agents can:</p><ul><li><strong>Auto-heal infrastructure</strong> — detect anomalies, diagnose root causes, and apply fixes without human intervention for routine issues.</li><li><strong>Optimize cloud costs (FinOps)</strong> — analyze usage patterns and automatically right-size resources.</li><li><strong>Generate golden paths</strong> — suggest optimized deployment configurations based on application type and team patterns.</li><li><strong>Accelerate onboarding</strong> — an AI assistant embedded in the IDP that answers developer questions, explains platform features, and walks through workflows.</li></ul><p>This is still early, but the direction is clear: the IDP of the future won’t just be a self-service portal — it’ll be an intelligent system that actively helps developers make better decisions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Nch6AnKn6N6BnMpLyH9Bg.png" /><figcaption>AI-Powered Developer Platform</figcaption></figure><h3>Should Your Team Make the Switch?</h3><p>If you’re on a small team shipping a single product, traditional DevOps practices are probably serving you well. Don’t over-engineer.</p><p>But if you recognize any of these symptoms, it’s time to think about platform engineering:</p><ul><li>Developers spend more time on infrastructure tasks than writing code.</li><li>Onboarding new engineers takes weeks because of tooling complexity.</li><li>Your “DevOps experts” have become bottlenecks for every deployment question.</li><li>Different teams use different CI/CD patterns, creating inconsistency and risk.</li><li>Security and compliance audits are painful because policies are scattered.</li><li>Tool switching and context changes are eating your team’s productivity.</li></ul><p>The fix isn’t hiring more DevOps engineers. It’s building a platform that removes the need for every developer to <em>be</em> a DevOps engineer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dfoW53xTj453yVPtXCQT0g.png" /><figcaption>When to Adopt Platform Engineering</figcaption></figure><h3>The Bottom Line</h3><p>DevOps changed how we build software. Platform engineering is changing how we <em>organize</em> to build software.</p><p>It’s not a replacement — it’s a maturation. The same principles of collaboration, automation, and continuous improvement now live inside a centralized, product-driven platform that scales with your organization instead of against it.</p><p>In 2026, the question for engineering leaders isn’t <em>whether</em> to invest in platform engineering. It’s whether their internal platforms will be <strong>intentional</strong> — or <strong>accidental</strong>.</p><p>The best teams are already building. The rest are still filing Jira tickets for a staging environment.</p><h3>🙌 If This Article Resonated With You…</h3><p>Thank you for reading to the end! Each article takes hours of research and writing, and your support is what makes the next one possible.</p><p>Here’s how you can help — and it really does matter:</p><p>👏 <strong>Clap up to 50 times</strong> — just hold down the clap button! Each clap helps Medium’s algorithm push this article to more engineers who are navigating the same challenges.</p><p>➕ <strong>Follow me</strong> on Medium <a href="https://medium.com/@elsa-andrea">@elsa-andrea</a> — I publish weekly deep dives on the real engineering behind AI, cloud, DevOps, and modern infrastructure. No hype. No fluff. Just how things actually work.</p><p>Your claps and follows aren’t just vanity metrics for me — they’re fuel. Every notification that someone clapped 50 times or hit follow gives me the energy to research and write the next piece. You’re literally powering this publication. 💙</p><p><strong>Coming up next:</strong> <em>How Data Centers Actually Work: From Cooling Systems to GPU Clusters</em> — follow me so you don’t miss it!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=00eee308957f" width="1" height="1" alt=""><hr><p><a href="https://pub.towardsai.net/platform-engineering-vs-devops-why-your-team-is-making-the-switch-in-2026-00eee308957f">Platform Engineering vs DevOps: Why Your Team Is Making the Switch in 2026</a> was originally published in <a href="https://pub.towardsai.net/">Towards AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Data Centers Actually Work: From Cooling Systems to GPU Clusters]]></title>
            <link>https://pub.towardsai.net/how-data-centers-actually-work-from-cooling-systems-to-gpu-clusters-a23918104762?source=rss-d0d035e00f1d------2</link>
            <guid isPermaLink="false">https://medium.com/p/a23918104762</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[data-center]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Zaina Hala]]></dc:creator>
            <pubDate>Thu, 23 Apr 2026 23:01:02 GMT</pubDate>
            <atom:updated>2026-04-23T23:01:02.268Z</atom:updated>
            <content:encoded><![CDATA[<h4>The factories behind your favorite apps.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y02imH0Hi9hhGE6MU5trdQ.png" /><figcaption>The AI Factory</figcaption></figure><p>Every time you ask ChatGPT a question, stream a movie on Netflix, or scroll through Instagram, your request travels to a building you’ll probably never see. Inside that building are rows upon rows of machines — humming, blinking, and generating enough heat to warm a small town.</p><p>If you can’t see the full story, Click me and unlock full story</p><p>That building is a <strong>data center</strong>. And in 2026, data centers aren’t just warehouses full of servers anymore. They’re becoming <strong>AI factories</strong> — purpose-built industrial facilities designed to produce intelligence at scale.</p><p>I’m a computer engineer, and I think data centers are one of the most underappreciated engineering marvels of our time. Most people imagine a room full of computers. The reality is far more complex — and far more interesting.</p><p>So let’s go inside. From the power that flows in, to the heat that flows out, to the GPU clusters that are reshaping these buildings from the ground up — here’s how data centers actually work.</p><h3>What a Data Center Actually Is</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Khb55Dy3fs8sudnq4eseNA.png" /><figcaption>Five Layers of a Data Center</figcaption></figure><p>At its most basic, a data center is a facility designed to house, power, cool, and connect large numbers of computers. But calling it “a room full of computers” is like calling a hospital “a building with beds.” The infrastructure surrounding those machines is what makes everything work.</p><p>A modern data center has <strong>five critical layers:</strong></p><ol><li><strong>Power systems</strong> — bringing electricity in and keeping it reliable.</li><li><strong>Cooling systems</strong> — removing the enormous heat generated by thousands of processors.</li><li><strong>Compute hardware</strong> — the servers, GPUs, CPUs, and storage that do the actual work.</li><li><strong>Networking</strong> — connecting machines to each other and to the outside world.</li><li><strong>Physical security</strong> — protecting millions of dollars of hardware and billions of bytes of data.</li></ol><p>Each of these layers is an engineering discipline in its own right. Let’s walk through them.</p><h3>Power: The Lifeblood</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9gJdnlNA7tCGp5UYr7Sc-g.png" /><figcaption>Grid to Rack</figcaption></figure><p>A data center without power is just an expensive warehouse. Power infrastructure is the foundation everything else sits on.</p><p><strong>How much power are we talking about?</strong> A traditional enterprise data center might use 5–10 megawatts. A modern hyperscale facility built for AI — the kind operated by Google, Microsoft, Meta, or Amazon — can consume 100+ megawatts. That’s enough electricity to power a small city.</p><p>The power enters the facility from the utility grid and passes through multiple layers of protection:</p><p><strong>Substations and transformers</strong> step the voltage down from high-voltage transmission lines to levels the equipment can use.</p><p><strong>Uninterruptible Power Supplies (UPS)</strong> contain massive battery banks that kick in instantly if grid power fails. They bridge the gap — usually just seconds — until backup generators start.</p><p><strong>Diesel generators</strong> provide long-term backup power. Most facilities maintain enough fuel to run for 24–72 hours without grid power. Some hyperscalers are now exploring natural gas and even small modular nuclear reactors as alternatives.</p><p><strong>Power Distribution Units (PDUs)</strong> route electricity from the UPS to individual server racks.</p><p>The industry measures efficiency using a metric called <strong>Power Usage Effectiveness (PUE)</strong>. A PUE of 1.0 would mean every watt goes to computing. In reality, a significant portion goes to cooling and other infrastructure. The industry average in 2026 hovers around 1.3–1.5, meaning 30–50% of total power is used for non-compute purposes. The best hyperscale facilities achieve PUEs below 1.1.</p><blockquote><strong><em>Why power matters now more than ever:</em></strong><em> GPU clusters for AI consume dramatically more power than traditional servers. A single rack of NVIDIA H100 GPUs can pull 40 kilowatts. The newest Blackwell-based racks exceed 120 kW. NVIDIA’s upcoming Vera Rubin NVL72 configuration — 72 GPUs in a single rack — pushes past 200 kW. Power availability has become the primary constraint for new data center construction. It’s no longer about finding land or laying fiber — it’s about securing megawatts.</em></blockquote><h3>Cooling: The Silent Engineering Battle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rfL9oue5Gw0Vf8_a6uKzTQ.png" /><figcaption>Air vs Liquid</figcaption></figure><p>Here’s a fact that surprises most people: <strong>cooling accounts for roughly 40% of a data center’s total energy consumption.</strong> The heat problem is so significant that cooling has evolved from a supporting system to a central component of data center architecture — influencing building design, layout, and even geographic location.</p><p>Every watt of electricity consumed by a processor is eventually converted to heat. That heat must be removed, or the equipment fails. Let’s look at how:</p><h4>Air Cooling — The Traditional Approach</h4><p>For decades, the standard method was simple: <strong>blow cold air over the servers.</strong></p><p>Most data centers use a <strong>hot aisle / cold aisle</strong> layout. Servers are arranged in rows so that all the cool air intakes face one aisle (the cold aisle) and all the exhaust fans face the other (the hot aisle). Computer Room Air Conditioning (CRAC) units push cold air under a raised floor, where it flows up through perforated tiles into the cold aisle.</p><p>This works well for traditional servers generating 5–10 kW per rack. But air cooling hits a physical wall at roughly 20 kW per rack. Beyond that, you simply can’t move enough air fast enough to keep the chips cool.</p><p>And modern GPU racks start at 40 kW.</p><h4>Liquid Cooling — The 2026 Standard</h4><p>This is where things get fascinating. Liquid cooling has moved from experimental to standard specification for AI infrastructure:</p><p><strong>Direct-to-chip cooling</strong> runs coolant — typically water or specialized fluid — through cold plates that sit directly on top of the hottest components (GPUs and CPUs). The liquid absorbs heat far more efficiently than air — roughly 3,500 times more effectively, in fact. The heated liquid then circulates to a <strong>Coolant Distribution Unit (CDU)</strong>, where it transfers heat to the building’s chilled water loop or an external heat rejection system.</p><p><strong>Rear-door heat exchangers</strong> attach to the back of server racks. Hot exhaust air passes through a coil of chilled water on its way out, removing heat before it reaches the room.</p><p><strong>Immersion cooling</strong> is the most dramatic approach: servers are literally submerged in tanks of non-conductive liquid. Some systems use <strong>two-phase immersion</strong> — the liquid boils on contact with hot components, turns to vapor, rises, condenses on a cool surface, and drips back down. It’s like a self-contained rain cycle inside a tank.</p><blockquote><strong><em>2026 reality check:</em></strong><em> NVIDIA’s latest Vera Rubin NVL72 rack is fully liquid-cooled, fanless, and cableless — exceeding 200 kW in a single enclosure. Air cooling these machines isn’t just inefficient — it’s physically impossible.</em></blockquote><h4>Where Does All That Heat Go?</h4><p>An increasingly creative answer: <strong>it gets reused.</strong> AI data centers produce enormous waste heat, and forward-thinking operators are capturing it instead of venting it into the atmosphere. In Scandinavian countries, data center waste heat already warms thousands of homes through district heating networks. In 2026, heat-reuse infrastructure is being built directly into new data center designs worldwide.</p><h3>Compute: The Machines That Do the Work</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lWVFS93fqQjVPrClr24B0w.png" /><figcaption>AI Compute Fabric</figcaption></figure><p>Inside those cooled, powered racks live the machines that actually process your requests.</p><h4>Traditional Servers (CPU-Based)</h4><p>Most of the internet still runs on <strong>CPU-based servers</strong>. Web applications, databases, email systems, and business software — these workloads use standard server hardware with multi-core processors, memory, and storage drives.</p><p>A typical server rack might hold 20–40 servers, each with one or two CPUs. These racks are well-understood, efficiently cooled with air, and represent the backbone of cloud computing as we know it.</p><h4>GPU Clusters (The AI Revolution)</h4><p>Then there are the GPU racks — and this is where data centers are being fundamentally redesigned.</p><p><strong>Why GPUs for AI?</strong> A CPU is designed to handle a few complex tasks very quickly (like running your operating system). A GPU is designed to handle thousands of simple tasks <em>simultaneously</em> (like matrix multiplications — the core math behind neural networks). A single NVIDIA H100 GPU contains over 16,000 cores. A cluster of thousands of these GPUs can train AI models with billions of parameters.</p><p>But GPU clusters aren’t just “more computers.” They create unique infrastructure demands:</p><p><strong>Extreme power density.</strong> Where a CPU server rack might draw 10 kW, a GPU rack pulls 40–200+ kW. The power infrastructure must be dramatically upgraded.</p><p><strong>Continuous operation.</strong> GPU clusters run at near-100% utilization for days or weeks during AI model training. There’s no idle time, no downtime for cooling to catch up. The thermal load is sustained and relentless.</p><p><strong>Ultra-fast networking.</strong> For thousands of GPUs to function as a single system, they need to communicate with each other at extraordinary speeds. Technologies like <strong>InfiniBand</strong> and advanced <strong>800 Gbps Ethernet</strong> connect GPU nodes with latencies measured in microseconds. The performance of a cluster often depends more on the network connecting the GPUs than on the GPUs themselves.</p><blockquote><strong><em>Scale check:</em></strong><em> The largest AI clusters in 2026 exceed 100,000 GPUs in a single deployment. These aren’t incremental upgrades — they’re industrial-scale facilities purpose-built to produce artificial intelligence.</em></blockquote><h3>Networking: The Invisible Backbone</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Plp4-Oq0YiUebb0liP8UTA.png" /><figcaption>Leaf-Spine Fabric</figcaption></figure><p>A data center’s network is what connects everything — machines to each other, and the facility to the outside world.</p><p><strong>Inside the data center</strong>, a layered network architecture connects servers to switches, switches to aggregation layers, and aggregation to core routers. For AI clusters, specialized fabrics like InfiniBand create a mesh that allows any GPU to communicate with any other GPU at near wire speed.</p><p><strong>Outside the data center</strong>, high-capacity fiber optic connections link the facility to internet backbone networks, other data centers, and CDN edge servers. Major data center campuses sit at the intersection of multiple fiber routes, providing redundancy and low-latency connectivity to global networks.</p><p><strong>Why networking constrains AI more than you’d think:</strong> You can buy all the GPUs you want, but if the network between them can’t move data fast enough, they sit idle waiting for each other. In many large deployments, network port density and optical component supply now limit cluster size more than GPU availability. The interconnect has become the bottleneck.</p><h3>Physical Security: More Than Locked Doors</h3><p>Data centers hold some of the most valuable — and sensitive — information on the planet. Physical security is taken extremely seriously:</p><p><strong>Multi-layer perimeter security</strong> includes fences, barriers, security guards, and vehicle checkpoints. <strong>Biometric access control</strong> (fingerprint, iris scan, or facial recognition) restricts entry to authorized personnel only. <strong>Mantrap entrances</strong> — small rooms where one door must close before the next opens — prevent tailgating. <strong>24/7 video surveillance</strong> covers every angle of the facility. <strong>Environmental monitoring</strong> tracks temperature, humidity, water leaks, and fire risk across every zone.</p><p>Some hyperscale facilities are built in undisclosed locations. You could drive past one and never know it — they’re often designed to look like ordinary warehouses or office buildings.</p><h3>The Shift: From Data Center to AI Factory</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YjGR__dquOgGiIsTH1BrgQ.png" /><figcaption>Traditional vs AI Data Center</figcaption></figure><p>Here’s the biggest transformation happening in 2026: data centers are being <strong>redesigned from the ground up around AI workloads.</strong></p><p>Traditional data centers were built for general-purpose computing — flexible facilities that could host any mix of web servers, databases, and cloud applications. The new generation is different. These are <strong>AI factories</strong>: specialized environments engineered for one primary purpose — training and running artificial intelligence at industrial scale.</p><p>What makes an AI factory different?</p><p><strong>GPU-centric layout.</strong> Instead of rows of standard server racks, AI factories are designed around dense GPU clusters with liquid cooling infrastructure integrated from day one. The chip drives the building design — not the other way around.</p><p><strong>Massive power density.</strong> AI factories require dedicated power substations, often with direct connections to the utility grid at medium or high voltage. Some are being co-located with power plants.</p><p><strong>Integrated cooling.</strong> Liquid cooling isn’t retrofitted — it’s foundational. Piping for coolant runs through the facility like plumbing in a building, with CDUs positioned alongside every row of GPU racks.</p><p><strong>Cluster-aware networking.</strong> The network isn’t just connectivity — it’s part of the compute architecture. High-speed fabrics are designed to make thousands of GPUs behave as a single, coordinated system.</p><blockquote><em>NVIDIA’s CEO Jensen Huang has called data centers “the factories of the AI era” — and the analogy is precise. Just as factories in the industrial revolution were purpose-built to produce goods at scale, AI factories are purpose-built to produce intelligence at scale.</em></blockquote><h3>Why This Matters to You</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rRwM9yFC0uvYfio0hZHovQ.png" /><figcaption>Request → AI → Response</figcaption></figure><p>You might never visit a data center. But every digital experience you have — every search, every stream, every AI conversation — depends on one.</p><p>Understanding how data centers work gives you a deeper appreciation for the physical infrastructure behind the digital world. The cloud isn’t floating in the sky. It’s running in carefully engineered buildings, consuming real electricity, generating real heat, and requiring real engineering to keep running 24/7/365.</p><p>In 2026, data centers are at the center of the biggest infrastructure buildout since the electrical grid. The AI revolution isn’t just a software story — it’s a story about power, cooling, chips, and the buildings that house them.</p><p>The next time someone says “it’s in the cloud,” you’ll know exactly where the cloud lives.</p><h3>🙌 If You Learned Something New…</h3><p>Thank you for making it to the end! These deep dives take serious research, and knowing that real people are reading them cover-to-cover is what keeps me going.</p><p>Here’s how you can help — and I truly mean it:</p><p>👏 <strong>Hold down that clap button until it hits 50</strong> — each clap tells Medium’s algorithm to share this article with more curious engineers and tech enthusiasts like you.</p><p>➕ <strong>Follow me</strong> on Medium <a href="https://medium.com/@elsa-andrea">@elsa-andrea</a> — I publish weekly deep dives on the real engineering behind AI, cloud, infrastructure, and software systems. No fluff. No hype. Just clarity.</p><p>Every clap, follow, and share is genuine fuel for me. Writing these articles takes hours, and knowing they’re helping people understand technology better gives me all the energy I need for the next one. 💙</p><p><strong>Coming up next:</strong> <em>The Hidden Engineering Behind Every AI Model: Storage, Compute, and the Data Pipeline Nobody Talks About</em> — follow me so you don’t miss it!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a23918104762" width="1" height="1" alt=""><hr><p><a href="https://pub.towardsai.net/how-data-centers-actually-work-from-cooling-systems-to-gpu-clusters-a23918104762">How Data Centers Actually Work: From Cooling Systems to GPU Clusters</a> was originally published in <a href="https://pub.towardsai.net/">Towards AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Agents Explained: What They Are, How They Work, and Why 2026 Is Their Year]]></title>
            <link>https://zaina-hala.medium.com/ai-agents-explained-what-they-are-how-they-work-and-why-2026-is-their-year-e19f8404fd81?source=rss-d0d035e00f1d------2</link>
            <guid isPermaLink="false">https://medium.com/p/e19f8404fd81</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Zaina Hala]]></dc:creator>
            <pubDate>Sun, 19 Apr 2026 18:55:21 GMT</pubDate>
            <atom:updated>2026-04-19T18:55:21.375Z</atom:updated>
            <content:encoded><![CDATA[<h4>Your AI just got a job.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*O-gSZgiJUTWp_BZM" /><figcaption>Photo by <a href="https://unsplash.com/@agk42?utm_source=medium&amp;utm_medium=referral">Alex Knight</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>You’ve probably heard the term “AI agent” thrown around a lot recently. It’s in every tech keynote, every LinkedIn post, every startup pitch deck. But when you ask people to explain what an AI agent actually <em>is</em> — and how it’s different from ChatGPT — most of them fumble.</p><p>That ends here.</p><p>I’m a computer engineer, and I believe AI agents are the single most important shift in how software works since the invention of the API. Not because of the hype — but because of what’s actually happening under the hood.</p><p>So let’s break this down from scratch. What is an AI agent? How does it actually work, step by step? And why is 2026 the year this technology stops being a demo and starts becoming infrastructure?</p><h3>First: What an AI Agent Is Not</h3><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*wQR_u_YA6HXO8w-2-vFVtw.png" /><figcaption>Evolution of AI Systems</figcaption></figure><p>Before we define what an agent is, let’s clear up what it isn’t.</p><p><strong>A chatbot</strong> takes your message, generates a response, and waits for your next message. It’s reactive. One input, one output. No memory of what it did two conversations ago. No ability to go <em>do</em> something in the real world.</p><p><strong>An AI assistant</strong> (like Siri or Alexa) can follow simple commands — “set a timer,” “play this song” — but it’s following pre-programmed rules. It doesn’t reason about <em>why</em> you need the timer or figure out a better approach.</p><p><strong>An AI agent is fundamentally different.</strong> It doesn’t just answer questions. It <em>works</em>. You give it a goal, and it figures out the steps, uses tools, checks its own results, adjusts its plan, and keeps going until the job is done — often without you needing to say another word.</p><p>Think of the difference this way:</p><ul><li><strong>Chatbot:</strong> “What’s the weather in Tokyo?” → “It’s 22°C and sunny.”</li><li><strong>Assistant:</strong> “Remind me to pack an umbrella” → Sets a reminder.</li><li><strong>Agent:</strong> “Plan my Tokyo trip for next week” → Checks weather forecasts, finds flights within your budget, books a hotel near your meeting location, creates a day-by-day itinerary, and emails it to you.</li></ul><p>The agent doesn’t wait for instructions at each step. It <em>reasons</em>, <em>decides</em>, and <em>acts</em>.</p><h3>The Four Ingredients of Every AI Agent</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NBf4kW4QT4tKOQZ-BDr_Hw.png" /><figcaption>Agent Architecture Stack</figcaption></figure><p>Every AI agent, no matter how simple or complex, is built from the same four components. This formula was elegantly captured by AI researcher Lilian Weng:</p><blockquote><strong><em>Agent = LLM + Memory + Planning + Tools</em></strong></blockquote><p>Let’s unpack each one.</p><h3>1. The LLM — The Brain</h3><p>At the center of every agent is a <strong>Large Language Model</strong> — think GPT-4, Claude, or Gemini. This is the reasoning engine. It reads instructions, thinks through problems, and decides what to do next.</p><p>But here’s the key insight: the LLM alone is just a brain in a jar. It can think, but it can’t <em>do</em> anything. It can’t check your email, query a database, or book a flight. That’s where the other components come in.</p><h3>2. Tools — The Hands</h3><p><strong>Tools</strong> are what give an agent the ability to interact with the real world. A tool is any external function the agent can call: a web search, a calculator, a code executor, a database query, an API call, a file reader.</p><p>When you ask an agent to “find the cheapest flight to Tokyo,” the LLM doesn’t magically know flight prices. Instead, it decides: <em>“I need to search for flights”</em> — and calls a flight search tool. It reads the result, reasons about it, and decides the next step.</p><p>In 2026, a protocol called the <strong>Model Context Protocol (MCP)</strong> has become the standard for how agents discover and use tools. Think of MCP as a universal plug for AI agents — it lets any agent connect to any tool using a common interface. Major AI companies — Anthropic, OpenAI, Google, Microsoft — all support it, and there are now over 10,000 publicly available MCP tool servers.</p><h3>3. Memory — The Notebook</h3><p>Without memory, an agent forgets everything between steps. It would be like a worker who checks their to-do list, completes one task, and then forgets the entire list.</p><p>Agents use two types of memory:</p><p><strong>Short-term memory</strong> is the conversation itself — the running context of what’s been said, what tools were called, and what results came back. This lives inside the LLM’s context window.</p><p><strong>Long-term memory</strong> is stored externally — in a database or vector store — and allows the agent to recall information from previous sessions. “Last time you traveled to Tokyo, you preferred hotels in Shinjuku” — that kind of continuity.</p><p>Memory is what turns a one-shot tool user into a genuine collaborator that learns your preferences over time.</p><h3>4. Planning — The Strategy</h3><p>Here’s where agents get genuinely interesting. Given a complex goal, the agent doesn’t just dive in blindly. It <strong>plans</strong>.</p><p>This is called <strong>task decomposition</strong> — breaking a big goal into smaller, manageable steps. “Plan my Tokyo trip” becomes:</p><ol><li>Check my calendar for available dates</li><li>Search for flights within budget</li><li>Find hotels near the conference venue</li><li>Check weather and suggest packing list</li><li>Create itinerary and send via email</li></ol><p>The agent generates this plan, then executes it step by step — checking results as it goes and adjusting if something goes wrong (say, no flights available on Tuesday, so it shifts to Wednesday).</p><h3>The Agent Loop: How It Actually Runs</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3jM4UDGGJlzFBh8WaFQHBA.png" /><figcaption>Agent Execution Loop</figcaption></figure><p>Now let’s look at how these four components work together in real time. The core execution pattern used by virtually every AI agent in 2026 is called the <strong>ReAct loop</strong> — short for <strong>Reasoning + Acting</strong>.</p><p>It works like this:</p><p><strong>Step 1: Perceive.</strong> The agent receives a goal or new information.</p><p><strong>Step 2: Think.</strong> The LLM reasons about the current state. “What do I know? What do I still need? What should I do next?”</p><p><strong>Step 3: Act.</strong> Based on its reasoning, the agent calls a tool — searching the web, querying a database, running code, or sending a message.</p><p><strong>Step 4: Observe.</strong> The agent reads the result of its action.</p><p><strong>Step 5: Repeat.</strong> It feeds the observation back into its reasoning and decides whether to take another action or deliver a final answer.</p><p>This loop — Think, Act, Observe, Repeat — continues until the task is complete or a stopping condition is met. It’s elegantly simple, yet powerful enough to handle multi-step workflows that would take a human hours.</p><p>Here’s a concrete example:</p><blockquote><strong><em>You:</em></strong><em> “Find the most cited paper on AI memory published in 2026 and summarize its key findings.”</em></blockquote><blockquote><strong><em>Agent thinks:</em></strong><em> “I need to search for recent papers on AI memory.”</em></blockquote><blockquote><strong><em>Agent acts:</em></strong><em> Calls academic search tool → gets 15 results with citation counts.</em></blockquote><blockquote><strong><em>Agent observes:</em></strong><em> Top result has 340 citations.</em></blockquote><blockquote><strong><em>Agent thinks:</em></strong><em> “I should retrieve the full abstract of this paper.”</em></blockquote><blockquote><strong><em>Agent acts:</em></strong><em> Calls document retrieval tool → gets full abstract and key sections.</em></blockquote><blockquote><strong><em>Agent observes:</em></strong><em> Reads the content.</em></blockquote><blockquote><strong><em>Agent thinks:</em></strong><em> “I now have enough to summarize.”</em></blockquote><blockquote><strong><em>Agent delivers:</em></strong><em> A clean summary of the paper’s key findings.</em></blockquote><p>Four reasoning steps, three tool calls, one complete answer. No human intervention needed between steps.</p><h3>Single Agents vs. Multi-Agent Systems</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V7T5881rqRxg0ktAwTQYBQ.png" /><figcaption>Agent Scaling Architecture</figcaption></figure><p>Early AI agents were solo operators — one agent, one task. But the most powerful applications in 2026 use <strong>multi-agent systems</strong>, where multiple specialized agents collaborate like a team.</p><p>Think of it as the difference between hiring one generalist employee and building a specialized team:</p><ul><li><strong>Agent 1 (Researcher):</strong> Gathers data and finds relevant information.</li><li><strong>Agent 2 (Analyst):</strong> Processes the data and identifies patterns.</li><li><strong>Agent 3 (Writer):</strong> Drafts a report based on the analysis.</li><li><strong>Agent 4 (Reviewer):</strong> Checks the report for accuracy and quality.</li></ul><p>An <strong>orchestrator agent</strong> coordinates the team — assigning tasks, managing dependencies, and deciding when the work is done. It’s like a project manager for AI workers.</p><p>This architecture is already being used in production. Coding agents analyze issues, write code, run tests, and prepare pull requests — all as a coordinated system. Customer service agents categorize requests, pull context from CRM systems, draft responses, and execute actions like issuing refunds — end to end, with no human in the loop for routine cases.</p><h3>Where AI Agents Are Actually Working Right Now</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6hfS5ALLeLSDoCv-X1D8MA.png" /><figcaption>Agent Deployment Landscape</figcaption></figure><p>This isn’t theoretical. AI agents are deployed across major industries today:</p><p><strong>Software engineering.</strong> Agents analyze codebases, suggest fixes, write tests, and prepare pull requests. Tools like Claude Code, GitHub Copilot, Cursor, and Devin all use agent architectures. The longest autonomous coding sessions now run for over 45 minutes without human input.</p><p><strong>Customer support.</strong> Agents handle tickets from start to finish — classifying the issue, pulling customer history, drafting a response, and executing the resolution (refund, reschedule, escalation). The shift is from reactive complaint handling to proactive issue prevention.</p><p><strong>Finance.</strong> Agents monitor transactions for fraud, generate compliance reports, and summarize regulatory filings — consolidating information from multiple systems that would take human analysts hours to review.</p><p><strong>Supply chain.</strong> Agents track inventory, predict disruptions, reroute shipments, and even negotiate with suppliers autonomously. When a delivery is delayed, an agent can reschedule, apply a service credit, and notify the customer — all before the customer notices.</p><p><strong>Healthcare.</strong> AI agents assist in diagnostic imaging, patient triage, and clinical documentation — always under physician oversight, but dramatically reducing administrative burden.</p><h3>Why 2026 Is the Tipping Point</h3><p>AI agents have existed as concepts for years. So why are they exploding <em>now</em>?</p><p><strong>The models got good enough.</strong> Modern LLMs can genuinely reason through multi-step problems, handle ambiguity, and recover from errors. Earlier models would get stuck in loops or hallucinate tool calls. Today’s models are reliable enough for production use.</p><p><strong>Tool ecosystems matured.</strong> The Model Context Protocol standardized how agents connect to tools. With over 10,000 public MCP servers and adoption by every major AI provider, agents can now plug into virtually any system.</p><p><strong>Enterprises are ready.</strong> Industry analysts project that AI agents will be embedded in nearly 80% of enterprise workplace applications by the end of 2026. Companies aren’t experimenting anymore — they’re deploying.</p><p><strong>The economics work.</strong> At current pricing, a complex multi-step agent query costs roughly $0.15–0.30. Compare that to the cost of a human performing the same multi-tool, multi-system workflow — the return on investment is clear.</p><h3>The Risks Nobody Should Ignore</h3><p>AI agents are powerful, but they come with real risks that responsible engineers take seriously:</p><p><strong>Agents can make mistakes.</strong> An agent that autonomously processes refunds or modifies code can cause real damage if its reasoning is wrong. That’s why production agents use the principle of <strong>minimum required permissions</strong> — they can only access what they strictly need.</p><p><strong>Security is about the tools, not the LLM.</strong> If an agent has access to delete files, rewrite pricing algorithms, or send emails, those capabilities can be exploited. Proper security means constraining what tools can do, not just what the LLM says.</p><p><strong>Observability is non-negotiable.</strong> Every agent action, every tool call, every reasoning step should be logged. Without this, debugging a failed agent workflow is nearly impossible.</p><p><strong>Human-in-the-loop isn’t a compromise — it’s a design pattern.</strong> The best agent systems keep humans in control of high-stakes decisions while letting agents handle execution-heavy tasks autonomously.</p><h3>What This Means for You</h3><p>Whether you’re a developer, an engineer, a product manager, or simply someone curious about where technology is heading — AI agents are the pattern to understand right now.</p><p>They represent a fundamental shift: from “AI that answers” to “AI that works.” From tools that wait for your prompt to systems that take initiative, use resources, and deliver results.</p><p>The companies, teams, and individuals who learn to build, deploy, and manage AI agents effectively will have a massive advantage in the years ahead. Not because agents replace humans — but because they change what humans spend their time on.</p><p>Instead of executing repetitive tasks, you become the person who sets goals, reviews results, and makes the decisions that matter.</p><p>And that’s a future worth building toward.</p><h3>🙌 If You Enjoyed This Deep Dive…</h3><p>Thank you for reading all the way through! Writing these deep dives takes a lot of research and energy, and your support is what keeps me going.</p><p>Here’s how you can help:</p><p>👏 <strong>Hold down the clap button until you hit 50</strong> — yes, you can clap up to 50 times on one article! Each clap pushes this article to more readers who are curious about how technology really works.</p><p>➕ <strong>Follow me</strong> on Medium <a href="https://medium.com/@elsa-andrea">@elsa-andrea</a> — I publish weekly deep dives on the real engineering behind AI, cloud infrastructure, and modern systems. No hype, no buzzwords — just clarity.</p><p><strong>Drop a comment</strong> — tell me what topic you’d like me to break down next. Your suggestions directly shape my upcoming articles.</p><p>Every clap, follow, and comment gives me more energy to keep writing. Knowing that real people are reading and learning from these articles genuinely makes my week. 💙</p><p><strong>Coming up next:</strong> <em>Platform Engineering vs DevOps: Why Your Team Is Making the Switch in 2026</em> — follow me so you don’t miss it!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e19f8404fd81" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Actually Happens When You Type a URL and Press Enter — The 2026 Edition]]></title>
            <link>https://zaina-hala.medium.com/what-actually-happens-when-you-type-a-url-and-press-enter-the-2026-edition-35af25884483?source=rss-d0d035e00f1d------2</link>
            <guid isPermaLink="false">https://medium.com/p/35af25884483</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[https]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Zaina Hala]]></dc:creator>
            <pubDate>Sat, 14 Mar 2026 20:18:40 GMT</pubDate>
            <atom:updated>2026-03-14T20:18:40.393Z</atom:updated>
            <content:encoded><![CDATA[<h4>The internet’s longest millisecond, decoded.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1kmhD7bP6MF0IFbqFRuDdQ.png" /></figure><p>You do it hundreds of times a day. You type a URL, hit Enter, and a webpage appears. It feels instant. Almost boring.</p><p>But here’s the thing — in that single second between pressing Enter and seeing a page, your request travels thousands of miles, passes through dozens of machines, gets encrypted, decrypted, cached, routed, and reassembled. It’s one of the most complex engineering feats happening on the planet, and it happens so smoothly that nobody thinks about it.</p><p>Until now.</p><p>I’m a computer engineer, and I think this is one of the most beautiful processes in modern technology. So let’s trace the full journey — from the moment your finger lifts off the Enter key to the moment pixels light up on your screen. No jargon soup. No hand-waving. Just the real path your data takes in 2026.</p><h3>Step 1: The Browser Checks Its Pockets First</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*06WKHv0pX5dg7KGvylbAyQ.png" /></figure><p>Before your request goes anywhere on the internet, your browser does something smart — it checks if it already has the answer.</p><p><strong>The browser cache</strong> is like a personal notebook where your browser scribbles down websites it has visited recently. If you loaded the same page an hour ago and the content hasn’t expired, the browser simply pulls it from memory. Done. No network request needed.</p><p>But let’s say it’s a fresh visit. The browser looks at your URL — say, https://www.example.com/about — and needs to figure out one critical thing:</p><p><em>Where on the internet does this website actually live?</em></p><p>A domain name like example.com is just a human-friendly label. Computers don&#39;t understand labels. They understand numbers — specifically, <strong>IP addresses</strong> like 93.184.216.34. So the browser needs to translate the name into a number.</p><p>That’s where DNS comes in.</p><h3>Step 2: DNS — The Internet’s Phone Book</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LnCl3RGFYlnL60rmLJZqcw.png" /></figure><p>The <strong>Domain Name System</strong> is one of the most underrated pieces of infrastructure ever built. It’s essentially a massive, distributed phone book that converts domain names into IP addresses.</p><p>Here’s how the lookup actually works, step by step:</p><p><strong>First</strong>, the browser checks the <strong>local DNS cache</strong> on your machine. Your operating system keeps a short-term memory of recent lookups.</p><p><strong>If that misses</strong>, the request goes to a <strong>DNS resolver</strong> — usually operated by your Internet Service Provider (ISP), or by services like Cloudflare’s 1.1.1.1 or Google&#39;s 8.8.8.8.</p><p><strong>The resolver then asks a chain of servers:</strong></p><ul><li>A <strong>root name server</strong> (there are only 13 sets of these in the world) points toward the right top-level domain — .com, .org, .io, etc.</li><li>A <strong>TLD (Top-Level Domain) server</strong> points to the specific domain’s authoritative server.</li><li>The <strong>authoritative name server</strong> for example.com finally returns the actual IP address.</li></ul><p>This whole chain typically resolves in <strong>20–120 milliseconds</strong>. But modern optimizations make it even faster. Many DNS resolvers now support <strong>DNS-over-HTTPS (DoH)</strong> and <strong>DNS-over-TLS (DoT)</strong>, which encrypt your DNS queries so nobody — not even your ISP — can see which websites you’re looking up.</p><blockquote><strong><em>2026 Update:</em></strong><em> Encrypted DNS is now the default in most browsers. Chrome, Firefox, Safari, and Edge all route DNS queries through encrypted channels automatically. Privacy is no longer optional — it’s built in.</em></blockquote><h3>Step 3: Knocking on the Server’s Door — The TCP Handshake</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aOWUt29BfRKLLDxj-iBHiQ.png" /></figure><p>Now the browser knows the IP address. Time to connect.</p><p>If the website uses HTTP/1.1 or HTTP/2 (most still do for initial connections), the browser initiates a <strong>TCP three-way handshake</strong>. Think of it as a polite introduction:</p><ol><li><strong>Your browser says:</strong> “Hey, I’d like to talk.” (SYN)</li><li><strong>The server responds:</strong> “Sure, I’m here. Let’s talk.” (SYN-ACK)</li><li><strong>Your browser confirms:</strong> “Great, let’s go.” (ACK)</li></ol><p>This takes one full round-trip between your device and the server. If the server is on another continent, that could add <strong>100–300 milliseconds</strong> of latency just for the handshake.</p><p>But wait — the website uses HTTPS (as nearly everything does in 2026). So right after TCP, the browser performs a <strong>TLS handshake</strong> to establish encryption. With TLS 1.3, this adds just <strong>one more round-trip</strong> — the browser and server agree on encryption keys, verify the server’s certificate, and lock the connection.</p><blockquote><strong><em>The result:</em></strong><em> everything you send and receive from this point forward is encrypted. Passwords, credit card numbers, even the URL path — all protected.</em></blockquote><h3>Step 4: HTTP/3 and QUIC — The 2026 Game Changer</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QLC47ZpVdcUicIib8aEyMw.png" /></figure><p>Here’s where 2026 is fundamentally different from even a few years ago.</p><p>If the server supports <strong>HTTP/3</strong> — and a growing majority now do — the browser skips TCP entirely. Instead, it uses a protocol called <strong>QUIC</strong>, which runs on top of <strong>UDP</strong> rather than TCP.</p><p>Why does this matter? Three reasons:</p><p><strong>Faster connections.</strong> QUIC combines the transport handshake and the TLS handshake into a single step. For repeat visits, it can even achieve <strong>zero round-trip time (0-RTT)</strong> — meaning the browser starts sending data <em>before</em> the handshake finishes.</p><p><strong>No more head-of-line blocking.</strong> HTTP/2 multiplexes many requests over a single TCP connection. That’s efficient — until one packet gets lost. With TCP, a single lost packet stalls <em>every</em> stream. QUIC fixes this by giving each stream its own independent flow. A lost packet in one stream doesn’t touch the others.</p><p><strong>Better for mobile.</strong> When your phone switches from Wi-Fi to cellular data, TCP connections break and have to restart from scratch. QUIC uses a <strong>connection ID</strong> that survives network changes, so your page keeps loading seamlessly as you walk out the door.</p><blockquote><strong><em>The numbers:</em></strong><em> HTTP/3 can be up to four times faster than HTTP/1.1 on lossy mobile networks. As of 2026, over 95% of major browsers and roughly a third of the top 10 million websites support it.</em></blockquote><h3>Step 5: The HTTP Request — Asking for What You Need</h3><p>With the connection established (whether via TCP+TLS or QUIC), the browser sends an <strong>HTTP request</strong>. This is the actual “can I have this page?” message.</p><p>A simplified version looks like this:</p><pre>GET /about HTTP/3<br>Host: www.example.com<br>Accept: text/html<br>User-Agent: Chrome/131<br>Accept-Encoding: gzip, br</pre><p>This tells the server: “I want the /about page, I can handle HTML, I&#39;m using Chrome, and I support compressed formats like gzip and Brotli.&quot;</p><p>The server processes this request. For a simple static page, it just grabs the file. For a dynamic page — say, your social media feed — it runs backend code, queries databases, assembles personalized content, and then sends back a response.</p><h3>Step 6: But First — The CDN Might Answer Instead</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0QradrqFFJvAaqreYdiksw.png" /></figure><p>Here’s a crucial detail most people miss: <strong>your request often never reaches the origin server</strong>.</p><p>In 2026, most major websites use a <strong>Content Delivery Network (CDN)</strong> — a global network of edge servers positioned close to users worldwide. Companies like Cloudflare, Akamai, and AWS CloudFront operate thousands of these servers in data centers across every continent.</p><p>When the DNS resolved your domain, it likely pointed you to a CDN edge server near your location — not the actual origin server. If that edge server already has a cached copy of the page you requested, it sends it directly. No need to travel to the origin.</p><p><strong>This is massive.</strong> Instead of your request flying from Colombo to a server in Virginia and back, it might only travel to Singapore or Mumbai. That alone can shave off hundreds of milliseconds.</p><blockquote><strong><em>2026 Update:</em></strong><em> CDNs aren’t just caching static files anymore. With </em><strong><em>edge computing</em></strong><em>, CDN servers now run actual code — rendering HTML, executing API calls, personalizing content — right at the edge. The line between “cache” and “server” is blurring fast.</em></blockquote><h3>Step 7: The Response Travels Back</h3><p>The server (or CDN edge) sends back an <strong>HTTP response</strong>. It looks something like this:</p><pre>HTTP/3 200 OK<br>Content-Type: text/html; charset=UTF-8<br>Content-Encoding: br<br>Cache-Control: max-age=3600</pre><p>Followed by the actual content — the HTML of the page, compressed using Brotli encoding to save bandwidth.</p><p><strong>The status code</strong> tells the browser what happened:</p><ul><li><strong>200</strong> — Success, here’s your page.</li><li><strong>301</strong> — This page moved permanently, go here instead.</li><li><strong>404</strong> — Page not found.</li><li><strong>500</strong> — Something broke on the server.</li></ul><p>If the response is 200, the browser has the HTML. But the page isn&#39;t done loading yet — not even close.</p><h3>Step 8: Parsing and Rendering — From Code to Pixels</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TxmewCUDSISHlX6zrPx2SA.png" /></figure><p>The HTML file the browser receives is just raw text — tags like &lt;div&gt;, &lt;h1&gt;, &lt;img&gt;. The browser needs to transform this into the visual page you see.</p><p>Here’s the rendering pipeline:</p><p><strong>1. Parse HTML → Build the DOM.</strong> The browser reads the HTML top to bottom and constructs a <strong>Document Object Model (DOM)</strong> — a tree structure representing every element on the page.</p><p><strong>2. Parse CSS → Build the CSSOM.</strong> As it encounters &lt;link&gt; tags pointing to stylesheets, it fetches them and builds a <strong>CSS Object Model</strong> — the rules for how everything should look.</p><p><strong>3. Combine → Render Tree.</strong> The DOM and CSSOM merge into a <strong>Render Tree</strong> — only the visible elements, with their computed styles.</p><p><strong>4. Layout.</strong> The browser calculates the exact position and size of every element on the screen. This is also called “reflow.”</p><p><strong>5. Paint.</strong> Each element gets its pixels drawn. Text is rasterized, images decoded, borders rendered.</p><p><strong>6. Composite.</strong> Complex pages have layers (think: a sticky header floating over scrolling content). The browser composites these layers together into the final image sent to your display.</p><p>This entire process — from raw HTML to visible pixels — typically takes <strong>50–200 milliseconds</strong> on a modern device.</p><h3>Step 9: JavaScript Brings the Page to Life</h3><p>Most modern websites don’t stop at static HTML. They load JavaScript that makes the page interactive — handling clicks, fetching additional data, animating transitions.</p><p>The browser downloads, parses, and executes JavaScript files. If the site uses a framework like React, Vue, or Next.js, there might be a “hydration” step where the server-rendered HTML gets wired up with client-side interactivity.</p><blockquote><strong><em>Performance note:</em></strong><em> JavaScript is often the biggest bottleneck in page loading. Smart websites in 2026 use techniques like </em><strong><em>code splitting</em></strong><em> (loading only what’s needed), </em><strong><em>lazy loading</em></strong><em> (deferring off-screen content), and </em><strong><em>streaming server-side rendering</em></strong><em> (sending HTML in chunks as it’s generated).</em></blockquote><h3>The Full Journey — In Under One Second</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HQL09ghSb6ZDLMG_9S014A.png" /></figure><p>Let’s zoom out and see the complete path:</p><ol><li><strong>You press Enter</strong> → Browser checks cache</li><li><strong>DNS lookup</strong> → Domain name translated to IP address (20–120ms)</li><li><strong>Connection</strong> → TCP+TLS handshake or QUIC 0-RTT (0–200ms)</li><li><strong>HTTP request</strong> → Browser asks for the page</li><li><strong>CDN or origin</strong> → Nearest edge server responds (10–300ms)</li><li><strong>Response received</strong> → HTML, CSS, JS downloaded</li><li><strong>Rendering</strong> → DOM → CSSOM → Layout → Paint → Composite (50–200ms)</li><li><strong>JavaScript</strong> → Page becomes interactive</li></ol><p>Total: typically <strong>200ms to 1.5 seconds</strong> for a well-optimized site. All of that engineering, all of that infrastructure — just so a page can feel “instant.”</p><h3>Why This Matters in 2026</h3><p>Understanding this journey isn’t just trivia. If you’re a developer, this is the foundation of web performance. If you’re an engineer, every layer — DNS, TLS, HTTP/3, CDNs, edge computing — is an area where milliseconds are won or lost.</p><p>The internet in 2026 is faster, more encrypted, and more distributed than ever. HTTP/3 and QUIC are replacing the TCP connections that powered the web for decades. Edge computing is moving code to within a few miles of every user. Encrypted DNS is protecting browsing habits by default.</p><p>The next time your page loads in under a second, remember — you just watched thousands of machines across the planet coordinate perfectly, in real time, just for you.</p><p>And that’s pretty incredible.</p><h3>🙌 If You Made It This Far…</h3><p>Thank you for reading! If this article helped you understand something new — or reminded you of something you’d forgotten — I’d truly appreciate it if you:</p><p>👏 <strong>Clap up to 50 times</strong> — yes, you can hold down the clap button! Each clap helps this article reach more curious minds like yours.</p><p>➕ <strong>Follow me</strong> on Medium <a href="https://medium.com/@elsa-andrea">@elsa-andrea</a> — I write about the real engineering behind the technology we use every day. From algorithms to architecture, no buzzwords, just clarity.</p><p>Your claps, follows, and shares give me the energy to keep writing and breaking down complex engineering topics into something everyone can understand. Every single clap genuinely makes my day and motivates the next article. 💙</p><p><strong>Coming up next:</strong> <em>AI Agents Explained: What They Are, How They Work, and Why 2026 Is Their Year</em> — stay tuned!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35af25884483" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Computers Actually Talk: From Electricity to the Cloud]]></title>
            <link>https://zaina-hala.medium.com/how-computers-actually-talk-from-electricity-to-the-cloud-4b42b210c2e0?source=rss-d0d035e00f1d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b42b210c2e0</guid>
            <category><![CDATA[computer-engineering]]></category>
            <category><![CDATA[computer-networking]]></category>
            <category><![CDATA[computer-work]]></category>
            <category><![CDATA[internet-protocol]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Zaina Hala]]></dc:creator>
            <pubDate>Tue, 26 Aug 2025 06:47:56 GMT</pubDate>
            <atom:updated>2025-08-26T06:48:46.876Z</atom:updated>
            <content:encoded><![CDATA[<h4>Understanding the Path of Data</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ahFaudFVIE3ezWSF" /><figcaption>Photo by <a href="https://unsplash.com/@growtika?utm_source=medium&amp;utm_medium=referral">Growtika</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>1. Introduction: From a Tap to a Message</h3><p>You send a message every day without thinking. A quick tap on your phone, the “typing…” dots flash, and a few seconds later your friend replies.<br>It feels instant. Invisible. Effortless.</p><p>But under the screen, something wild just happened. Millions of microscopic switches inside your device flipped at lightning speed, pushing tiny bursts of electricity down wires and through the air. Those electrical pulses — so small you’ll never see them — just traveled halfway across the planet, wrapped in rules, chopped into packets, and stitched back together on your friend’s device. All so one line of text could show up.</p><p>We live inside this invisible conversation every second: the pulse of electricity, the language of bits, the flow of networks, the chatter of HTTP, the vast backbone of the cloud. You don’t see it, but it’s happening all the time — every search, every swipe, every “send”</p><p>This article is a guided tour through that journey. No buzzwords, no abstract diagrams — just the real story of how computers actually talk, from the first flicker of voltage to the giant cloud services that run your favorite apps.</p><h3>2. Voltage Flickers: Bits Born from Electricity</h3><p>Every digital conversation starts with a flicker of electricity.<br>At the lowest level, a computer doesn’t “know” text, images, or cat videos. It only understands two states: <strong>on</strong> and <strong>off</strong>.</p><p>Engineers give those states numbers:</p><ul><li><strong>0</strong> → off, low voltage</li><li><strong>1</strong> → on, high voltage</li></ul><p>That’s a <strong>bit</strong> — the smallest unit of digital information. String enough of them together, and you can represent anything: numbers, letters, even video streams.</p><p>Inside your processor, billions of tiny electronic switches called <strong>transistors</strong> decide whether current flows or stops. They flip faster than you can blink — actually, billions of times per second. Each flip is one decision: 0 or 1.</p><p>Then come <strong>logic gates</strong>. These are little decision-makers built from transistors. An <strong>AND gate</strong>, for example, only outputs a “1” if both of its inputs are “1.” An <strong>OR gate</strong> lights up if either input is “1.” By wiring these together, you can build anything: calculators, CPUs, even AI chips.</p><p>So when you press a key or tap your phone screen, you’re really setting off a storm of 0s and 1s — electricity rushing, pausing, and combining in precise patterns. Those patterns are the raw language of your machine.</p><p>It looks simple — just two states — but it’s the alphabet computers use to say everything.</p><h3>3. Moving Bits: Sending Data Across Wires and Air</h3><p>Bits alone don’t mean much if they stay locked inside your device.<br>The real magic begins when those 0s and 1s start moving — across wires, fiber optics, or the invisible waves of Wi-Fi.</p><p>Think of it like mailing letters.<br>Your message is chopped into little envelopes called <strong>packets</strong>. Each packet carries not just the data, but also instructions:</p><ul><li><strong>Where it’s going</strong> (the destination address)</li><li><strong>Where it came from</strong> (the source address)</li><li><strong>How to put the pieces back together</strong> when they arrive</li></ul><p>That’s where <strong>TCP/IP</strong> comes in — the rulebook of the internet.</p><ul><li><strong>IP (Internet Protocol):</strong> This is the addressing system. It’s like writing a street address on an envelope so routers know where to forward it.</li><li><strong>TCP (Transmission Control Protocol):</strong> This ensures your data arrives intact. If a packet goes missing, TCP resends it — like a post office double-checking every letter is delivered.</li></ul><p>Sometimes speed matters more than reliability. That’s when we use <strong>UDP (User Datagram Protocol)</strong>. It doesn’t bother resending missing packets. Perfect for live video or online games where a tiny glitch is better than a delay.</p><p>So when you hit “send,” your device doesn’t shoot one big block of data across the network. It breaks your message into dozens (or thousands) of packets, hands them to TCP/IP, and ships them across whatever path the internet chooses — maybe undersea fiber cables, maybe bouncing through Wi-Fi to your router.</p><p>At the other end, the packets are reassembled like puzzle pieces. Your friend sees the message. To them, it felt instant. In reality, it was a global relay race of bits riding electrons and radio waves.</p><h3>4. Layered Roadmap: The TCP/IP Stack Explained</h3><p>If moving data is like mailing letters, the internet doesn’t trust one set of rules to do it all.<br>Instead, it stacks rules in <strong>layers</strong>. Each layer has a job, and together they form the <strong>TCP/IP model</strong> — the real-world backbone of how networks work.</p><p>Here’s the simple breakdown:</p><ol><li><strong>Link Layer</strong> — This is the ground floor. It covers the physical hop between you and the next device: Wi-Fi, Ethernet, or even cellular signals. Think of it as handing your letter to the local post office.</li><li><strong>Internet Layer</strong> — This is where <strong>IP (Internet Protocol)</strong> lives. It decides the route: across towns, under oceans, through satellites. The internet doesn’t send one “best path” — it often splits your packets across multiple routes and reassembles them at the destination.</li><li><strong>Transport Layer</strong> — Now comes <strong>TCP</strong> (reliable, like certified mail) or <strong>UDP</strong> (fast, like a postcard). This layer ensures that your friend actually gets the message and can understand it in the right order.</li><li><strong>Application Layer</strong> — The top layer is where you live: web pages, email, Zoom calls. Protocols like <strong>HTTP</strong>, <strong>SMTP</strong>, and <strong>FTP</strong> are just languages apps use to talk on top of TCP/IP.</li></ol><p>Some textbooks mention a more detailed <strong>OSI model</strong> with 7 layers. That’s useful for learning, but in practice, the world runs on TCP/IP’s 4-layer version. It’s simpler, and it works.</p><p>So the next time you refresh Instagram or load a website, you’re not just “using Wi-Fi.” You’re climbing this hidden staircase:</p><blockquote><strong>Link → Internet → Transport → Application</strong></blockquote><p>Each layer adds its own envelope around your data, like Russian nesting dolls. By the time your friend reads your text, the outer layers have been peeled away — and all that’s left is the clean message.</p><h3>5. Modern Web Talk: HTTP/3 and QUIC</h3><p>When you type a URL or tap a link, your browser isn’t sending electricity or even raw packets anymore. It’s speaking <strong>HTTP</strong> — short for <strong>HyperText Transfer Protocol</strong>. That’s the language of the web.</p><p>Here’s how it works:</p><ul><li>Your browser (the client) sends a <strong>request</strong>: “Hey server, give me the homepage of example.com.”</li><li>The server replies with a <strong>response</strong>: “Here’s the HTML, CSS, and JavaScript you need.”</li><li>Your browser takes those pieces and paints the page you see.</li></ul><p>For years, this was handled by <strong>HTTP/1.1</strong> — reliable but slow. Then came <strong>HTTP/2</strong>, which introduced multiplexing (sending multiple requests over one connection). Better, but still not perfect.</p><p>Now, the internet is moving to <strong>HTTP/3</strong>, which runs on top of a newer transport protocol called <strong>QUIC</strong> (Quick UDP Internet Connections). QUIC ditches the old TCP handshake for something faster, built on <strong>UDP</strong>. It fixes big headaches like:</p><ul><li><strong>Head-of-line blocking</strong> — in HTTP/2, one stuck packet could hold up everything else. QUIC solves that by handling streams independently.</li><li><strong>Connection setup delays</strong> — QUIC gets you talking to the server in fewer steps, which means faster page loads.</li></ul><p>In plain English: <strong>HTTP/3 makes websites feel snappier, especially on mobile networks with flaky connections.</strong> Google, Facebook, and most modern browsers already use it under the hood.</p><p>So, the next time a page loads lightning-fast, thank QUIC. It’s the invisible upgrade that makes the web’s conversation smoother.</p><h3>6. The Cloud: What Happens “Behind the Curtain”</h3><p>Every request you make — whether it’s opening Gmail, streaming Netflix, or backing up photos — eventually lands on a <strong>server</strong>.<br>But in 2025, it’s rarely just one server in some random basement. It’s the <strong>cloud</strong>.</p><p>Think of the cloud as massive warehouses filled with racks of computers. These aren’t magical; they’re just scaled-up versions of the same machines we’ve been talking about: processors flipping bits, network cards shuffling packets, storage drives holding data. The difference? Cloud providers like Amazon, Google, and Microsoft run millions of them, stitched together with high-speed networks.</p><p>When you “use the cloud,” here’s what really happens:</p><ul><li>Your request hits a load balancer, which decides which machine in the warehouse should handle it.</li><li>Virtualization slices one physical server into dozens of “virtual” ones, so companies can rent them like apartments in a giant high-rise.</li><li>Data isn’t stored in just one place — it’s replicated across regions so your photos survive even if one data center goes dark.</li></ul><p>Modern clouds aren’t just storage or compute anymore. They’ve become <strong>AI platforms</strong>. Want speech recognition? Image tagging? Text generation? You can call those services from the same cloud that powers your app. The line between “infrastructure” and “intelligence” is blurring.</p><p>Of course, there’s a cost. Cloud giants consume <strong>huge amounts of power</strong>. Entire countries are debating how to balance energy grids with the demand of data centers. And for companies, cloud bills can balloon fast — which is why <strong>hybrid setups</strong> (mixing cloud and local servers) are becoming the norm.</p><p>So the cloud is both invisible and everywhere. It’s not “out there in the sky.” It’s racks of humming servers, running in chilled rooms the size of football fields, all choreographed to make your apps feel instant.</p><h3>7. The Edge: When the Cloud Is Too Far</h3><p>The cloud is powerful, but it’s not always fast enough.<br>Imagine a self-driving car. It can’t afford to ship video of the road to a data center thousands of miles away, wait for a response, and then decide whether to brake. By then, it’s already crashed.</p><p>This is where <strong>edge computing</strong> comes in. Instead of sending everything to the cloud, some processing happens <strong>closer to where the data is created</strong> — on your phone, a local server, or even inside the car itself.</p><p>Here’s why it matters:</p><ul><li><strong>Speed (low latency):</strong> Edge devices cut out the long trip to the cloud, shaving milliseconds that make all the difference.</li><li><strong>Privacy:</strong> Data can stay local instead of always traveling to a central server.</li><li><strong>Reliability:</strong> If your internet cuts out, edge devices can keep working.</li></ul><p>You’re already using edge without realizing it. Your phone’s <strong>face recognition</strong> works instantly because the neural network runs on the device, not in the cloud. Voice assistants like Siri or Alexa increasingly process commands locally before sending anything out.</p><p>And the trend is accelerating. Analysts expect that by <strong>2025, around 75% of enterprise data</strong> will be processed at the edge rather than in distant cloud centers. Even chipmakers like AMD predict most <strong>AI inference</strong> (the part where AI makes decisions) will run on local devices by the end of the decade.</p><p>In other words: the future isn’t all “in the cloud.” It’s a partnership. Cloud handles the heavy lifting; edge handles the real-time moments where waiting is not an option.</p><h3>8. Keeping It All Safe: Secure Access at the Edge</h3><p>So far, we’ve seen how data travels — from flickers of electricity to the cloud and edge. But there’s one constant threat in this whole chain: <strong>security</strong>.</p><p>Traditionally, companies protected their networks with a big firewall at the center — like a castle wall. All traffic flowed through it for inspection before going out to the internet. That worked when people sat in offices, but today? We’re connecting from homes, phones, airports, coffee shops, and every random Wi-Fi network in between. The castle wall doesn’t scale.</p><p>Enter <strong>SASE</strong> — <strong>Secure Access Service Edge</strong>. It flips the model: instead of dragging all traffic through one choke point, security is delivered <strong>at the edge</strong>, close to the user or device.</p><p>What does that mean in practice?</p><ul><li><strong>Identity-based access:</strong> Your login and device matter more than where you’re connecting from.</li><li><strong>Zero Trust:</strong> Every request is verified, even if you’re “inside” the network. No automatic trust.</li><li><strong>Cloud-delivered security:</strong> Firewalls, VPNs, threat detection — all packaged as services that follow you wherever you connect.</li></ul><p>For end users, it’s invisible. You just see your apps working quickly and safely. Behind the scenes, SASE ensures that whether your packets hop through a coffee shop router or a 5G tower, they’re still protected.</p><p>The internet’s conversation isn’t just fast and global — it’s guarded at every step. Without that, none of this would be usable at all.</p><h3>9. Final Thoughts: The Invisible Conversation</h3><p>Every time you send a message, stream a video, or open an app, you’re riding on an invisible chain of events:</p><ul><li>A flicker of <strong>voltage</strong> flips into 0s and 1s.</li><li>Those bits are packed into <strong>packets</strong> and routed by TCP/IP.</li><li>Protocols like <strong>HTTP/3 and QUIC</strong> carry your requests across the web.</li><li>Massive <strong>cloud data centers</strong> process, store, and scale it all.</li><li><strong>Edge devices</strong> step in when milliseconds matter.</li><li><strong>Security at the edge</strong> keeps the whole chain safe.</li></ul><p>To you, it feels instant. But behind the scenes, it’s billions of micro-decisions, wires, radio waves, and servers humming in perfect sync. Computers don’t just “work” — they talk, constantly, across layers and systems we rarely see.</p><p>That’s the beauty of modern computing. What looks like a casual tap on your phone is actually the end result of decades of engineering — a carefully choreographed dance of electricity, math, and networks.</p><p>So the next time your Wi-Fi lags or a page takes forever to load, remember: you’re not just “waiting on the internet.” You’re watching a conversation happen across the planet, one bit at a time.</p><h3>Enjoyed this? ❤</h3><p>Follow and drop some Claps if you want more no-fluff takes on AI, storage, and the backend battles shaping tomorrow’s tech.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b42b210c2e0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From MIT to Cloudian: Rethinking Storage for the AI Era]]></title>
            <link>https://zaina-hala.medium.com/from-mit-to-cloudian-rethinking-storage-for-the-ai-era-1d46ca5b8333?source=rss-d0d035e00f1d------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d46ca5b8333</guid>
            <dc:creator><![CDATA[Zaina Hala]]></dc:creator>
            <pubDate>Wed, 20 Aug 2025 18:20:49 GMT</pubDate>
            <atom:updated>2025-08-20T18:20:49.992Z</atom:updated>
            <content:encoded><![CDATA[<h4>The Data Bottleneck Nobody Solves</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eNYiDlSg5qs6tg8B" /><figcaption>Photo by <a href="https://unsplash.com/@hdbernd?utm_source=medium&amp;utm_medium=referral">Bernd 📷 Dittrich</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>1. Intro</h3><p>Everyone’s obsessing over GPUs. NVIDIA’s stock soars, startups fight for H100s like they’re lottery tickets, and every pitch deck screams “compute, compute, compute.”</p><p>But here’s the unsexy truth: AI isn’t starving for GPUs. It’s choking on data.</p><p>Modern AI workloads don’t look like your dad’s database queries. Instead of a handful of users sending predictable commands, today’s models juggle <strong>millions of simultaneous agents</strong> pulling from oceans of data. Before any of that reaches a GPU, it has to crawl through storage layers built for a completely different era. The result? Latency, bottlenecks, wasted compute cycles.</p><p>That’s the real battlefield nobody talks about. And it’s exactly where MIT-bred engineers, through a company called Cloudian, are now picking a fight.</p><h3>2. Why GPUs Alone Don’t Cut It</h3><p>GPUs get all the credit because they’re flashy. Teraflops, CUDA cores, training LLMs in days instead of months — the marketing writes itself. But here’s the ugly side nobody wants on a keynote slide: a GPU spends half its life sitting idle, waiting for data.</p><p>Think about it. Traditional applications were built for small, neat requests. A few users log in, click a button, the system fetches from storage, job done. Now compare that with AI workloads — millions of agents, all demanding terabytes in parallel. The pipelines just aren’t built for that kind of flood.</p><p>It’s like owning a Formula 1 car but fueling it through a soda straw. The engine roars, the design is perfect, but it barely moves because the fuel (your data) can’t reach it fast enough.</p><p>That’s why adding more GPUs isn’t fixing the problem. It’s multiplying the waste. If the storage layer can’t keep up, your shiny new GPU farm is just an overpriced waiting room.</p><h3>3. MIT Roots → Cloudian’s Big Bet</h3><p>This isn’t just another “startup saves the day” story. It starts at MIT in the ’90s, where a young Michael Tso was knee-deep in parallel computing and distributed systems. Back then, the internet was still figuring out how to move data without collapsing, and Tso was learning from legends like Bill Dally and David Clark — people who literally wrote the playbook on scaling networks.</p><p>Fast-forward a decade. Tso worked at Intel on syncing data for BlackBerry (remember those?), then at Nokia during the ringtone and mobile messaging boom. Every stop hammered in the same lesson: <strong>the bottleneck isn’t the device, it’s the data flow.</strong></p><p>So when AI workloads started looking less like neat SQL queries and more like tidal waves of unstructured data, Tso and co-founder Hiroshi Ohta launched Cloudian. Their bet? If compute was already evolving for AI, storage had to evolve too — not as a sidekick, but as an equal partner.</p><p>That’s why Cloudian’s platform isn’t just a bigger hard drive. It’s storage with brains — designed to move in parallel, feed GPUs without starving them, and collapse those messy layers between “data at rest” and “data in motion.”</p><p><em>(As first reported by </em><a href="https://news.mit.edu/2025/cloudian-helps-data-storage-keep-up-with-ai-revolution-0806"><em>MIT News</em></a><em>, Tso’s journey from parallel computing at MIT to building Cloudian shows how deep academic roots can shape industry-scale solutions.)</em></p><h3>4. What Cloudian Actually Does (in Plain English)</h3><p>So what’s Cloudian’s magic trick? They blur the line between <strong>where data lives</strong> and <strong>where data gets processed.</strong></p><p>In the old world, storage was passive. You dumped data into it, then begged it to cough things back up whenever the CPU or GPU asked. The handoff was slow, clunky, and layered with bottlenecks.</p><p>Cloudian flips that script. Their platform integrates <strong>storage and compute</strong> so that data doesn’t just sit there — it moves in <strong>parallel streams</strong> directly to GPUs and CPUs. Think of it like building a six-lane express highway instead of a single dirt road between your data and your processors.</p><p>The result? Lower latency, fewer idle GPUs, and less chaos in managing multi-tier storage setups. And here’s the kicker: in AI, it’s not enough to get “a little more efficient.” To push models meaningfully forward, you often need <strong>1,000 times more data</strong>, not just smarter algorithms. Cloudian’s system is designed to handle exactly that kind of scale.</p><p>It’s not glamorous like a shiny new GPU, but it’s the plumbing that decides whether your AI engine roars or sputters.</p><h3>5. The Bigger Shift: From Model-Centric to Data-Centric AI</h3><p>For years, the AI hype cycle worshiped models. Bigger transformers, more parameters, smarter algorithms — as if clever math alone would unlock intelligence. That worked for a while, but reality caught up fast: smarter models don’t matter if they’re starving for input.</p><p>We’re now entering the <strong>data-centric era of AI.</strong> The quality, accessibility, and flow of data define how well a system performs. You don’t get those “wow” improvements in accuracy by tweaking an equation — you get them by training on <em>orders of magnitude more data</em>, and moving it through your infrastructure at insane speeds.</p><p>That’s why companies are suddenly rethinking “boring” backend stuff:</p><ul><li><strong>NVMe-over-Fabrics</strong> to slash latency across clusters.</li><li><strong>RDMA pipelines</strong> so GPUs can pull data directly, without waiting on CPUs to babysit transfers.</li><li><strong>Object storage at scale</strong> to handle the messy, unstructured oceans of text, images, and video modern AI feeds on.</li></ul><p>Cloudian fits right into this shift. They’re not selling storage as a filing cabinet. They’re pushing storage as an <em>active participant</em> in the AI pipeline — compute at the edge of data. That’s a fundamental rethink of infrastructure, and it’s where the industry is quietly moving.</p><h3>6. Why This Matters Beyond Silicon Valley</h3><p>It’s easy to shrug this off as “big tech problems.” But the storage bottleneck isn’t just Google-scale — it’s creeping into every corner of the industry.</p><ul><li><strong>For engineers</strong>: Stop treating storage as a dumb vault. If your pipeline can’t deliver data in parallel, your GPUs are burning cash while twiddling their thumbs. Backend and infra engineers who understand storage-compute integration will be the ones who actually keep AI systems alive under real-world load.</li><li><strong>For AI startups</strong>: Don’t blow your entire budget on GPUs. The fastest cards in the world won’t save you if your data layer collapses. Fix your bottleneck first.</li><li><strong>For enterprises</strong>: Integrated storage-compute platforms are going to be <strong>table stakes.</strong> Just like Kubernetes became unavoidable for cloud-native apps, smarter storage will become non-negotiable for production AI.</li></ul><p>AI’s future isn’t just about who has the biggest GPU farm. It’s about who can feed those GPUs without starving them. That shift is already underway — and companies like Cloudian are proof.</p><h3>7. Final Thoughts: The Silent Battlefield</h3><p>The AI boom won’t collapse because we run out of GPUs. It’ll stall because we can’t feed them fast enough.</p><p>For decades, storage was the quiet plumbing of tech — invisible until it failed. But in the AI era, it’s not background anymore. It’s the frontline. Whoever solves the data bottleneck at scale wins the next decade of AI.</p><p>Cloudian’s story — from MIT labs to enterprise deployments — is just one example of that shift. It shows that the real breakthroughs won’t always come wrapped in silicon or parameter counts. Sometimes, they come from rethinking the most “boring” part of the stack.</p><p>And here’s the irony: the companies that treat storage as an afterthought will end up starving their AI engines. The ones that treat storage as compute’s equal partner? They’ll be the ones shaping the future.</p><h3><strong>Enjoyed this? </strong>❤️</h3><p>Follow and drop some Claps if you want more no-fluff takes on AI, storage, and the backend battles shaping tomorrow’s tech.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d46ca5b8333" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Computer Engineering Still Matters in 2025: Lessons Beyond Code]]></title>
            <link>https://zaina-hala.medium.com/why-computer-engineering-still-matters-in-2025-lessons-beyond-code-2585330df243?source=rss-d0d035e00f1d------2</link>
            <guid isPermaLink="false">https://medium.com/p/2585330df243</guid>
            <dc:creator><![CDATA[Zaina Hala]]></dc:creator>
            <pubDate>Tue, 19 Aug 2025 19:56:55 GMT</pubDate>
            <atom:updated>2025-08-19T19:56:55.131Z</atom:updated>
            <content:encoded><![CDATA[<h4>The foundations still run everything</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bG8KxtlDjghRuTFy" /><figcaption>Photo by <a href="https://unsplash.com/@zendure?utm_source=medium&amp;utm_medium=referral">Zendure Power Station</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Intro</h3><p>Everyone’s chasing the next shiny thing in tech — AI models, cloud-native buzzwords, the latest framework promising to “change everything.” But here’s the quiet truth nobody brags about: none of it works without the boring, invisible foundations that computer engineers have obsessed over for decades.</p><p>When your app feels slow, it’s rarely just a “bad line of code.” It’s usually the memory hierarchy laughing at you. When your cloud bill explodes, it’s not AWS being greedy — it’s poor system design, wasting cycles at the architecture level. These are problems Computer Engineering already solved long before “full-stack” became a job title.</p><p>That’s why Computer Engineering still matters in 2025. It’s not nostalgia. It’s the reason modern tech stands up at all.</p><h3>Section 1: The Forgotten Layer</h3><p>Most developers jump straight into code. Frameworks, libraries, quick fixes — that’s where the spotlight usually is. But the truth? The performance of your “modern” app is still chained to the same old fundamentals: hardware, memory, and architecture.</p><p>Take memory, for example. Everyone knows about variables, but very few stop to ask <em>where</em> those variables actually live. That “laggy” function you’re cursing might not be slow because of Python or JavaScript — it might be slow because the data keeps missing the CPU cache and pulling from RAM. That’s not a framework problem. That’s a Computer Engineering problem.</p><p>Or look at distributed systems. We glamorize Kubernetes clusters, but the real bottlenecks? They look a lot like the problems CE solved decades ago: synchronization, scheduling, and race conditions. The playground changed, the rules didn’t.</p><p>Computer Engineering is the layer nobody writes Medium posts about — but it’s the layer silently deciding whether your fancy AI model trains in two hours or two weeks.</p><h3>Section 2: Hardware–Software Co-Design in Daily Life</h3><p>Most people think Computer Engineering lives in dusty textbooks. But you actually run into it every single day — usually when something annoys you.</p><p>That mobile app that eats your battery in two hours? That’s not “bad design vibes.” It’s energy inefficiency at the chip level, where software ignores how the processor schedules tasks.</p><p>That streaming service that stutters on your “fast” Wi-Fi? Not magic. That’s buffer underflow — data isn’t arriving fast enough to fill the playback pipeline. A problem straight out of CE’s “systems” chapter.</p><p>That cloud bill that made your startup panic? Chances are it’s not AWS’s fault. It’s your code calling the database like a drunk dialing ex — hundreds of times more than it needs to. The result: wasted CPU cycles, wasted bandwidth, wasted money. Classic system-design ignorance.</p><p>When hardware and software don’t play nicely together, <strong>you feel it</strong> — in your laggy apps, your hot laptops, your monthly bills. Computer Engineering is the language that explains <em>why</em>.</p><h3>Section 3: Parallelism and Scaling</h3><p>Startups love to brag about “scaling.” More users, more servers, more buzzwords. But here’s the thing: scaling isn’t magic. It’s the same lesson Computer Engineering hammered into us years ago — parallelism and bottlenecks.</p><p>Think about a CPU pipeline. You don’t make one instruction faster by yelling at it — you break the work into stages. Fetch, decode, execute, write back. Multiple instructions flow through the pipe at once. Throughput goes up, without rewriting physics.</p><p>Web apps do the same thing. You don’t handle 10,000 users by hoping your single server “tries harder.” You pipeline requests, distribute them across cores, and remove the bottleneck that slows the entire flow.</p><p>And the bottlenecks? They’re always there. Just like a CPU stalls when it waits for memory, your backend stalls when it waits for the database. Doesn’t matter if you’re a chip or a startup — if one stage is slow, <em>everything</em> is slow.</p><p>That’s why CE principles feel timeless. Scaling web systems in 2025 is basically replaying what computer architects figured out in the 1970s. New playground, same rules.</p><h3>Section 4: Why This Still Matters in 2025</h3><p>For years, engineers coasted on Moore’s Law — chips doubling in power every couple of years, like clockwork. Write sloppy code? Doesn’t matter, the next generation of hardware will cover for you.</p><p>That era is over. Transistors aren’t shrinking the way they used to, and the “free lunch” of automatic speed-ups is gone. Which means the fundamentals of Computer Engineering — efficiency, parallelism, memory management — are suddenly back in the spotlight.</p><p>Look at AI. Training massive models isn’t just about smarter math. It’s about GPU memory bandwidth, cache locality, data movement. The same “boring” bottlenecks CE professors drilled into us decades ago are now the very limits holding back trillion-dollar industries.</p><p>Even cloud computing isn’t a get-out-of-jail card. If your system burns cycles and thrashes caches, AWS will happily charge you for every wasted millisecond. Scaling ignorance = scaling bills.</p><p>In 2025, Computer Engineering isn’t background noise. It’s the guardrail that separates companies that run fast and lean from those that drown in inefficiency.</p><h3>Section 5: Lessons Beyond Code</h3><p>Computer Engineering teaches a kind of humility. It reminds you that no matter how flashy the software stack looks, there’s always a limit underneath — in cycles, in memory, in bandwidth. Ignore that, and your “modern” system cracks in the same old ways.</p><p>That’s the real lesson: engineering isn’t about chasing the newest framework. It’s about understanding the layers that don’t change. The invisible stuff that decides whether your code runs smooth or bleeds money.</p><p>For me, Computer Engineering isn’t just a degree. It’s a lens. It taught me to think in systems, to spot bottlenecks before they blow up, to design with efficiency in mind. And that mindset? It’s more valuable in 2025 than ever.</p><p>Software may be eating the world, but Computer Engineering is still the table it eats on. Forget that, and the whole meal collapses.</p><h3>Thanks for reading ❤️</h3><p>You just read my very first Medium post. I’m treating this as the start of something long-term: breaking down Computer Engineering concepts in a way that’s clear, practical, and worth your time. If that’s something you want more of, hit <strong>Follow, Claps</strong> and <strong>Subscribe</strong>. Let’s figure this journey out together.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2585330df243" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>