<?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 Vishal Gore on Medium]]></title>
        <description><![CDATA[Stories by Vishal Gore on Medium]]></description>
        <link>https://medium.com/@vgore3965?source=rss-26ce92357f07------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*nKAnpkPWYlnGvM9YuDnDyQ.webp</url>
            <title>Stories by Vishal Gore on Medium</title>
            <link>https://medium.com/@vgore3965?source=rss-26ce92357f07------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 02:14:44 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@vgore3965/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[Kubernetes Architecture Explained (Master, Node, Pods)]]></title>
            <link>https://medium.com/@vgore3965/kubernetes-architecture-explained-master-node-pods-0292540ded85?source=rss-26ce92357f07------2</link>
            <guid isPermaLink="false">https://medium.com/p/0292540ded85</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[masternodes]]></category>
            <category><![CDATA[kubernetes-architecture]]></category>
            <dc:creator><![CDATA[Vishal Gore]]></dc:creator>
            <pubDate>Thu, 30 Apr 2026 17:36:57 GMT</pubDate>
            <atom:updated>2026-04-30T17:36:57.158Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*hLTXJ52j2jKVefEdEhW4mw.jpeg" /></figure><p>I still remember the day I first tried to understand Kubernetes architecture. It sounded fancy, but honestly, I had no clue what was going on. I was running containers locally, everything seemed fine, and then suddenly everyone kept talking about clusters, nodes, and pods. I remember feeling stuck, like I was missing something obvious. At one point I almost gave up, thinking maybe this whole thing was just too complex for me.</p><p>But I decided to slow down and break it into pieces. Instead of trying to understand everything at once, I focused on one idea at a time. That is when I first understood the role of the master. I started thinking of it like a manager in an office. It does not do all the work, but it decides what needs to be done and who should do it. The master controls everything, keeps track of the system, and makes sure things are running as expected. That simple analogy made things click for me.</p><p>Then came the nodes. At first, I thought they were just machines, and technically that is true, but understanding their role helped me more. I imagined them as workers following instructions from the master. They run the actual applications and handle the real work. Without nodes, nothing really happens. That realization made the architecture feel less abstract and more practical.</p><p>Finally, I reached pods, and honestly, this part confused me the most. Why not just run containers directly? That question kept bothering me. After reading, experimenting, and breaking things a few times, I realized that pods are like small wrappers around containers. They group them together and give them a shared space to run. It felt like Kubernetes was saying, do not think about individual containers, think about how they work together. That shift in thinking changed everything for me.</p><p>Slowly, the pieces started connecting. Master gives instructions, nodes execute them, and pods carry the actual applications. It no longer felt like a mess of new terms. It felt like a system with purpose.</p><p>Looking back, I realize I was overcomplicating things in the beginning. I was trying to memorize instead of understand. Once I started relating concepts to simple real life ideas, everything became easier. I still do not know everything, and sometimes I still get confused, but now I am not afraid of it. The biggest lesson I learned is that complex systems are just simple ideas connected together. And sometimes, all it takes is patience and a bit of curiosity to finally see the bigger picture. I remember the moment it finally made sense, I was just staring at my screen and smiling for no reason. It was not perfect, but it was enough. Since then, every time I deploy something, I quietly appreciate how these pieces work together. It feels less scary now, more like something I can actually handle. And if I could tell my past self one thing, it would be, keep going, it will make sense soon.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0292540ded85" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is Docker and why developers love it]]></title>
            <link>https://medium.com/@vgore3965/what-is-docker-and-why-developers-love-it-05091604a317?source=rss-26ce92357f07------2</link>
            <guid isPermaLink="false">https://medium.com/p/05091604a317</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Vishal Gore]]></dc:creator>
            <pubDate>Tue, 28 Apr 2026 13:32:18 GMT</pubDate>
            <atom:updated>2026-04-28T13:32:18.579Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*BtbM7KMYlim3KxCYvbKJwA.jpeg" /></figure><p>I still remember the day my simple project refused to run on my friend’s laptop. It worked perfectly on my machine, so I assumed everything was fine. But the moment we tried to run it there, errors started popping up. Missing dependencies, version conflicts, things I had never even noticed. I remember feeling stuck, wondering why something so basic had become such a headache.</p><p>At first, I tried fixing it the usual way. I installed libraries manually, checked versions, copied files, and even rewrote small parts of the code. It worked for a while, then broke again. Different systems, different problems. It felt endless. At one point I almost gave up and thought, maybe this is just how development is supposed to be.</p><p>Then someone mentioned Docker to me. Honestly, I didn’t get it at first. The idea sounded complicated, like another tool I would struggle to learn. But I decided to give it a try, mostly out of frustration.</p><p>What surprised me was how simple the core idea was. Instead of relying on my system, I could package my application with everything it needed into a small container. It was like creating a tiny, self-contained environment that could run anywhere. Same setup, same behavior, no surprises.</p><p>I remember the first time I ran my app using Docker on another machine. I was honestly expecting it to fail again. But it worked. No missing packages, no weird errors. That moment felt strangely satisfying, like finally solving a puzzle that had been bothering me for days.</p><p>After that, I started using Docker more regularly. I noticed how much time it saved me. Setting up new projects became faster. Sharing code with others became easier. I didn’t have to explain long setup steps anymore. Everything was already inside the container.</p><p>That’s when I understood why developers love Docker. It removes the small, annoying problems that slow us down. It gives consistency, which is something I didn’t realize I needed until I had it.</p><p>Of course, it wasn’t perfect from the start. I made mistakes, wrote messy configurations, and sometimes broke things again. But even then, fixing issues felt more predictable.</p><p>Looking back, Docker didn’t just solve my problem, it changed how I think about development. Now I focus less on environment issues and more on building things that actually matter.</p><p>If I had to describe it simply, Docker gave me peace of mind. And honestly, that’s something every developer is quietly looking for.</p><p>I still run into problems sometimes, but they feel manageable now. I no longer fear setting up a new project or sharing it with someone else. That old confusion is mostly gone, replaced with a bit of confidence. It’s funny how one tool can change your entire workflow without you even realizing it at first. I guess that’s why I keep recommending it to others, especially beginners who feel stuck like I once did. It makes things easier, and sometimes that’s exactly what we need to keep going.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=05091604a317" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How CI/CD Works in Azure DevOps (step-by-step)]]></title>
            <link>https://medium.com/@vgore3965/how-ci-cd-works-in-azure-devops-step-by-step-4ff5dfa46275?source=rss-26ce92357f07------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ff5dfa46275</guid>
            <category><![CDATA[cicd-pipeline]]></category>
            <category><![CDATA[azure-devops-pipeline]]></category>
            <category><![CDATA[azure]]></category>
            <dc:creator><![CDATA[Vishal Gore]]></dc:creator>
            <pubDate>Fri, 24 Apr 2026 18:56:58 GMT</pubDate>
            <atom:updated>2026-04-24T18:56:58.141Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*-ggu_DIcZPPidwmUWE1klA.jpeg" /></figure><p>I still remember the first time I heard about CI/CD in Azure DevOps. It sounded fancy, almost intimidating. Everyone around me was talking about automation, pipelines, deployments… and I was just trying to figure out how to even connect my code to something meaningful. I had built a simple React app, but getting it live felt like a completely different challenge.</p><p>At first, I thought I could just manually upload files to a server and be done with it. And honestly, I did try that. It worked… once. Then I made a small change, forgot a file, broke something, and spent hours debugging. That’s when I realized I needed something more reliable. That’s when CI/CD started making sense.</p><p>I began with Azure DevOps, mostly because I had already been exploring it. Setting up my first pipeline felt confusing. There were so many options, and I remember staring at the YAML file thinking, “How does this even work?” But I started small.</p><p>The first step I figured out was Continuous Integration. I connected my Git repository to Azure DevOps. Then I created a basic pipeline that would run whenever I pushed code to the main branch. The idea was simple: every time I made a change, the system would automatically build my project.</p><p>I added steps like installing Node.js, running npm install, and then building the app. The first time the pipeline ran successfully, I won’t lie, it felt really good. Like something finally clicked. No manual steps, no guesswork. Just push code, and it builds.</p><p>But that was only half the story.</p><p>Next came Continuous Deployment, which honestly felt a bit scary. Automatically deploying code sounded powerful, but also risky. What if something broke? Still, I wanted to try.</p><p>I had already created a virtual machine using Terraform and configured it using Ansible. Now I needed Azure DevOps to deploy my app there. I added another stage in my pipeline. This stage would take the build files and copy them to my VM using SSH.</p><p>The first few attempts failed. Connection issues, permission errors, missing paths… I hit all of them. At one point, I almost gave up because nothing seemed to work consistently. But slowly, I started fixing things one by one. Opened the right ports, checked SSH keys, verified paths.</p><p>Then one day, it worked.</p><p>I pushed my code, watched the pipeline run through stages — build, then deploy — and within minutes, my app was live on the server. No manual copying, no stress. Just a smooth flow from code to production.</p><p>That’s when CI/CD really made sense to me. It’s not just about automation. It’s about confidence. Knowing that every change you make goes through a process that builds, tests, and deploys it properly.</p><p>Looking back, the journey wasn’t smooth. I was confused, stuck, and sometimes frustrated. But learning CI/CD in Azure DevOps changed how I think about development. Now, I don’t just write code — I think about how it moves, how it reaches users.</p><p>And honestly, that shift made all the difference.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ff5dfa46275" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is Ansible and Why It’s Popular in DevOps]]></title>
            <link>https://medium.com/@vgore3965/what-is-ansible-and-why-its-popular-in-devops-046e5c0a3d33?source=rss-26ce92357f07------2</link>
            <guid isPermaLink="false">https://medium.com/p/046e5c0a3d33</guid>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[ansible-playbook]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[Vishal Gore]]></dc:creator>
            <pubDate>Tue, 31 Mar 2026 17:35:05 GMT</pubDate>
            <atom:updated>2026-03-31T17:35:05.884Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/834/1*xDN_dfeCg-uQIAJuHfmTwg.jpeg" /></figure><p>I still remember the day I had to set up the same web server on three different machines for a small project. It sounded simple at first, but after logging into each system, installing packages, copying files, and fixing small errors again and again, I felt exhausted. I kept thinking, there has to be a better way to do this. That frustration was actually my first step into understanding what Ansible is.</p><p>At that time, I didn’t even know the term “configuration management.” I was just trying to avoid repeating the same boring steps. I tried writing bash scripts, which worked for a while, but they were messy and hard to maintain. One small mistake and everything broke. I remember feeling stuck and honestly a bit annoyed with myself.</p><p>Then someone mentioned Ansible to me during a discussion. I was curious but also skeptical. Another tool? Another thing to learn? Still, I decided to give it a try. The first thing that surprised me was how simple it felt. Instead of writing long scripts, I could describe what I wanted in a clean, readable format. It almost felt like writing instructions for a human.</p><p>That’s when it clicked for me. Ansible is basically a tool that automates tasks like installing software, configuring servers, and deploying applications. But the real beauty is how it does it. You write something called a playbook, which is just a set of steps written in a simple YAML format. Even if you are not a hardcore programmer, you can understand it.</p><p>I started small. I wrote my first playbook to install Nginx on a server. When I ran it and saw everything happen automatically, I felt a weird mix of relief and excitement. No more logging into multiple machines. No more repeating commands manually. It just worked.</p><p>Of course, it wasn’t perfect from the start. I made mistakes. Sometimes my playbooks failed, and I had no idea why. At one point, I almost gave up because debugging felt confusing. But slowly, as I kept experimenting, things started making sense. I learned how Ansible connects to machines using SSH, how it doesn’t need agents, and how it keeps things simple.</p><p>What really made me appreciate Ansible was how much time it saved me. Tasks that used to take hours were now done in minutes. And more importantly, everything became consistent. No more “it works on my machine” problems.</p><p>Now I understand why Ansible is so popular in DevOps. It’s not just about automation. It’s about making life easier, reducing errors, and giving you confidence that your setup will work the same way every time.</p><p>Looking back, that frustrating day with manual setup was actually a turning point for me. It taught me that sometimes the right tool can completely change how you work. And for me, Ansible was exactly that tool. Since then, I try to share what I learn with others, because teaching makes me understand things better, and keeps me growing every single day.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=046e5c0a3d33" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Agentic AI is Different from ChatGPT-style AI]]></title>
            <link>https://medium.com/@vgore3965/how-agentic-ai-is-different-from-chatgpt-style-ai-50958f2e1c7d?source=rss-26ce92357f07------2</link>
            <guid isPermaLink="false">https://medium.com/p/50958f2e1c7d</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[anthropic-claude-code]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Vishal Gore]]></dc:creator>
            <pubDate>Sat, 28 Mar 2026 15:54:08 GMT</pubDate>
            <atom:updated>2026-03-28T15:54:08.271Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*InvUSmBT_CoxYYnG4jWF0w.jpeg" /></figure><p>I still remember one evening when I was sitting in front of my laptop, staring at my screen, completely lost. I had been using ChatGPT for a while, and honestly, it had been helping me a lot. But that day, something felt off. I needed more than just answers, and I could feel that clearly.</p><p>I kept asking better questions, or at least I thought they were better. Long prompts, more context, step by step instructions, I tried everything I could think of. It worked, but only a little. Every time I got an answer, I still had to do the real work myself. And I remember thinking, why does this still feel so slow?</p><p>There was a point where I actually leaned back in my chair and just stared at the ceiling. I felt stuck, like I was missing something obvious. That’s when I randomly came across this idea of Agentic AI. At first, I didn’t really get it. It sounded like one of those buzzwords people throw around.</p><p>But I was curious, so I gave it a shot. My first attempt was honestly messy. I set things up wrong, misunderstood how things should flow, and for a moment I thought I had made things worse. I even remember thinking, why did I start this?</p><p>But then, slowly, something changed. I stopped asking it for answers and started giving it a goal instead. And that’s when it felt different. It wasn’t just replying anymore, it was actually doing things.</p><p>I tried it on a small task, nothing serious. And I just watched. It planned steps, took actions, and kept moving forward without me pushing every second. I remember smiling a little, like okay, this is new.</p><p>With ChatGPT, I always felt like I was driving the whole time. Here, it felt like I had someone in the passenger seat who could take over when needed. It wasn’t perfect, not even close.</p><p>Sometimes it made weird choices, and I had to step in. But even then, I wasn’t starting from scratch. That alone made a huge difference.</p><p>Looking back now, I think that’s the real shift. It’s not just about getting smarter answers. It’s about letting something actually act on what it knows. And for me, that changed everything.</p><p>I still use ChatGPT, and I still find it useful, but I don’t expect it to carry the whole task anymore. Now I think in terms of what can be handled with me, and what can be handled without me constantly watching.</p><p>And honestly, that shift made me feel less tired. I didn’t realize how much mental load I was carrying until it reduced. It feels more like collaboration now.</p><p>And I guess that’s what stayed with me the most. Not just smarter tools, but a different way of working altogether.</p><p>And I’m still figuring it out, still making mistakes, but at least now it feels like I’m not doing everything alone anymore at all these days.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=50958f2e1c7d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Infrastructure as Code (IaC) Explained with Terraform]]></title>
            <link>https://medium.com/@vgore3965/infrastructure-as-code-iac-explained-with-terraform-56bc990607ee?source=rss-26ce92357f07------2</link>
            <guid isPermaLink="false">https://medium.com/p/56bc990607ee</guid>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Vishal Gore]]></dc:creator>
            <pubDate>Thu, 26 Mar 2026 15:53:57 GMT</pubDate>
            <atom:updated>2026-03-26T15:53:57.303Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/627/1*sIHE83KmmbgDlJ6UUITwCQ.jpeg" /></figure><p>A few months ago, I was working late on a small cloud project. Nothing too serious, just something I wanted to try on my own. But I kept running into the same problem. I would set everything up, miss one tiny setting, and the whole thing would stop working. Then I’d go back, fix it, and somehow break something else.</p><p>After doing this a few times, I just sat there thinking, there has to be a better way to handle this.</p><p>That’s when I first heard about Infrastructure as Code. The idea sounded simple, but also a bit confusing. Instead of setting things up manually, you write down your infrastructure in a file and let a tool create it for you. It didn’t fully click at first, but I decided to try anyway.</p><p>I started using Terraform because it seemed beginner-friendly. My first attempt was very basic. I just wanted to create one server. I followed a small example, changed a few values, and ran it.</p><p>To my surprise, it worked on the first try.</p><p>I remember just staring at the screen for a few seconds. No clicking through menus, no guessing, no missed steps. Everything was created exactly the way I had written it.</p><p>A few days later, I needed to set up something similar again. Normally, that would mean repeating the same boring process. This time, I opened my file, changed a couple of lines, and ran it again. Done in minutes.</p><p>That’s when it really started to make sense.</p><p>What I liked most was how everything felt clear. Earlier, my setup existed only in my head or scattered across different screens. Now, it was all written in one place. If something went wrong, I could actually read through it and understand what I had done.</p><p>I even shared my configuration with a friend. Instead of explaining every step, I just sent him the file. He ran it and got the same setup. That moment made me realize how useful this approach really is, especially when working with others.</p><p>Of course, it wasn’t always smooth. There were times when things failed, and I had to figure out why. But even then, it felt different. I wasn’t randomly clicking around anymore. I was just adjusting my file and trying again.</p><p>Over time, this small change started affecting how I work. I stopped jumping straight into creating things and began thinking first. What exactly do I need? How should it be structured?</p><p>Now, whenever I start something new, I open a file before I open any cloud dashboard. It feels more organized, and honestly, less stressful.</p><p>Looking back, those frustrating moments were actually helpful. They pushed me to find a better way. And once I did, there was no going back.</p><p>Even today, whenever something feels repetitive, I pause for a second and ask myself if I can define it instead of doing it manually. Most of the time, the answer is yes.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=56bc990607ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Azure Resource Groups Explained with Example]]></title>
            <link>https://medium.com/@vgore3965/azure-resource-groups-explained-with-example-bc265833a546?source=rss-26ce92357f07------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc265833a546</guid>
            <category><![CDATA[resource-groups]]></category>
            <category><![CDATA[microsoft-azure]]></category>
            <category><![CDATA[azure]]></category>
            <dc:creator><![CDATA[Vishal Gore]]></dc:creator>
            <pubDate>Fri, 06 Mar 2026 22:27:32 GMT</pubDate>
            <atom:updated>2026-03-06T22:27:32.425Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/946/1*Vh3KZZQIo7DLUTE37HHn9A.png" /></figure><p>I remember the first time I opened the Azure portal. It looked like a control room with dozens of buttons and menus. At that moment I kept wondering where everything should go. Virtual machines, databases, networks, storage accounts all sitting in different places. That confusion is exactly why Azure has something called a resource group.</p><p>A resource group is basically a folder for your cloud stuff. Instead of leaving every service scattered around, you place related resources inside one group. When I first understood this idea, things suddenly felt organized. It was like cleaning a messy desk and putting papers into labeled files.</p><p>Let me explain with a simple example. Suppose I am building a small web application. The app needs a virtual machine to run the code, a database to store data, and maybe a storage account for images. Instead of creating them randomly, I create one resource group called something like bookreview-app-rg. Now everything related to that project lives in one place.</p><p>The nice part comes later. If I ever want to remove the whole project, I do not delete each service one by one. I simply delete the resource group and Azure removes everything inside it. The first time I did this I remember thinking that it felt surprisingly satisfying.</p><p>Resource groups also help when you are working on multiple projects. During my practice labs I usually create separate groups like testing-rg, practice-rg, or demo-rg. This keeps experiments away from anything important. If something breaks, I can delete the test group and start fresh without touching other work.</p><p>Another small benefit is access control. Sometimes you want teammates to manage only one project. Instead of giving them access to the entire subscription, you grant permissions just on that resource group. I realized this is very practical, especially in team environments.</p><p>Over time I started seeing resource groups as the starting point of any Azure setup. Before creating anything, I pause for a second and ask myself where this resource should live. That simple habit saves confusion later.</p><p>If you are just beginning with Azure, think of resource groups as project containers. Every app, experiment, or practice lab can have its own space. It keeps things tidy and easier to manage.</p><p>After using Azure for a while, I noticed that most mistakes happen when resources are created without planning. A quick resource group decision prevents that mess.</p><p>One last thing I like about resource groups is visibility. When I open the Azure portal and click a group, I immediately see every service connected to that project. It feels like looking at the whole system from one window. No hunting through menus or guessing where something was created. For beginners this clarity matters a lot. It makes the cloud feel less overwhelming and much more manageable day by day. Once this concept clicks, exploring other Azure services becomes far less confusing and honestly a bit more fun to learn and experiment with in everyday practice as well for beginners.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc265833a546" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding IAM Users, Roles & Policies with Real Examples]]></title>
            <link>https://medium.com/@vgore3965/understanding-iam-users-roles-policies-with-real-examples-68da6eee5c15?source=rss-26ce92357f07------2</link>
            <guid isPermaLink="false">https://medium.com/p/68da6eee5c15</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[aws-policies]]></category>
            <category><![CDATA[aws-iam]]></category>
            <category><![CDATA[aws-role]]></category>
            <dc:creator><![CDATA[Vishal Gore]]></dc:creator>
            <pubDate>Fri, 27 Feb 2026 20:03:29 GMT</pubDate>
            <atom:updated>2026-02-27T20:03:29.091Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*_fdDzS3v45AXO9PYd_8lww.jpeg" /></figure><p>When I first started using AWS, IAM was the part that confused me the most. EC2 made sense. S3 made sense. But IAM felt abstract. Users, roles, policies… everything sounded similar, and I could not understand why AWS made it so complicated.</p><p>Let me explain it the way I understood it.</p><p>An IAM user is simply a person or application that needs access to AWS. For example, when I created my own AWS account, I was using the root user. That is the main account. But using the root user daily is risky. So I created an IAM user for myself. That IAM user had its own username and password. Now I could log in without touching the root account.</p><p>That’s it. An IAM user = an identity.</p><p>Now comes policies. A policy is just a permission document. It defines what actions are allowed and on which resources. Think of it like a rulebook.</p><p>For example, when I wanted my IAM user to launch EC2 instances, I attached a policy that allowed actions like ec2:RunInstances and ec2:DescribeInstances. Without that policy, I would see “Access Denied.” The user exists, but without permissions, it can’t do anything.</p><p>So users are identities. Policies are permissions.</p><p>Then I came across roles. This part confused me again.</p><p>A role is not attached to a specific person like a user. Instead, it is meant to be assumed temporarily by a service or user. That sentence took me time to understand. The real example helped.</p><p>When I launched an EC2 instance and wanted it to access an S3 bucket, I had two options. I could store access keys inside the EC2 instance. That felt unsafe. Or I could create an IAM role with permission to access S3 and attach that role to the EC2 instance.</p><p>I chose the role.</p><p>Now the EC2 instance could access S3 without me storing any secret keys. The instance “assumed” the role automatically. That felt clean and secure. This is where roles really shine. They are perfect for services like EC2, Lambda, or ECS.</p><p>So in simple words:</p><p>Users are for people or applications that log in.<br>Policies define what actions are allowed.<br>Roles are temporary identities that services can assume.</p><p>One mistake I made early on was giving full administrator access just to avoid errors. It worked, but it was lazy. Later, when I started debugging permission issues in my projects, I realized why least privilege matters. If something breaks, it’s easier to trace. And it’s safer.</p><p>IAM is not about memorizing JSON policy documents. It’s about understanding who needs access, to what, and for how long.</p><p>Once I started thinking in those terms, IAM stopped feeling scary. It became logical. Not simple, but logical.</p><p>And honestly, that small mindset shift helped me a lot while building real systems on AWS.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68da6eee5c15" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Traditional SDLC vs DevOps Lifecycle: What Changed and Why]]></title>
            <link>https://medium.com/@vgore3965/i-first-learned-software-development-through-the-traditional-sdlc-model-b946a68fc88e?source=rss-26ce92357f07------2</link>
            <guid isPermaLink="false">https://medium.com/p/b946a68fc88e</guid>
            <category><![CDATA[sdlc]]></category>
            <category><![CDATA[sdlc-vs-devops-lifecycle]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[devops-lifecycle]]></category>
            <dc:creator><![CDATA[Vishal Gore]]></dc:creator>
            <pubDate>Wed, 04 Feb 2026 06:51:57 GMT</pubDate>
            <atom:updated>2026-02-04T09:29:02.358Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*VbVseLzXWoLiAcRQOmrzbw.jpeg" /><figcaption>Traditional SDLC vs DevOps Lifecycle: What Changed and Why</figcaption></figure><p>I first learned software development through the traditional SDLC model. Everything had a fixed order. Requirements came first, then design, then development, then testing, and finally release. Each phase felt like a closed door. Once you moved ahead, going back was hard. It taught discipline, but it also taught waiting.</p><p>In real projects, that waiting became painful. Developers waited for approvals. Testers waited for builds. Customers waited for fixes. By the time software reached users, their needs had already changed. Bugs felt expensive because fixing them meant reopening old work. SDLC worked well on paper, but real life rarely followed the plan.</p><p>DevOps entered my learning journey much later. At first, it felt confusing. There was no strict start or end. Everything looked like a loop. Code, test, deploy, monitor, and repeat. Teams talked more. Feedback came faster. Mistakes were not hidden until the end. They showed up early, when fixing them was easier.</p><p>The biggest change was mindset. Traditional SDLC treated development and operations as separate worlds. DevOps brought them together. The same people who built the software now cared about how it ran in production. That created ownership. When something broke, there was no finger pointing, only problem solving.</p><p>Another big shift was automation. In SDLC, many tasks were manual. Builds, tests, and deployments took time and energy. DevOps encouraged tools to handle repeat work. This did not remove humans from the process. It gave them space to think, review, and improve instead of rushing through routine steps.</p><p>Speed is often mentioned, but speed alone is not the real story. DevOps changed how teams learn. Small releases mean small lessons. Instead of waiting months to know if something worked, teams learn in days or hours. That constant learning builds confidence and trust.</p><p>Why did this change happen? Software stopped being static. Users expect updates often. Businesses need to respond quickly. Systems grew complex and connected. The old linear flow could not keep up. DevOps evolved as a response, not a trend.</p><p>Traditional SDLC still has value. It brings structure and clarity, especially for stable systems. DevOps does not reject that. It adapts it. Planning still matters. Design still matters. The difference is flexibility.</p><p>Looking back, SDLC taught me how software should be built. DevOps taught me how software survives in the real world. Both shaped my understanding. The change happened because reality demanded it, and developers learned to listen.</p><p>Over time, I stopped seeing this as a battle between two approaches. It feels more like an evolution. Teams borrow what works and leave what does not. The goal stays simple. Build software people can rely on. Keep improving it without burning out the humans behind the screen. That balance explains why the shift continues.</p><p>For anyone learning today, understanding both helps. One explains order. The other explains change. Together, they show how software moved from slow delivery to steady improvement, shaped by real users, real failures, and real lessons learned along the way. Nothing stays fixed forever. Clearly.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b946a68fc88e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git for DevOps Engineers: A Beginner’s Guide]]></title>
            <link>https://medium.com/@vgore3965/git-for-devops-engineers-a-beginners-guide-c1b30d2d57a9?source=rss-26ce92357f07------2</link>
            <guid isPermaLink="false">https://medium.com/p/c1b30d2d57a9</guid>
            <dc:creator><![CDATA[Vishal Gore]]></dc:creator>
            <pubDate>Thu, 29 Jan 2026 18:31:45 GMT</pubDate>
            <atom:updated>2026-01-29T18:31:45.500Z</atom:updated>
            <content:encoded><![CDATA[<p>Git is one of those tools every DevOps engineer hears about early, yet many beginners feel lost using it. I remember opening a terminal, typing git status, and wondering what half the output meant. Over time, Git stopped feeling like magic and started feeling practical and useful.</p><p>At its core, Git is simply a way to track changes. Every time you save progress, Git remembers what changed and when. You start by creating or cloning a repository. git init turns a folder into a repo, while git clone &lt;url&gt; copies an existing one. From that moment, Git quietly watches your files.</p><p>The first commands you use often are basic. git status shows what changed. git add . tells Git which files you want to save. git commit -m &quot;message&quot; creates a snapshot. Commits are not scary. They are small notes to your future self explaining what you changed and why.</p><p>Branches confused me at first. I thought they were risky copies. In reality, they are safe spaces. You create one using git branch feature-name or git checkout -b feature-name. This lets you test ideas without touching the main branch. If it works, you merge it. If not, you delete it.</p><p>Merging happens with git merge branch-name. Sometimes Git cannot decide what to keep, and conflicts appear. That feels stressful early on. But conflicts are just Git asking you to choose. After fixing files, you add them again and commit. With practice, conflicts feel manageable.</p><p>Pulling and pushing are daily habits. git pull brings changes from others. git push sends your work back. Forgetting to pull can cause conflicts later. I learned that lesson the hard way. Now I pull often, even before small changes.</p><p>For DevOps engineers, Git shows up everywhere. Terraform files, Kubernetes YAMLs, shell scripts, and pipelines all live in repositories. A wrong edit can break systems. Git history helps you roll back using git checkout &lt;commit-id&gt; or inspect changes with git log and git diff.</p><p>The best way to learn Git is slow repetition. Try things. Break things. Create branches, merge them, and delete them. Read error messages instead of copying commands blindly. Git rewards curiosity more than speed, and patience matters more than memorizing commands.</p><p>Even now, I still look up commands. That does not mean failure. It means Git is deep. Writing clear commit messages saves time later. Short, honest messages help teams understand decisions. Git also builds shared ownership because everyone can see and review changes.</p><p>Beginners should ignore advanced features at first. Rebase, cherry-pick, and hooks can wait. Focus on add, commit, pull, and push. Use Git daily, even for tiny edits. Familiarity grows quietly.</p><p>Git does not need love or obsession. It needs respect and calm learning. Once mistakes feel normal, confidence follows. Version control becomes routine, like saving files, and that quiet reliability supports DevOps work every single day.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c1b30d2d57a9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>