<?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 Mohamed Salman on Medium]]></title>
        <description><![CDATA[Stories by Mohamed Salman on Medium]]></description>
        <link>https://medium.com/@mohamedsalmanpersonal?source=rss-bfcdb62e5a0c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*j-KjfJjyhaB1RAN0</url>
            <title>Stories by Mohamed Salman on Medium</title>
            <link>https://medium.com/@mohamedsalmanpersonal?source=rss-bfcdb62e5a0c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 09:11:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mohamedsalmanpersonal/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[What Actually Happens When You Push Code: GitHub Actions Under the Hood]]></title>
            <link>https://medium.com/@mohamedsalmanpersonal/what-actually-happens-when-you-push-code-github-actions-under-the-hood-f0ce5d3d14ba?source=rss-bfcdb62e5a0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/f0ce5d3d14ba</guid>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[continous-deployment]]></category>
            <category><![CDATA[continous-delivery]]></category>
            <category><![CDATA[continous-integration]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <dc:creator><![CDATA[Mohamed Salman]]></dc:creator>
            <pubDate>Thu, 27 Aug 2026 14:22:32 GMT</pubDate>
            <atom:updated>2026-08-27T14:22:32.038Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G6goDfR8XSuEVeaQT6KCuA.jpeg" /></figure><p>You’ve written the YAML a hundred times. on: push, jobs:, a green checkmark that means you&#39;re safe to merge and go get coffee. But have you ever actually sat there, in the fifteen seconds between git push and that little yellow dot turning into a spinning circle, and wondered what&#39;s <em>actually</em> happening?</p><p>I have. More than I’d like to admit, usually while a job was stuck and I had no idea why. So I went down the rabbit hole, and it turns out the answer is way more satisfying than “cloud magic.” There’s an actual, explainable machine under there.</p><p>No YAML today. Just the machinery underneath it — and I promise to make it less dry than the GitHub docs.</p><h3>Think of GitHub as a restaurant with an automated kitchen</h3><p>Picture GitHub as a restaurant. You (the developer) are a customer placing an order — except instead of ordering food, you’re placing code changes. Every time you push a commit or open a pull request, that’s you ringing the little bell at the counter and saying “order up.”</p><p>There are three parts to this restaurant that matter:</p><ul><li><strong>The host stand (GitHub’s control plane)</strong> — watches for bells ringing, checks the order against the menu, and decides which kitchen stations need to fire.</li><li><strong>The kitchen stations (runners)</strong> — the actual stoves and prep counters where the cooking happens.</li><li><strong>The line cooks (the Runner agent)</strong> — the software standing at each station that reads the ticket and does the actual work.</li></ul><p>Nobody drags you into the kitchen to cook your own order. You ring the bell, and a system you never see takes it from there — which, frankly, is the only reason any of us trust CI/CD with our Friday afternoon deploys.</p><h3>Step 1: The bell rings — how a push becomes a “workflow run”</h3><p>The moment you push a commit, GitHub’s internal event system generates an event — “hey, a push just landed on this branch.” A background service then does something like flip through every workflow YAML file sitting in .github/workflows/ on your repo, checking each one&#39;s on: section like a maître d&#39; checking reservation slips: <em>does this ticket match anything on the menu?</em></p><p>Every workflow file whose trigger matches gets its own <strong>workflow run</strong> — think of this as a single order ticket, printed and clipped to the rail. If your workflow has three jobs, that’s three tickets going to three different stations, and GitHub keeps track of which ticket depends on which (that’s your needs: graph) before sending anything to the kitchen at all.</p><p>Nothing has actually <em>cooked</em> yet. This is all paperwork — matching, queuing, dependency resolution. The actual work hasn’t started. It’s the CI/CD equivalent of a restaurant hostess saying “someone will be with you shortly,” except here, someone actually shows up.</p><h3>Step 2: The ticket reaches the kitchen — how a job starts executing</h3><p>Here’s where it gets interesting, because GitHub doesn’t keep a kitchen running 24/7 just for you (as much as it might feel that way when you’re the one paying for minutes). For GitHub-hosted runners, there’s a <em>massive shared pool</em> of identical, sealed prep stations sitting idle — freshly-booted virtual machines, basically. When your job’s ticket is ready, GitHub grabs a clean one matching your runs-on: label, say ubuntu-latest, and hands it a copy of the ticket.</p><p>On that machine sits a piece of software called the <strong>Runner agent</strong>. This isn’t magic — it’s real, open-source code (github/actions/runner, written in C#/.NET), and honestly it behaves a lot like that one overeager cook who keeps wandering past the ticket rail going &quot;anything for me? anything for me?&quot; That&#39;s called <strong>long-polling</strong>: the agent reaches <em>out</em> to GitHub repeatedly asking for work, rather than GitHub reaching <em>in</em> to the machine. This detail matters a lot if you run self-hosted runners — your own servers never need an open inbound port, they just keep pestering GitHub for work like the eager cook they are.</p><p>Once the agent picks up a job, it:</p><ol><li><strong>Reads the ticket</strong> — pulls down exactly which steps to run, in what order, with what secrets.</li><li><strong>Preps the counter</strong> — sets up a clean workspace, checks out your code.</li><li><strong>Cooks each step</strong> — for run: steps, it just opens a shell and executes your command. For uses: steps (pre-built actions), it fetches that action&#39;s code or container image first, then runs it.</li><li><strong>Calls out orders as it goes</strong> — logs stream back to GitHub live, which is why you can watch a job’s output update in real time instead of waiting for it to finish.</li></ol><p>Self-hosted runners work identically — you’re just running the same line-cook software on your own hardware, registered to your own kitchen. GitHub still only ever <em>asks</em>, never <em>pushes in</em>.</p><p>And once the job’s done, if it was a GitHub-hosted runner, that entire VM gets thrown away — every single job starts on a completely fresh, disposable machine. No leftover state, no contamination between orders. It’s less “kitchen” and more “kitchen made entirely of paper plates” — used once, then straight in the bin. That’s a deliberate security decision, not a limitation (and also, I assume, the one part of this whole system your ops team is not thrilled to hear described as “disposable”).</p><h3>Step 3: When one kitchen borrows another kitchen’s recipe — reusable workflows</h3><p>Now for the part that trips people up: <strong>reusable workflows</strong> (workflow_call), especially when they live in a <em>different repo</em> than the one calling them.</p><p>Keep the restaurant metaphor going. Imagine your repo’s workflow needs to do something a sibling repo already knows how to do well — say, “build and scan a Docker image.” Instead of rewriting that recipe from scratch, you call over to the other kitchen and say “just run your standard build-and-scan recipe, but use <em>my</em> ingredients.”</p><pre>jobs:<br>  build:<br>    uses: org/other-repo/.github/workflows/build.yml@main<br>    with:<br>      environment: prod<br>    secrets: inherit</pre><p>Here’s the part that surprises people: this isn’t treated as a <em>second, separate</em> order. GitHub doesn’t spin up a brand-new workflow run in the other repo and hope it comes back with results. Instead, at the moment your workflow hits that uses: line, GitHub reaches into org/other-repo, fetches the exact recipe at the @main ref you pointed to, checks that it&#39;s actually marked reusable (on: workflow_call), and <strong>stitches its jobs directly into your original order ticket</strong>. If you open the run in GitHub&#39;s UI, you&#39;ll see the borrowed jobs nested right there alongside your own — same run, same ID, just extra stations pulled in.</p><p>A few things worth knowing about this borrowing process:</p><ul><li><strong>Ingredients don’t cross kitchens automatically.</strong> Your secrets and permissions don’t just flow into the other repo’s workflow by default — that’s exactly why secrets: inherit exists as an explicit opt-in. Without it, the called workflow gets nothing.</li><li><strong>The borrowed recipe runs under its own kitchen’s rules.</strong> The reusable workflow gets its own GITHUB_TOKEN, scoped to <em>its own</em> repository, not yours — unless it&#39;s a same-repo call, in which case there&#39;s nothing to separate.</li><li><strong>You need permission to walk into someone else’s kitchen.</strong> If the repo holding the reusable workflow is private, your repo needs explicit access — either same organization, or an allowlist the other repo’s owner sets up. GitHub checks this <em>before</em> anything runs, not partway through.</li><li><strong>There’s a limit on how many kitchens you can chain.</strong> Reusable workflows can call other reusable workflows, but only up to four levels deep — otherwise you could accidentally build an infinite hall of mirrors.</li></ul><p>It’s worth contrasting this with something that <em>looks</em> similar but isn’t: triggering a workflow in another repo via repository_dispatch or a token-triggered workflow_dispatch. That&#39;s not borrowing a recipe mid-order — that&#39;s placing a completely separate order at a different restaurant. Different run, different ticket, no shared context, and you&#39;d need to explicitly pass any information across via the API call itself.</p><h3>Tying it together</h3><p>So next time you push a commit and watch that little dot spin, here’s what’s actually going on:</p><ul><li><strong>The push rings a bell</strong> that GitHub’s control plane hears, and it prints out a ticket for every workflow that matches.</li><li><strong>A runner is a disposable kitchen station</strong>, staffed by an open-source agent that <em>asks</em> GitHub for work rather than waiting to be handed it — which is exactly what lets self-hosted runners sit safely behind a firewall.</li><li><strong>A reusable workflow isn’t a phone call to another restaurant.</strong> It’s GitHub literally pulling in another kitchen’s recipe and folding it into your existing order, ingredients included only if you explicitly hand them over.</li></ul><p>None of this changes how you write your YAML tomorrow morning. But it does mean the next time a job hangs, a secret goes missing, or a permissions error shows up out of nowhere, you’re not just staring at a black box wondering if the CI gods are angry with you. You’re picturing an actual kitchen, with actual staff, following an actual process — one that, it turns out, makes a lot of sense once you know it’s there.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0ce5d3d14ba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What DevOps Really Is (Explained Without the Jargon)]]></title>
            <link>https://medium.com/@mohamedsalmanpersonal/what-devops-really-is-explained-without-the-jargon-dce28dff4b8d?source=rss-bfcdb62e5a0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/dce28dff4b8d</guid>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[devops-tool]]></category>
            <category><![CDATA[azure-devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Mohamed Salman]]></dc:creator>
            <pubDate>Sun, 23 Aug 2026 14:38:56 GMT</pubDate>
            <atom:updated>2026-08-23T14:38:56.133Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iiQY_zXooZ-o5n8Au1kcwQ.png" /></figure><p>If you’ve ever asked someone “what is DevOps?” and gotten an answer full of words like “CI/CD,” “infrastructure as code,” and “shift left,” you probably walked away more confused than when you started.</p><p>Here’s the thing: DevOps isn’t a tool. It isn’t a job title, even though companies hand out that title all the time. It’s a way of working — and once you strip away the acronyms, it’s actually a pretty simple idea.</p><p>Let’s use some everyday examples to make it click.</p><p><strong>The Restaurant That Couldn’t Talk to Itself</strong></p><p>Imagine a restaurant where the chefs and the waiters never spoke to each other.</p><p>The chefs work in a sealed kitchen. They cook whatever they feel like, whenever they feel like it, then shove finished plates through a small hole in the wall and walk away. They have no idea if the customer ordered a steak or a salad. They just cook and push.</p><p>The waiters, meanwhile, are stuck out front. They take orders from customers, but they have no way of telling the kitchen what’s actually been ordered. They just wait by the hole in the wall, hoping something useful comes through. When the wrong dish shows up, they shrug and serve it anyway — or send it back with an angry note, and wait for the next confusing plate.</p><p>This restaurant is a mess. Customers get wrong orders. Food gets cold. Nobody knows who’s responsible when things go wrong. The chefs blame the waiters for bad communication; the waiters blame the chefs for not listening.</p><p>This is what software used to look like. The people who built software (developers) and the people who ran and maintained software once it was live (operations) worked in completely separate rooms, with a metaphorical hole in the wall between them. Developers wrote code and “threw it over the wall.” Operations caught whatever landed and had to make it work, often with no idea what the code was even supposed to do.</p><p>DevOps is what happens when you knock that wall down. The chefs and waiters start working in the same space, talking constantly, seeing the same orders, and taking joint responsibility for the customer actually getting a good meal.</p><p><strong>It’s a Culture First, a Toolset Second</strong></p><p>A lot of people think DevOps means “using certain tools”, things like Docker, Jenkins, Kubernetes, or GitHub Actions. Those tools help, the same way a good ticket printer helps a restaurant kitchen. But buying a ticket printer doesn’t fix a restaurant where the chefs and waiters despise each other and never talk.</p><p><strong>DevOps at its core is a set of habits and values:</strong></p><p>- Shared responsibility. Everyone owns the outcome, not just their slice of the process.</p><p>- Small, frequent changes instead of huge, rare, risky ones.</p><p>- Fast feedback loops, so problems are caught in minutes, not months.</p><p>- Automation of repetitive, error prone tasks, so humans focus on judgment calls.</p><p>The tools exist to support those habits, not replace them.</p><p><strong>The Assembly Line Analogy</strong></p><p>Think about how a car used to be built versus how it’s built today.</p><p>Old way: one team designs the car, finishes their part completely, and hands blueprints to a totally separate manufacturing team months later. If the manufacturing team finds a design flaw, it takes forever to get that fixed, because the design team has already moved on to the next car and stopped paying attention.</p><p>Modern way: designers, engineers, and the assembly line work in tight feedback loops. A flaw discovered on the line gets reported back to design almost immediately. Small adjustments happen constantly instead of in one giant, risky handoff.</p><p>Software teams doing DevOps work the same way. Instead of writing code for six months and then “throwing it over the wall” to be deployed, they ship small updates constantly — sometimes multiple times a day — and get real feedback from real usage almost instantly.</p><p><strong>Why “Automate the Boring Stuff” Matters</strong></p><p>Picture a small bakery where, every single morning, someone has to manually count all the ingredients, weigh out the flour, check the oven temperature by hand, and write down the results on paper before baking can even start.</p><p>It works, but it’s slow, and humans get tired and make mistakes — especially at 2 in the mid night.</p><p>Now imagine the bakery installs a smart system where ingredients are pre measured automatically, the oven pre heats itself and checks its own temperature, and everything gets logged without anyone lifting a pen.</p><p>The bakers aren’t replaced. They’re freed up to focus on the things that actually require a human — tasting, adjusting recipes, handling the unexpected. The boring, repetitive, error prone stuff runs itself.</p><p>This is exactly why DevOps teams love automation. Testing code, deploying updates, checking system health — these are the “measuring flour” tasks of software. Automating them doesn’t just save time, it removes the human error that creeps in when people do the same tedious task 200 times.</p><p><strong>Who “Owns” a Problem When Something Breaks?</strong></p><p>In the old, walled off world, when a website went down at 2 in the mid night., there was often a very unhelpful conversation:</p><p>&gt; “It’s a code problem, that’s Dev’s fault.”</p><p>&gt; “No, it’s a server problem, that’s Ops’ fault.”</p><p>Meanwhile, customers are staring at an error page.</p><p>In a DevOps culture, that conversation doesn’t happen, because there’s no wall to hide behind. The same people (or tightly connected teams) who built the feature are also responsible for watching it run in the real world. If it breaks, they fix it — because they understand both the code and the environment it runs in.</p><p>It’s the difference between a chef who never has to taste their own cooking, versus a chef who eats at their own restaurant every night and hears directly from unhappy customers.</p><p><strong>So, What Is DevOps, Really?</strong></p><p>Strip away the buzzwords, and DevOps is simply this:</p><p>Break down the wall between building something and running something, so the same people care about both — and use small steps, fast feedback, and automation to make that possible.</p><p>It’s less a technology and more a philosophy — closer to “how a well run kitchen operates” than “which software you install.” The tools make it easier, but the mindset is what actually makes it work.</p><p>Next time someone throws the word “DevOps” at you like it’s some mystical engineering discipline, you can just think: restaurant with no wall between the kitchen and the dining room. That’s really it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dce28dff4b8d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>