<?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 F8010 on Medium]]></title>
        <description><![CDATA[Stories by F8010 on Medium]]></description>
        <link>https://medium.com/@f8010?source=rss-e5239857b252------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by F8010 on Medium</title>
            <link>https://medium.com/@f8010?source=rss-e5239857b252------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 06:53:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@f8010/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[Our HPA Took Down Production. Here’s What I Did in the First 30 Minutes.]]></title>
            <link>https://medium.com/@f8010/our-hpa-took-down-production-heres-what-i-did-in-the-first-30-minutes-777e972e4061?source=rss-e5239857b252------2</link>
            <guid isPermaLink="false">https://medium.com/p/777e972e4061</guid>
            <dc:creator><![CDATA[F8010]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 05:43:44 GMT</pubDate>
            <atom:updated>2026-11-19T05:43:44.688Z</atom:updated>
            <content:encoded><![CDATA[<p>It was 2:07 on a Tuesday afternoon when the first alert landed. Checkout latency was climbing. By 2:12, the support channel had its first customer complaint. By 2:15, the CEO was asking in a leadership thread why the app felt broken.</p><p>I was the engineering lead on call. Nothing had been deployed that day. No one had touched the code. That is what made the next few minutes so uncomfortable.</p><p>The cause turned out to be the <a href="https://best-kubernetes-consulting-companies.lovable.app/guide/kubernetes-complexities">Kubernetes Horizontal Pod Autoscaler</a>, the HPA. It is the feature that adds or removes copies of an application based on demand. We had turned it on months earlier, and it had quietly worked. That afternoon, it did the opposite of its job.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_HW1A3l8WQTUvpif" /><figcaption>Photo by <a href="https://unsplash.com/@rgaleriacom?utm_source=medium&amp;utm_medium=referral">Ricardo Gomez Angel</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>What Happened Before I Even Opened a Laptop</h3><p>A marketing email went out at 2:00. Traffic doubled in four minutes. The autoscaler saw the spike and started adding application copies, as designed. But each new copy opened connections to the same database. The database ran out of room. Requests slowed down. The autoscaler read the slowdown as more load and added even more copies.</p><p>More copies made the database slower. A slower database made the autoscaler add more copies. Nobody had planned for that loop.</p><p>Pull Quote: The tool meant to protect us from traffic was feeding the problem.</p><h3>The First 30 Minutes, Step by Step</h3><p>This is the core of the story, so I will give the full timeline. If you run a team, this is the order I would repeat.</p><h4>Minutes 0 to 5: Stop Guessing and Confirm the Pattern</h4><p>My first instinct was to roll back the last release. I did not, because nothing had shipped. Rolling back would have burned five minutes and fixed nothing.</p><p>I asked one question in the incident channel: “What changed in the last hour?” The only answer was the marketing email. That pointed at traffic, not code.</p><h4>Minutes 5 to 10: Look at the Replica Count</h4><p>I opened the dashboard and checked how many copies of the checkout service were running. Normal is 12. The number on screen was 140 and still rising.</p><p>That was the moment I understood the autoscaler was not responding to the problem. It was part of it.</p><h4>Minutes 10 to 15: Freeze the Scaling</h4><p>I did the least heroic thing available. I set the autoscaler’s maximum to 40 copies and stopped it from climbing further. I did not delete it. I did not rebuild anything.</p><p>Freezing a runaway system is almost always the right first move. You buy time, and time is what you need to think.</p><h4>Minutes 15 to 22: Relieve the Database</h4><p>With the count capped, I shrank the pile of copies down to a number the database could actually serve. Connections dropped. Query times started to recover. Checkout latency fell from eleven seconds to under two.</p><p>I also asked the marketing lead to hold the second email batch scheduled for 2:30. That was a human fix, not a technical one, and it mattered as much as anything I typed.</p><h4>Minutes 22 to 30: Tell People the Truth</h4><p>At 2:22, I posted a short update to leadership. It said what broke, what we had done, and when I would update again. It did not guess at a root cause. It did not blame anyone.</p><p>By 2:37, orders were flowing normally. Total impact was about 30 minutes of degraded checkout.</p><h4>Here is the timeline at a glance:</h4><p>Time: What I Did</p><ul><li><strong>0 to 5 minutes: </strong>Asked what changed. Ruled out a bad release.</li><li><strong>5 to 10 minutes:</strong> Checked replica count. Found 140 copies instead of 12.</li><li><strong>10 to 15 minutes: </strong>Capped the autoscaler at 40.</li><li><strong>15 to 22 minutes: </strong>Let the database recover. Paused the second email send.</li><li><strong>22 to 30 minutes: </strong>Sent a plain status update to leadership.</li></ul><h3>Why Autoscaling Fails in This Way</h3><p>Autoscaling reacts to pressure on one part of a system. It does not know about the parts behind it. When a downstream piece, like a database, becomes the bottleneck, adding more front-end copies makes things worse.</p><p>Three things made our setup fragile:</p><ul><li><strong>No ceiling.</strong> We had set a minimum number of copies but a maximum so high it meant nothing.</li><li><strong>No link to the database. </strong>Nobody had checked how many connections the database could handle against how many copies we might create.</li><li><strong>No warning from marketing.</strong> Engineering did not know a large email was going out. Traffic spikes are a business event before they are a technical one.</li></ul><h3>What We Changed the Following Week</h3><p>We did not buy new tools. We made five small decisions:</p><ol><li>Set a sensible maximum for every autoscaled service, based on what the database can carry.</li><li>Added a simple alert for when replica count grows faster than normal.</li><li>Created a shared calendar where marketing posts large sends before they happen.</li><li>Wrote a one-page runbook for this exact failure, so the next on-call person starts at minute 10, not minute 0.</li><li>Ran a short test with a traffic surge in staging to confirm the new limits held.</li></ol><h3>Checklist for Your Own Team</h3><p>Ask your engineers these questions this week:</p><ul><li><strong>Maximums: </strong>Does every autoscaled service have an upper limit that matches what its dependencies can handle?</li><li><strong>Visibility: </strong>Can someone see replica counts at a glance, without digging?</li><li><strong>Communication:</strong> Does engineering hear about large campaigns, launches, or sales before they go live?</li><li><strong>Practice: </strong>Has anyone rehearsed a traffic surge, even once?</li></ul><h3>Where Outside Help Fits</h3><p>This kind of failure sits between teams. Application engineers assumed the platform would handle scale. The platform team assumed the applications were sized correctly. Neither was wrong, but nobody owned the gap.</p><p>A good consulting partner can help here, and I say that as someone who resisted the idea at first. An outside team will map how your autoscaling, databases, and business calendar connect, then point out where one team’s assumption becomes another team’s outage. That kind of review costs far less than one bad afternoon of lost orders.</p><h3>What I Took Away</h3><p>The autoscaler did exactly what we told it to do. The mistake was ours, and it was a planning gap, not a tooling one.</p><p>If you lead a team, ask one question today: what happens to our systems when demand doubles in four minutes? If nobody can answer in a sentence, you have found your next project.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=777e972e4061" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The One Moment in a Pod’s Lifecycle a Platform Engineer Should Never Ignore]]></title>
            <link>https://medium.com/@f8010/the-one-moment-in-a-pods-lifecycle-a-platform-engineer-should-never-ignore-ef14c4ec211e?source=rss-e5239857b252------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef14c4ec211e</guid>
            <dc:creator><![CDATA[F8010]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 06:35:21 GMT</pubDate>
            <atom:updated>2026-11-18T06:35:21.791Z</atom:updated>
            <content:encoded><![CDATA[<p>It was 2:07 a.m. when the pager went off for a retail company’s checkout service. The dashboard showed green. Every pod said “Running.” Customers could not pay.</p><p>The on-call engineer spent forty minutes digging through logs. The pods were running, but they were not ready. Traffic was reaching containers that could not answer. Nobody had looked at the one moment that mattered: the gap between a pod starting and a pod being ready to work.</p><p>That gap is the moment a platform engineer should never ignore. If you run Kubernetes, or lead the people who do, this story is probably closer to your own than you would like.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oFDsHG8eZZkRQ7ou" /><figcaption>Photo by <a href="https://unsplash.com/@dcbelanger?utm_source=medium&amp;utm_medium=referral">Danielle-Claude Bélanger</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>What Happens Between “Started” and “Ready”</h3><p>A pod does not become useful the second it starts. The container launches, the application loads its settings, connects to databases, warms up its caches, and only then can it serve a real request.</p><p>Kubernetes does not know when that finishes unless someone tells it. The tool that tells it is the readiness probe, a small check that asks the application, “Can you take traffic now?” Until the answer is yes, the pod should receive nothing.</p><p>Many teams skip this check or set it up carelessly. The pod then gets traffic while it is still waking up. Customers see errors. The dashboard still shows green, because “Running” only means the container exists.</p><h3>Why This Moment Gets Missed</h3><p>The cause is rarely carelessness. It is usually a gap in ownership.</p><p>Developers assume the platform handles startup. The platform team assumes developers define what “ready” means. Nobody writes it down, so every service ends up with a different answer, or none.</p><p>Three failure patterns show up again and again:</p><ul><li><strong>Traffic too early:</strong> The pod accepts requests before its database connection exists. The first hundred customers get errors.</li><li><strong>Restart loops: </strong>A health check is too strict or too slow, so Kubernetes keeps killing a pod that was about to succeed. Engineers see the status CrashLoopBackOff and assume the code is broken.</li><li><strong>Memory kills:</strong> The application uses more memory at startup than during normal work. Kubernetes stops it with an OOMKilled status before it ever settles down.</li></ul><p>All three look like different problems. All three come from the same place: nobody defined what a healthy startup looks like.</p><h3>The Core Fix: Make Readiness a Platform Decision</h3><p>Treating readiness as a per-team afterthought guarantees inconsistency. The better move is to make it part of the platform itself, the internal developer portal and the golden paths your engineers use to ship software.</p><p>Here is what that looks like in practice.</p><p>Step 1, Give every service a startup contract. Before a service goes live, its team answers three questions: How long does startup take? What must be connected before it can serve traffic? How much memory does it need at its peak?</p><p>Step 2, Build the answers into the template. When a developer creates a new service from the portal, the readiness check, startup allowance, and memory settings are already there. They fill in values. They do not invent the structure.</p><p>Step 3, Separate “alive” from “ready.” A pod can be alive and still not ready. The platform should treat these as two different questions, so a slow starter is given time instead of being killed.</p><p>Step 4, Watch the gap. Track how long pods take to go from started to ready. When that number creeps up, something changed, and you find out before customers do.</p><p>The retail team did exactly this after their 2 a.m. incident. They added a startup contract to their service template. New services got sensible defaults from day one. The checkout service now takes ninety seconds to warm up, and Kubernetes waits patiently instead of sending customers into a wall.</p><h3>What Leaders Should Ask</h3><p>You do not need to read a single probe configuration to act on this. Three questions are enough:</p><ul><li>Do we know how long our critical services take to become ready?</li><li>Who owns the definition of “ready” for each service?</li><li>Does our platform set this up by default, or does each team start from scratch?</li></ul><p>If the answers are vague, you have found risk that no dashboard is showing you.</p><h3>Where Consulting Fits In</h3><p>Many organizations know this gap exists but cannot find time to close it. Their platform team is busy keeping things running.</p><p>A short engagement with a platform engineering consulting partner can audit how services start, find the weak spots, and help build the templates that make good startup behavior the default. The goal is a platform that does the right thing without anyone remembering to ask.</p><h3>The Takeaway</h3><p>Outages rarely come from dramatic failures. More often they come from a quiet gap that nobody owned, like the space between a pod starting and a pod being ready.</p><p>Define that moment. Build it into the platform. Watch it over time. The 2 a.m. page you avoid will be the one you never hear about.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef14c4ec211e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Manage Dev, Staging, and Production Namespaces in Kubernetes Without Duplicating YAML]]></title>
            <link>https://medium.com/@f8010/how-to-manage-dev-staging-and-production-namespaces-in-kubernetes-without-duplicating-yaml-196c60a74e82?source=rss-e5239857b252------2</link>
            <guid isPermaLink="false">https://medium.com/p/196c60a74e82</guid>
            <dc:creator><![CDATA[F8010]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 08:50:31 GMT</pubDate>
            <atom:updated>2026-11-16T08:50:31.210Z</atom:updated>
            <content:encoded><![CDATA[<p>A payments company shipped a small change on a Friday afternoon. It passed in staging. It failed in production within minutes. The cause was one line of configuration. Staging had a longer timeout. Production still had the old one. Nobody caught it because the two environments lived in separate copies of the same files, and someone had edited only one.</p><p>The team fixed it in four hours and lost their weekend. Monday morning, the CTO asked a fair question: why do we keep three copies of everything?</p><p>If you run Kubernetes, you may be asking the same thing. This article explains how to manage dev, staging, and production namespaces in Kubernetes without duplicating YAML. It is written for technology leaders who want the idea, not the syntax.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dMNj_7UHFM2d_cI1" /><figcaption>Photo by <a href="https://unsplash.com/@afgprogrammer?utm_source=medium&amp;utm_medium=referral">Mohammad Rahmani</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>What Namespaces and YAML Mean in Plain Words</h3><p>A namespace is a separate room inside the same building. Dev is where engineers experiment. Staging is the dress rehearsal. Production is where customers are.</p><p>YAML is the instruction sheet that tells Kubernetes what to run in each room.</p><p>Most teams start by copying the instruction sheet three times. It feels fast. It stops feeling fast around month six.</p><h3>Why Copied Files Cause Outages</h3><p>The payments company was not careless. Copying is the natural first move, and the problems arrive slowly:</p><ul><li>Drift: Each copy changes on its own schedule, so the rooms stop matching.</li><li>Slow fixes: A security patch must be applied three times, and someone forgets one.</li><li>Hidden differences: Nobody can say which differences are on purpose and which are accidents.</li><li>Painful audits: Proving that production matches an approved setup takes days of manual comparison.</li></ul><h3>How to Manage Dev, Staging, and Production Namespaces Without Duplicating YAML</h3><p>Keep one shared base that describes the application once. Store only the differences for each environment in small separate files. A tool combines the base with the differences and produces the final instructions for each namespace. Git holds all of it, so every change has an author, a date, and a review.</p><p>Think of a franchise operations manual. The core manual is identical in every location. Each location adds one short page with its local hours and local prices. Nobody rewrites the whole manual to open a new store.</p><p>Here is how that looks in practice:</p><ol><li>Write the base once. Describe the application, its settings, and its safety rules in a single place.</li><li>List the real differences. Dev needs one copy of the app and a small amount of memory. Production needs several copies, more memory, and stricter access. Write down only those gaps.</li><li>Pick the combining tool. Kustomize and Helm are the two common choices. The next section compares them.</li><li>Store everything in Git. One repository, one review process, one history.</li><li>Deploy from Git automatically. Tools such as Argo CD or Flux compare what Git says with what is running and fix any gap. This habit is called GitOps.</li><li>Promote changes, do not rewrite them. A change moves from dev to staging to production through a merge, not through three separate edits.</li></ol><p>The payments company followed these steps over six weeks. Their staging and production files shrank to a few lines each. The timeout setting that caused the outage now lives in one place, and any difference between staging and production is visible in a single short file.</p><blockquote>The goal is not fewer files. The goal is one place to look when something is different.</blockquote><h3>Choosing Between Kustomize, Helm, and GitOps Overlays</h3><p>This is where engineers argue the most, so here is the plain version.</p><ul><li>Kustomize: Layers small patches over a base. Easy to read and easy to review. It gets awkward when applications vary a lot.</li><li>Helm: Packages the application as a template with fill-in-the-blank values. Powerful and widely used for third-party software. Templates become hard to read as they grow.</li><li>GitOps overlays: Not a rival tool. This is the practice of keeping overlays in Git and letting Argo CD or Flux apply them. It works with Kustomize and with Helm.</li></ul><p>My recommendation is to start with Kustomize for the applications your own teams write. Use Helm for software you did not write, such as monitoring tools or databases. Put GitOps delivery on top of both.</p><p>The tradeoff is real. If you run dozens of near-identical services, Kustomize overlays multiply and become their own copy problem. At that point, shared Helm charts or a platform layer pay off.</p><h3>Where a Platform Fits</h3><p>Choosing a tool solves the files problem. It does not solve the people problem.</p><p>Picture a new developer on day one. She should not have to learn overlays, patches, and promotion rules before she ships her first change. That is the job of a platform, in the platform engineering sense.</p><p>A platform team builds the process once and offers it as a paved road. In an internal developer portal, the developer picks a service template, chooses an environment, and clicks deploy. The portal creates the base, the overlays, and the Git repository behind the scenes. It also shows which version is running in dev, staging, and production.</p><p>The developer never touches the machinery. The platform team maintains it in one place. When the security team requires a new rule, it changes once and reaches every service.</p><h3>When Outside Consulting Helps</h3><p>A capable team can set up one base and two overlays in a week. The hard part comes after that.</p><p>Someone has to move forty existing services off their copied files without breaking any of them. Someone has to settle naming, access rules, and who approves a production release. Someone has to build the portal so developers want to use it instead of working around it.</p><p>This is where platform engineering consulting earns its fee. A consulting partner has seen these migrations across many companies. It can show you which services to move first, which arguments to skip, and which shortcuts create new drift. Your team keeps ownership, and the outside help shortens the learning curve.</p><p>If your team already has strong platform skills, you may not need it. If your engineers are also running daily operations, an outside team can protect their time.</p><h3>What Changed for the Payments Company</h3><p>Six weeks after the Friday outage, the same team shipped another release on another Friday. It passed in staging and passed in production. Nobody noticed, which was the point.</p><p>They did not buy a new product. They stopped keeping three copies of the truth.</p><p>Start small. Pick one service, write its base, and move its three environments onto it. Measure how long the next change takes. Then decide how fast to move the rest.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=196c60a74e82" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Linux vs macOS for Kubernetes Platform Work: Switched After 8 Years, No Regrets]]></title>
            <link>https://medium.com/@f8010/linux-vs-macos-for-kubernetes-platform-work-switched-after-8-years-no-regrets-a05b588e0539?source=rss-e5239857b252------2</link>
            <guid isPermaLink="false">https://medium.com/p/a05b588e0539</guid>
            <dc:creator><![CDATA[F8010]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 05:30:42 GMT</pubDate>
            <atom:updated>2026-11-10T05:30:42.016Z</atom:updated>
            <content:encoded><![CDATA[<p>For eight years, a MacBook was my work laptop. I loved it. Then a Tuesday demo changed my mind.</p><p>I was showing a platform team’s new internal developer portal to a client. The portal lets developers click a button and get a running service. I clicked. The service failed to start. The container image I built that morning on my laptop was built for the wrong chip. The cluster ran on standard servers, and my laptop spoke a different dialect.</p><p>I fixed it in ten minutes while everyone watched. It was a small thing. It was also the fourth time that month something like it had happened.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lbnzZ7hzs6Eo_Ks0" /><figcaption>Photo by <a href="https://unsplash.com/@martinkatler?utm_source=medium&amp;utm_medium=referral">Martin Katler</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Where The Friction Came From</h3><p>None of these problems were big. Together they cost me hours every week.</p><p><strong>Chip mismatch: </strong>My Mac builds for Arm. Most production clusters run on x86. Images built locally sometimes failed in the cluster, and the error never pointed at the cause.</p><p><strong>Hidden virtual machine: </strong>Containers do not run natively on a Mac. Docker Desktop runs a small Linux machine in the background. It held a large share of my memory even when I was idle.</p><p><strong>Slow local clusters: </strong>Spinning up a test cluster took minutes. I started avoiding tests because I did not want to wait.</p><p><strong>Battery drain:</strong> Running a local cluster meant keeping the charger within reach, which defeated the point of a laptop.</p><p>I blamed myself for a long time. I assumed I had configured something badly. Then a colleague who had used Linux for years watched me wait on a cluster and asked a simple question. “Why are you running a Linux machine inside a Mac?”</p><p>I had no good answer.</p><h3>The Switch</h3><p>I did not switch overnight. I installed Ubuntu on a spare ThinkPad and used it for one project first. Within a week, I stopped opening the Mac.</p><p>Here is what changed in my daily platform work.</p><h3>What Actually Changed For Kubernetes Platform Work</h3><p>This is the part that matters if you lead a platform team or fund one. Kubernetes runs on Linux. When your laptop runs Linux too, a whole layer of translation disappears.</p><p>Containers run directly on the machine. There is no virtual machine in between. A local test cluster that took around four minutes on my Mac now starts in under one. I run tests more often because the wait is gone.</p><p>Images match production. I build on x86 and deploy to x86. The wrong-chip failures stopped. My demos stopped breaking for reasons nobody could explain.</p><p>Memory stays free. The background virtual machine used to take several gigabytes. Now that memory goes to my editor, my browser, and the cluster itself. I can run a realistic local setup of a developer portal with several services and still have room left.</p><p>Debugging gets simpler. When something fails, I look at the real thing. The network, the files, and the processes are the same ones Kubernetes sees. I no longer wonder whether the problem lives in my laptop’s extra layer.</p><p><strong>Here is the shape of a typical day, before and after.</strong></p><p>Before: Open laptop, wait for Docker to start, wait for the cluster, build an image, find out it is the wrong architecture, rebuild.</p><p>After: Open laptop, start the cluster, build, test, ship.</p><p>That sounds minor. Multiply it by every engineer on a platform team, every day, for a year. Faster feedback is the whole point of a platform. It felt strange that my own tools were slowing me down.</p><h3>What I Miss</h3><p>I will be honest about the costs, because there are some.</p><p><strong>Battery and trackpad:</strong> The MacBook is still better. My ThinkPad lasts a working morning on battery, not a full day. The trackpad is fine, but it is not a Mac trackpad.</p><p><strong>Polish: </strong>Mac apps look better and feel smoother. I miss that small daily pleasure.</p><p><strong>Corporate setup: </strong>Many companies manage their laptops with tools built around Windows and macOS. Linux needs an approved path and some extra work from the IT team. I had to ask for one, and it took a few weeks.</p><p><strong>Video calls and office tools: </strong>Most work in the browser. A few things needed workarounds.</p><h3>Who Should Switch</h3><p>I do not think everyone should. A Mac is still a great laptop, and many good platform engineers use one every day. A simple way to decide is below.</p><p><strong>Stay on macOS if:</strong> You mostly write code and review work, and your clusters live in the cloud. You rarely run things locally.</p><p><strong>Move to Linux if:</strong> You build and test containers all day, run local clusters, or maintain a developer portal where small delays pile up.</p><p><strong>Try before you commit: </strong>Dual boot or use one spare machine for a single project. That is what I did.</p><h3>Why I Bring This Up In Consulting Work</h3><p>In my consulting work, I talk with CXOs who want their platform teams to move faster. They usually look at big things first, like new tools, reorganizations, or more headcount. Few look at the laptop on the engineer’s desk.</p><p>I now ask one small question early in any engagement. How long does it take a developer to go from a code change to a running test? If the answer is minutes, there is a hidden cost nobody has measured. Sometimes the fix is a better pipeline. Sometimes it is a better laptop setup. Both are cheaper than a reorganization.</p><h3>Final Thoughts</h3><p>I did not switch because of a benchmark or a blog post. I switched because a demo broke in front of a client and I got tired of explaining why.</p><p>Eight years on a Mac taught me a lot, and I still respect it. For Kubernetes platform work, though, Linux removes a layer I never needed. My clusters start faster, my images match production, and I wait less.</p><p>If your platform team feels slow and nobody can say why, start with the laptop. Watch one engineer work for an hour. You may find the answer sitting right on the desk.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a05b588e0539" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Make Your Internal Kubernetes Platform Hard to Ignore]]></title>
            <link>https://medium.com/@f8010/how-to-make-your-internal-kubernetes-platform-hard-to-ignore-57d2926456c9?source=rss-e5239857b252------2</link>
            <guid isPermaLink="false">https://medium.com/p/57d2926456c9</guid>
            <dc:creator><![CDATA[F8010]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 04:39:42 GMT</pubDate>
            <atom:updated>2026-11-09T04:39:42.455Z</atom:updated>
            <content:encoded><![CDATA[<p>Maya ran engineering at a mid-size retailer. Her team spent nine months building an internal Kubernetes platform. It had a clean developer portal, standard templates, and automated deployments. The launch email went out on a Tuesday.</p><p>Six weeks later, she checked the numbers. Four teams out of thirty were using it. The rest kept doing what they had always done: filing tickets, waiting on the infrastructure group, and copying old setups from old projects.</p><p>Her engineers were not lazy. Her platform was not broken. It was just easy to ignore. If you lead technology at a company, this story probably sounds familiar. Here is how to build an internal Kubernetes platform that teams choose on their own.</p><h3>Why Good Platforms Get Ignored</h3><p>Maya’s team built what they thought developers needed. They never asked the developers. Three habits explain most of the silence she saw:</p><p>Built for the builders: The platform team designed around their own preferences, so the portal used their vocabulary and their workflow.</p><p>Launched as a mandate: Teams heard “you must use this” and treated it as extra work, not a favor.</p><p>Never compared to the old way: Nobody measured whether the platform was actually faster than filing a ticket.</p><p>“A platform is a product. Its customers are your developers, and they can say no.”</p><p>How to Make Your Internal Kubernetes Platform Hard to Ignore</p><p>Maya changed her approach. She stopped asking how to get people to adopt the platform and started asking why anyone would want to. These six steps came out of that shift.</p><h3>Start with one painful task</h3><p>Maya sat with three teams and asked where they lost the most time. All three gave the same answer: getting a new service running took two weeks. She dropped her roadmap and fixed only that. A developer picks a template in the portal and gets a running service in under an hour. Nothing else shipped until that worked.</p><h3>Make the easy path the default path</h3><p>Developers take the route with the least friction. Maya made sure the portal was the fastest way to do everything. A new service, a new environment, and a new database all started in one place. When the platform is faster than the ticket queue, the queue empties by itself.</p><h3>Put everything in one front door</h3><p>Her developers used to hunt through wikis, chat threads, and old documents to find who owned a service or how to deploy it. The internal developer portal now answers those questions on one page. Service owner, documentation, health, and deployment status all sit together. People return to the portal because it saves them a search.</p><h3>Hide the complexity</h3><p>Kubernetes has hundreds of settings. A product developer needs about five of them. Maya’s team set sensible defaults for security, scaling, and cost, and exposed only the few choices that matter. Developers ship without becoming cluster experts.</p><h3>Recruit friendly early users</h3><p>She did not announce a company-wide launch. She picked two teams who were eager and gave them white-glove support. Within a month, those teams were telling their colleagues how much faster they shipped. Peer stories carried more weight than any email from leadership.</p><h3>Treat feedback like a product backlog</h3><p>Her platform team now holds a short monthly session with developers. Every complaint goes on a visible list. Every fix gets announced. Developers see that someone listens, and they keep telling the team what is broken.</p><h3>What Leaders Should Measure</h3><p>Adoption was the number Maya watched first, but it was not the only one. Executives who sponsor a platform should ask for these:</p><p>Time to first deployment: How long a new developer takes to ship something real. This number shows whether the platform is easy to learn.</p><p>Ticket volume: How many requests still go to the infrastructure group. A falling number means developers trust the platform.</p><p>Voluntary usage: How many teams use the platform without being told to. Forced adoption hides problems. Chosen adoption exposes them.</p><p>Developer satisfaction: A simple quarterly question about whether the platform makes their work easier.</p><h3>Where Consulting Fits In</h3><p>Maya’s team was strong on technology and short on product thinking. Midway through the project, she brought in an outside <a href="https://best-kubernetes-consulting-companies.lovable.app/">Kubernetes consulting partner</a> for a short engagement. The consultants interviewed developers, mapped where time was lost, and helped the team rank what to build first. They also ran the early-user program so the internal team could stay focused on the build.</p><p>A good consulting partner brings pattern recognition from many platforms. They have seen which features get used and which ones collect dust. That shortens the learning curve and keeps leadership from funding the wrong work for six months.</p><h3>The Takeaway</h3><p>An internal Kubernetes platform wins when developers pick it without being asked. That happens when it solves a real pain, takes less effort than the old way, and improves because people can say what is wrong.</p><p>Maya’s platform now serves 24 teams. Nobody mandated it. It is simply the fastest way to get work done.</p><p>If your platform is quiet, ask your developers why. Their answer is your roadmap. If you want an outside view, talk with a consulting team that has helped others through the same turn.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=57d2926456c9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Kubernetes Security Skills I Would Bet My Career on for the Next 5 Years]]></title>
            <link>https://medium.com/@f8010/the-kubernetes-security-skills-i-would-bet-my-career-on-for-the-next-5-years-c3b936087fba?source=rss-e5239857b252------2</link>
            <guid isPermaLink="false">https://medium.com/p/c3b936087fba</guid>
            <dc:creator><![CDATA[F8010]]></dc:creator>
            <pubDate>Fri, 23 Oct 2026 07:24:45 GMT</pubDate>
            <atom:updated>2026-10-23T07:24:45.015Z</atom:updated>
            <content:encoded><![CDATA[<p>A few years ago, I got a call from a CTO at a retail company. It was a Sunday evening. His team had found a forgotten test service running in their production cluster. Nobody remembered building it. Nobody knew who owned it. It had a door open to the internet, and it sat three steps away from customer data.</p><p>Nothing was stolen. He was lucky. But he asked me a question I still think about: “Which skills should my people actually learn so this never happens again?”</p><p>This article is my answer. If you lead a technology team, or you fund one, these are the Kubernetes security skills I would build a career on for the next five years.</p><h3>Why Security Skills Matter More Every Year</h3><p>Kubernetes now runs the systems that take orders, move money and store records. That makes it a target, and it makes mistakes expensive.</p><p>Here is what I see in the field:</p><p>Clusters multiply: One cluster becomes ten. Ten become fifty. Nobody tracks them all.</p><p>Teams move fast: Developers ship daily. Security reviews happen monthly. The gap is where trouble starts.</p><p>Tools change quickly: The product your team learned last year may be replaced next year.</p><p>The last point matters most. Tools expire. Skills do not. So the question is which skills hold their value no matter which tool wins.</p><h3>The Five Kubernetes Security Skills Worth Betting On</h3><p>I picked these five by watching what separated calm teams from panicked ones. Each one stays useful when the tools change.</p><h4>#1 Designing Who Can Do What</h4><p>Think of a building. Not everyone needs a key to every room. Kubernetes works the same way. Every person, every application and every automated job gets some level of access. In most clusters I review, far too many of them hold master keys.</p><p>The skill here is deciding access on purpose. Who needs to see this? Who needs to change it? What is the smallest key that gets the job done?</p><p>In the retail case, the forgotten test service had broad access because someone copied a template and never trimmed it. One shortcut years earlier created the exposure.</p><p>What it looks like in practice: A person who can sit with a team lead and say, “This service reads orders. It should never write them. Let’s fix that.”</p><p>Why it lasts: Every future system will need access rules. The technology changes. The question does not.</p><h4>#2 Knowing What Goes Into Your Software</h4><p>Modern software is assembled from thousands of parts written by strangers. Your team did not write most of what runs in production.</p><p>Picture a restaurant. The chef can be excellent, but if a supplier delivers spoiled ingredients, customers still get sick. Software has suppliers too. Every borrowed component is an ingredient.</p><p>This skill means tracking what you use, where it came from and whether anyone has reported problems with it. It also means being able to answer one question fast: “A flaw was just announced. Are we affected?”</p><p>Teams without this skill take days to answer. Teams with it take minutes.</p><h4>#3 Turning Rules Into Automatic Checks</h4><p>Written policies get ignored. Not out of bad intent. People are busy.</p><p>The stronger approach is to build the rule into the system itself. If a service tries to launch without an owner, it gets stopped. If it asks for too much access, it gets stopped. Nobody has to remember anything.</p><p>A bank I worked with moved from a forty-page security document to a handful of automatic checks. Reviews got shorter. Mistakes dropped. Developers stopped feeling policed, because the system told them what to fix before they got blocked.</p><p>This skill sits where security meets the platform team. People who can write good rules, and explain them kindly, are rare.</p><h4>#4 Spotting Strange Behavior While It Happens</h4><p>Locks keep most trouble out. Some gets in anyway. The next skill is noticing it.</p><p>Think of a night guard who knows the building. A janitor in the hallway at midnight is normal. A stranger opening the server room is not. The guard does not need a manual for that. The guard knows what normal looks like.</p><p>In a cluster, this means knowing which services usually talk to each other, how much data usually moves and what usually runs at 3 a.m. When something breaks the pattern, a trained person notices within minutes.</p><p>Without this skill, companies learn about break-ins from customers, journalists or regulators. That is the worst way to find out.</p><h4>#5 Explaining Risk in Plain Language</h4><p>I put this one last, but it may be the most valuable.</p><p>Plenty of people understand the technical side. Far fewer can walk into a leadership meeting and say, “Here is the risk, here is what it costs to fix, and here is what happens if we wait.”</p><p>The person who can do that gets budget, gets trust and gets promoted.</p><p>“Security people who speak business get funded. Security people who speak only technology get ignored.”</p><h3>Skills I Would Not Bet On</h3><p>Some skills feel important and age badly.</p><p>Memorizing one vendor’s product: The product may be gone in three years. The thinking behind it will not be.</p><p>Collecting certificates alone: A certificate shows you studied. It does not show you can calm a room during an incident.</p><p>Chasing every new threat headline: Most headlines repeat the same old lessons. Learn the basics deeply instead of the news shallowly.</p><h3>Ninety Days to Start Building These Skills</h3><p>If you lead a team, you do not need a big program. Start small.</p><ol><li>Take a list of every cluster and every service. Write down an owner next to each. Anything without an owner gets a deadline: claim it or remove it.</li><li>Pick your three most sensitive services. Review who has access to them. Trim anything unneeded.</li><li>Choose one rule your team keeps breaking. Turn it into an automatic check.</li><li>Run a short practice drill. Tell the team a flaw was announced in a popular component and ask how fast they can find affected services. Time it.</li><li>Ask one engineer to present the results to leadership in ten minutes, with no jargon.</li></ol><p>That last step builds skill number five, and it shows you who is ready to grow.</p><h3>Where Outside Help Fits</h3><p>Some companies do this alone and do it well. Others hit a wall because the team is busy running daily work. Consulting can speed things up when it focuses on teaching instead of taking over.</p><p>The engagements that worked best followed one pattern. Our consultants worked next to the client team, built the first few checks together and stepped back. Within a few months, the client team owned everything. The skills stayed after we left, which was the point.</p><h3>A Quick Checklist for Leaders</h3><p>Use this in your next team meeting:</p><p>[ ] Every cluster and service has a named owner</p><p>[ ] Access is reviewed at least twice a year</p><p>[ ] Key rules run as automatic checks</p><p>[ ] The team can list affected services within an hour of a new flaw announcement</p><p>[ ] Someone on the team can explain top risks to the board in plain words</p><p>If you can tick four out of five, you are ahead of most companies I meet. If you tick two or fewer, you now know where to start.</p><p>The CTO from that Sunday call has since built a team that checks all five. His cluster is not perfect. Nobody’s is. But when something odd shows up now, someone notices in minutes, someone owns it and someone can explain it to the CEO by Monday morning.</p><p>So here is my question for you. If a forgotten service sat in your production cluster tonight, how long would it take your team to find it, and who would they call?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c3b936087fba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cilium Is More Than a CNI: Why We Don’t Need kube-proxy Anymore]]></title>
            <link>https://medium.com/@f8010/cilium-is-more-than-a-cni-why-we-dont-need-kube-proxy-anymore-725b86cd6705?source=rss-e5239857b252------2</link>
            <guid isPermaLink="false">https://medium.com/p/725b86cd6705</guid>
            <dc:creator><![CDATA[F8010]]></dc:creator>
            <pubDate>Thu, 22 Oct 2026 03:43:24 GMT</pubDate>
            <atom:updated>2026-10-22T03:43:24.956Z</atom:updated>
            <content:encoded><![CDATA[<p>Priya runs platform engineering at an online retailer. At 2 a.m. on Black Friday, her phone lit up. Checkout was slow. Not down, just slow enough that carts were being abandoned.</p><p>Her team did what teams do. They added servers. Nothing changed. CPU looked fine. Memory looked fine. The slowdown was somewhere in the plumbing between services.</p><p>It took three hours to find it. The culprit was a small, old component inside Kubernetes called kube-proxy. If your company runs Kubernetes, you probably have one on every server right now. This article explains why a growing number of teams are replacing it with Cilium, and what that means for the business.</p><h3>What kube-proxy Does and Why It Slows Down</h3><p>Kube-proxy is the traffic director inside a Kubernetes cluster. When one service needs to talk to another, kube-proxy decides where the request goes.</p><p>Think of a receptionist with a printed phone list. Every new service adds a line to the list. When a call comes in, the receptionist reads down the list until they find the right name.</p><p>With 50 services, that works. With 5,000, the receptionist spends real time reading. Every call pays that cost, and the list keeps growing as the company grows.</p><p>Updating the list also hurts. Each change forces the receptionist to rewrite large parts of it. In a busy cluster, that rewriting competes with live traffic.</p><p>“A routing layer built for a hundred services does not stop working at five thousand. It just gets slower, quietly, until a peak day exposes it.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*niV4FIot5l3miIY9" /><figcaption>Photo by <a href="https://unsplash.com/@thephotoandfocus?utm_source=medium&amp;utm_medium=referral">MARCO</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>What Cilium Is Beyond a CNI</h3><p>A CNI is the part of Kubernetes that connects containers to the network. Most teams treat it as a basic utility and pick one early. Cilium started in that role, but it does more:</p><ul><li>Networking: Connects workloads across the cluster and handles routing between them.</li><li>Security: Controls which services may talk to each other, down to the application level.</li><li>Visibility: Shows who is talking to whom, in real time, through a tool called Hubble.</li><li>Load balancing: Does the job kube-proxy does today, without the printed list.</li></ul><p>One tool replaces several. That matters to anyone paying for the people who maintain them. Cilium is also a graduated project of the Cloud Native Computing Foundation, and Microsoft offers it inside Azure Kubernetes Service through Azure CNI powered by Cilium.</p><h3>How Cilium Replaces kube-proxy</h3><p>This is the core of the story. Cilium uses a technology called eBPF. You do not need to learn it. You need one idea: eBPF lets small, safe programs run inside the operating system itself, right where network traffic passes through.</p><p>Go back to the receptionist. Cilium removes the printed list and puts an indexed directory at the front door. A call comes in, the directory finds the destination in one step, and the call is routed. The size of the directory barely changes how fast the lookup runs.</p><p>Here is what happens when one service calls another with Cilium in charge:</p><ol><li>A request leaves a container, headed for a service name.</li><li>Cilium catches it inside the operating system, before it travels further.</li><li>Cilium looks up the destination in its directory. This is a direct lookup, not a walk down a list.</li><li>The request goes straight to a healthy destination.</li><li>Hubble records what happened, so your team can see it later.</li></ol><p>For Priya, the difference was concrete. After her team moved to Cilium in a staging cluster, the same load test that had choked checkout ran clean. They made the switch in production two months before the next peak season.</p><p>Cilium also keeps working when kube-proxy is gone entirely. Teams call this running in “kube-proxy replacement mode.” The old component is removed from every server, and Cilium handles every job it used to do.</p><h3>What Changes for the Business</h3><p>Executives do not care about packet paths. They care about outcomes. Here is what a switch tends to change:</p><p>Peak day stability: Traffic spikes stop punishing the routing layer, so fewer 2 a.m. calls.<br> Faster troubleshooting: Hubble shows which service is failing, so engineers stop guessing.<br> Fewer tools: Networking, security rules, and visibility live in one place, which cuts licensing and training work.<br> Cleaner audits: Clear records of which services can talk to which ones make security reviews simpler.</p><h3>Checklist Before You Switch</h3><p>Moving off kube-proxy is a platform decision, not a weekend project. Run through this list first:</p><p>Check your Linux kernel versions on every server. Cilium needs a reasonably modern kernel.<br> Confirm your cloud provider supports Cilium in your managed Kubernetes service.<br> Test in a staging cluster with realistic traffic, not an empty one.<br> Write down your current network security rules so you can compare them after the move.<br> Plan the rollout cluster by cluster, with a rollback path for each one.<br> Tell your support and on-call teams what is changing and when.</p><h3>When to Keep kube-proxy</h3><p>Cilium is not the right move for every company. Small clusters with a handful of services will not feel the problem. Older servers running outdated kernels may not support it. And a team already stretched thin may be better off waiting until it has the time to learn a new tool well.</p><p>If your clusters are small and stable, kube-proxy is fine. The case for Cilium grows with scale, with the number of services, and with how much a slow checkout page costs you per minute.</p><h3>Where Consulting Fits In</h3><p>Priya’s team was strong, but they had never run a networking migration at this scale. They brought in an outside consulting partner for two things: a review of their cluster design before the move, and a rollout plan that protected live traffic.</p><p>That is a common pattern. The technology is not the hard part. The hard part is sequencing the change across production clusters, training the people who will run it, and agreeing on what success looks like before you start. A consulting engagement earns its fee in those decisions, especially when your internal developer portal and platform team are already running at capacity.</p><h3>Takeaway</h3><p>Kube-proxy did its job for years. But it was built for smaller clusters, and it reads from a list that keeps growing. Cilium replaces that list with a directory, and adds security and visibility in the same step.</p><p>If your platform engineering team is adding servers to fix slowness that CPU graphs cannot explain, ask one question: how does traffic find its destination inside our clusters? The answer may be a printed phone list, and the fix may be smaller than you think.</p><p>Meta Description: Cilium can replace kube-proxy in Kubernetes. Learn how eBPF networking works, what changes for your business, and when to make the switch. (146 characters)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=725b86cd6705" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Best Platform Engineer Refused To Use kubectl For One Week. By Friday, He Said…]]></title>
            <link>https://medium.com/@f8010/my-best-platform-engineer-refused-to-use-kubectl-for-one-week-by-friday-he-said-7426dd9c0d76?source=rss-e5239857b252------2</link>
            <guid isPermaLink="false">https://medium.com/p/7426dd9c0d76</guid>
            <dc:creator><![CDATA[F8010]]></dc:creator>
            <pubDate>Tue, 20 Oct 2026 15:32:52 GMT</pubDate>
            <atom:updated>2026-10-20T15:32:52.670Z</atom:updated>
            <content:encoded><![CDATA[<p>Daniel has been on my team for six years. He is the person everyone calls when production breaks at night. He types commands faster than most people read. So when I told the team we were rolling out an internal developer portal, he looked at me like I had asked him to cook dinner with oven mitts on.</p><p>“I’ll keep using kubectl,” he said. “It’s faster.”</p><p>I didn’t argue. I made him a deal instead. For one week, he would do his daily work through the portal only. No command line. If he hated it by Friday, I would drop the rollout for the quarter.</p><p>He shook my hand. He was smiling. He thought he had already won.</p><p>This is the story of that week, and what it taught me about platform engineering, speed, and the quiet cost of having a hero on your team.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*10hLqmSyYUHkeiYb" /><figcaption>Photo by <a href="https://unsplash.com/@andrewtneel?utm_source=medium&amp;utm_medium=referral">Andrew Neel</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Why I Made The Bet</h3><p>For context, kubectl is the command line tool engineers use to control the systems that run our applications. It is powerful. It is also a tool that only a few people on any team truly master.</p><p>Our problem was never skill. Our problem was lines. Developers needed a new environment, a log, a permission, or a deployment. They asked Daniel or one of two other engineers. Then they waited.</p><p>Here is what I saw in our team metrics and hallway talk before the bet:</p><p>Waiting time: Developers spent more time asking for things than building things.<br> Interruptions: Our best engineers were answering the same five questions every week.<br> Risk: Three people held knowledge that the whole company depended on.<br> Morale: New hires felt embarrassed to ask for help a fourth time.</p><p>An internal developer portal is a single place where developers can request and manage what they need without filing a ticket. It sits on top of the same systems. Nothing about the underlying work changes. What changes is who can do it, and how long it takes.</p><p>Daniel did not see it that way. He saw a toy.</p><h3>Monday Through Thursday</h3><p>Daniel kept a short log that week. He shared it with me afterward. Here is the version I remember best.</p><ol><li>Monday: He spent the morning annoyed. He could not find a setting he knew by heart on the command line. He asked a junior engineer for help. That had never happened before.</li><li>Tuesday: He created a test environment in a few clicks. It took him about as long as it took to type the old command. He said nothing.</li><li>Wednesday: A developer from another team needed a new service set up. Daniel did not do it. The developer did it alone, using the portal, while Daniel watched over his shoulder.</li><li>Thursday: Daniel got through his entire task list by lunch. He spent the afternoon on a problem he had postponed for four months.</li></ol><p>That Thursday afternoon is the part I think about most. He was not faster at the old tasks. He was free of them.</p><h3>What Daniel Said On Friday</h3><p>I booked a short meeting on Friday morning. I expected a speech about why the command line was better. I had my reply ready.</p><p>Daniel sat down and was quiet for a moment.</p><p>“I didn’t miss it,” he said. “And I think I’ve been the bottleneck.”</p><p>Nobody had told him that. Nobody would have dared to. He figured it out on his own, standing behind a developer who set up a service in ten minutes without asking him a single question.</p><p>He kept going. His whole value, he said, had been tied to being the person who knew how. Every request made him feel needed. But every request also meant someone was stuck until he got to it.</p><p>Then he said the thing that made the whole experiment worth it.</p><p>“The best version of my job is building the thing that makes me unnecessary for this stuff.”</p><p>That is platform engineering in one sentence. It is the practice of building shared tools so that developers can serve themselves, and platform engineers can work on harder problems. The portal is the visible part. The real change is in how the team thinks about its own role.</p><p>Here is how Daniel described the shift, side by side:</p><p>Before the portal: A developer asks for an environment. A ticket is filed. An engineer picks it up when free. The developer waits, sometimes for days.<br> After the portal: A developer picks an approved template. The environment is ready in minutes. The engineer never hears about it.</p><p>Before the portal: Knowledge lives in a few heads. When those people leave or get sick, work stalls.<br> After the portal: Knowledge lives in templates and guides that everyone can read.</p><p>Before the portal: Senior engineers spend their week on repeat requests.<br> After the portal: Senior engineers spend their week on reliability, cost, and security.</p><p>Daniel also had complaints, and I want to be honest about them. The portal did not cover every case. Two of his tasks still needed the command line. He found a confusing menu. He wanted better search. I wrote all of it down. A portal is a product, and products need an owner who listens.</p><h3>What This Means For Your Organization</h3><p>You do not need a Daniel to see this pattern. You probably have one already. Look for the person who is always busy, always praised, and always the answer to the question “who knows how this works?”</p><p>That person is a gift and a risk at the same time. If your best people spend their days answering requests, your company is paying top salaries for ticket handling.</p><p>An internal developer portal moves that work to where it belongs. Developers get speed. Leaders get fewer single points of failure. Engineers get their time back.</p><p>Here is a short checklist you can use this week:</p><p>[ ] Count the requests: Ask your engineering lead how many requests come in for environments, access, and deployments each week.<br> [ ] Name the people: Write down who answers most of them. Ask how they feel about it.<br> [ ] Find the repeats: Pick the five requests that show up again and again.<br> [ ] Start small: Build or buy a simple portal that covers only those five.<br> [ ] Run your own bet: Ask one skeptical engineer to try it for a week and report back honestly.</p><p>That last step matters most. Daniel did not change his mind because I told him to. He changed it because he tried it himself.</p><h3>Where Consulting Fits In</h3><p>Many leadership teams stall at this point. They agree with the idea, but they do not know where to begin. Which tool should we pick? Who should own it? How do we avoid building something nobody uses?</p><p>This is where an outside consulting partner earns their fee. A good consulting team has seen several versions of this rollout. They know which first steps work and which ones create a nine month project with no users. They can also say the uncomfortable things an internal team cannot, such as telling a senior engineer that the old way has a cost.</p><p>We brought in outside help for the second phase of our rollout. They did not tell us anything we could not have learned. They told us sooner, and they kept us from building features nobody asked for.</p><h3>How Our Story Ended</h3><p>Daniel runs our platform team today. He no longer answers most requests. He writes the templates, reviews the guides, and spends his time on the problems that actually need his skill. He still uses kubectl when he needs it. He just does not need it to prove his worth anymore.</p><p>I keep the handwritten note he left on my desk that Friday. It says, “Bet lost. Good.”</p><h3>Final Takeaway</h3><p>If your best engineer is also your biggest bottleneck, the fault is not theirs. It is a design problem, and design problems can be fixed.</p><p>An internal developer portal will not fix your culture on its own. It gives your people a way to work without waiting. What they do with that time is the real payoff.</p><p>Try one week. Pick one skeptic. Listen to what they say on Friday.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7426dd9c0d76" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I Defend The Monolith Pod In Every Kubernetes Architecture Review Now]]></title>
            <link>https://medium.com/@f8010/why-i-defend-the-monolith-pod-in-every-kubernetes-architecture-review-now-87c4b4956a09?source=rss-e5239857b252------2</link>
            <guid isPermaLink="false">https://medium.com/p/87c4b4956a09</guid>
            <dc:creator><![CDATA[F8010]]></dc:creator>
            <pubDate>Mon, 19 Oct 2026 12:34:18 GMT</pubDate>
            <atom:updated>2026-10-19T12:34:18.080Z</atom:updated>
            <content:encoded><![CDATA[<p>Three years ago, a client pulled me into a war room because their platform team wanted to split a single service into fourteen microservices before the product had even found its first thousand paying customers. The CTO looked exhausted.</p><p>His engineers were excited. I was the only person in the room asking why.</p><p>That meeting changed how I run every architecture review since.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*AijmSpdi0jTHd4dU" /><figcaption>Photo by <a href="https://unsplash.com/@zoltantasi?utm_source=medium&amp;utm_medium=referral">Zoltan Tasi</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Pitch That Started It</h3><p>The engineering team had a slide deck. Clean boxes, clean arrows, a service mesh diagram that looked like a subway map of Tokyo. Their argument was simple: microservices scale, monoliths don’t, and any serious company running on Kubernetes should be decomposing early.</p><p>I asked one question. How many engineers do you have on this product?</p><p>Six.</p><p>Six engineers were about to own fourteen deployments, fourteen sets of logs, fourteen points of failure, and a service mesh that none of them had operated in production before. The CTO signed off anyway, because the room full of smart people agreed it was the right call.</p><p>Eight months later, that company spent more time debugging network calls between services than building features customers asked for. I came back in to help them merge half those services back into a single deployable pod. We called it a rollback. It was really a correction.</p><h3>What I Actually Defend</h3><p>I do not defend monoliths out of nostalgia. I defend a specific decision: keeping related functionality inside one pod, one deployment unit, until the organization has a real reason to split it. This is the core of every architecture review I run now, and it deserves more than a passing mention.</p><p>Here is the test I use with every client before Kubernetes architecture decisions get locked in:</p><ul><li><strong>Team size versus service count: </strong>If you have fewer engineers than services, you are not practicing microservices. You are practicing distributed debugging.</li><li><strong>Deployment frequency: </strong>If different parts of your application change together, on the same release cycle, splitting them adds coordination overhead without adding independence.</li><li><strong>Failure isolation needs: </strong>Ask what actually breaks the business if it goes down. If the answer is everything, splitting one component into five does not protect you. It just multiplies the ways things can fail.</li><li><strong>Operational maturity: </strong>Running fourteen services well requires fourteen times the observability, fourteen times the alerting discipline, and a platform team that can support it. Most organizations do not have that team yet.</li><li><strong>Clear service boundaries:</strong> Microservices work when the boundaries map to real business domains, not when they map to an org chart someone drew during a planning offsite.</li></ul><p>A pull quote from that same CTO, eight months after the rollback, still sits in my notes:</p><p>“We didn’t need more services. We needed fewer places where things could go wrong.”</p><p>That sentence is the whole argument.</p><h3>Math Nobody Puts On The Slide</h3><p>Every extra service in a Kubernetes cluster adds real, recurring cost that rarely makes it into the planning conversation:</p><ol><li>Another deployment pipeline to maintain and secure</li><li>Another set of resource requests and limits to tune</li><li>Another service-to-service authentication boundary</li><li>Another place for a dependency to go stale</li><li>Another on-call surface for an already stretched team</li></ol><p>None of these costs are visible in a demo. All of them show up in an incident at 2am, which is usually when I get the call.</p><p>A consulting engagement I ran last year made this concrete. The client had split a straightforward order-processing workflow into six services because a previous team believed that was the “cloud native” way to build on Kubernetes. The business logic hadn’t changed in two years. The only thing that had changed was the number of ways a simple order could get stuck between services, with nobody fully owning the failure. We consolidated four of those six services back into a single pod with clear internal modules. Deployment time dropped. On-call tickets dropped faster.</p><h3>When Splitting Actually Makes Sense</h3><p>I am not against microservices. I am against splitting before you have earned the complexity. Here is when I tell clients to go ahead and split a service out of the monolith pod:</p><p>One part of the system has wildly different scaling needs than the rest, such as an image processing job that spikes hard while the rest of the application stays flat.</p><ul><li>A specific team owns a specific domain and needs to deploy on their own schedule, without waiting on a different team’s release.</li><li>A component has different security or compliance requirements that justify its own isolation boundary.</li></ul><p>The monolith pod has grown large enough that build times and test suites are slowing every engineer down, regardless of what they’re working on.</p><p>If none of those are true yet, the split is premature, and premature splits are the single most common Kubernetes architecture mistake I see in client reviews.</p><h3>Short Checklist For Your Next Architecture Review</h3><p>Before you approve another service split, ask your team these questions directly:</p><ul><li>Who owns this new service after it ships.</li><li>What happens to deployment speed once this service exists.</li><li>How many new alerts and dashboards does this require.</li><li>Does the team size support the operational load this adds.</li><li>Is this split solving a real scaling problem or a hypothetical one.</li></ul><p>If your team can’t answer these clearly in the room, that’s your answer. Wait.</p><h3>Part CXOs Actually Care About</h3><p>Executives don’t lose sleep over pod architecture diagrams. They lose sleep over missed deadlines, unexplained outages, and platform teams that seem permanently behind.</p><p>Every time I defend the monolith pod in a review, I am really defending the business outcome underneath it: fewer surprises, faster recovery, and engineers spending their time on product instead of plumbing between services that didn’t need to be separate in the first place.</p><p>The companies I’ve watched succeed with Kubernetes long term are not the ones with the most services. They’re the ones that split only when the business demanded it, and kept things together when it didn’t.</p><p>So here’s the question I leave with every leadership team I work with now. Before your next architecture review, look at your service count and your team size side by side.</p><p>Which one is actually driving the other?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=87c4b4956a09" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Real Reason Teams Bypass Your Kubernetes Policies]]></title>
            <link>https://medium.com/@f8010/the-real-reason-teams-bypass-your-kubernetes-policies-308922713976?source=rss-e5239857b252------2</link>
            <guid isPermaLink="false">https://medium.com/p/308922713976</guid>
            <dc:creator><![CDATA[F8010]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 04:36:03 GMT</pubDate>
            <atom:updated>2026-10-15T04:36:03.166Z</atom:updated>
            <content:encoded><![CDATA[<p>Three weeks ago, I sat across from a VP of Engineering at a mid-size fintech company. He pulled up a dashboard that should have made him proud. Every namespace had resource limits. Every deployment required approval. Every policy his security team had spent a year writing was technically enforced.</p><p>Then he scrolled down and showed me the exceptions list. Two hundred and forty entries. Half his platform was running on waivers.</p><p>“We built all this,” he said, “and people still find a way around it.”</p><p>He wasn’t angry at his team. He was confused. The policies were sound. The tooling worked. So why did his best engineers keep quietly routing around the rules he’d put in place to protect them?</p><p>The answer has nothing to do with rule breaking. It has everything to do with what happens when a policy makes someone’s job harder without making the system safer in a way they can feel.</p><h3>Why Smart Engineers Break Rules On Purpose</h3><p>Here is the part most leadership teams miss. The engineers bypassing your policies are usually your most capable ones. They know the rules exist. They know what the audit will say if they get caught. They do it anyway because the cost of following the process is higher than the cost of the risk they are taking on.</p><p>Picture a developer who needs to ship a fix before a client demo in four hours. The approved path requires:</p><ul><li>A ticket filed with the platform team</li><li>A review that typically takes two business days</li><li>A security scan that occasionally flags false positives requiring manual override</li><li>A deployment window that only opens twice a week</li></ul><p>None of those steps are unreasonable on their own. Together, they add up to a four day process for a problem that needs to be solved in four hours. So the engineer finds someone with standing access, borrows a shortcut, or quietly tags the workload as “temporary” and moves on.</p><p>This is not a discipline problem. It is a design problem. When I worked with a logistics company on their platform rollout, we found that the teams with the fewest policy violations were not the ones with the strictest enforcement. They were the ones where the fast path and the compliant path were the same path.</p><h4>That distinction is the entire argument of this article, so it is worth sitting with.</h4><p>A policy only works if following it is the easiest available option. If it is not the easiest option, people will find the next easiest one, and that one is rarely the safe one.</p><p>Think about how this plays out in practice. Your policy says every container image must come from an approved registry. Reasonable. But if pulling from that registry takes three extra steps and a manual request, someone under deadline pressure will pull from Docker Hub instead, just this once. Your policy says every service needs a service mesh sidecar for traffic encryption. Also reasonable. But if adding that sidecar breaks a legacy app’s health checks and nobody has time to debug it, the team will disable the mesh for that one service. You find out six months later during an audit.</p><h3>The Pattern Behind Every Bypass</h3><h4>What We Assume vs What Actually Happens</h4><p>We assume: Engineers skip policy because they don’t understand the risk.<br> What actually happens: Most engineers understand the risk better than the people who wrote the policy. They just have a deadline that doesn’t care about the risk.</p><p><strong>We assume: More enforcement will close the gap.<br></strong> What actually happens: Stricter enforcement without an easier compliant path just pushes the bypass further underground, where it is harder to detect.</p><p><strong>We assume: Exceptions are a sign of weak governance.<br></strong> What actually happens: A healthy exceptions process is often a sign that the organization is honest about where the policy and the workflow don’t fit yet.</p><p>That last point matters more than it sounds. A platform with zero recorded exceptions is not necessarily a well governed platform. Sometimes it means nobody is reporting the workarounds anymore.</p><h3>What Actually Fixes This</h3><p>The fix is not writing better policy documents. It is removing the gap between what is compliant and what is convenient. Three things tend to close that gap faster than anything else.</p><p>Build the guardrail into the platform, not the process. If a policy lives in a wiki page that someone has to remember to check, it will get skipped. If it lives in the deployment pipeline itself, where the compliant path is automatically the default path, people stop thinking about it. They just build.</p><p>Measure how long compliance takes, not just whether it happened. Most governance dashboards show a pass or fail. They rarely show that the “pass” took four days when the business needed four hours. Start tracking time to compliant deployment the same way you track time to deploy. If that number is embarrassing, you have found your real problem.</p><p>Give teams a fast, visible, honest exception path. Waivers are not a failure of governance. A waiver that requires someone to explain the business reason, gets logged, and gets reviewed later is far safer than a silent workaround nobody knows about. The goal is not zero exceptions. The goal is zero hidden ones.</p><h3>A Short Checklist Before Your Next Policy Review</h3><p>Before you tighten another control, walk through this with your platform and security leads together, not separately.</p><p>Can a developer comply with this policy in under the time their task normally takes.<br> Does the compliant path require fewer steps than the workaround, not more.<br> Is there a visible, fast way to request an exception instead of forcing a silent one.<br> Do you know how many exceptions exist right now, and why each one was granted.<br> Has anyone on the platform team actually tried following their own process under a real deadline.</p><p>If you cannot answer the last one with confidence, that is usually where the real answer is hiding.</p><p>The fintech VP I mentioned earlier ran that exercise with his own team. It took three weeks to redesign the deployment pipeline so the secure path and the fast path became the same thing. His exceptions list dropped from two hundred and forty to under twenty, not because anyone got stricter, but because following the rules stopped being the slower option.</p><p>That is usually what separates policies that hold from the ones that quietly collapse under their own weight. The rule was never the problem. The gap between the rule and the real workday was.</p><p>So before you write the next policy for your platform, ask the harder question first. If your best engineer were under deadline pressure tomorrow, would they follow this rule, or would they find a way around it?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=308922713976" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>