<?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 Ajah Ijeoma on Medium]]></title>
        <description><![CDATA[Stories by Ajah Ijeoma on Medium]]></description>
        <link>https://medium.com/@Aijay27?source=rss-609565ed0c73------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*HB_SN7MZkBa-EE1WUZDFMw.jpeg</url>
            <title>Stories by Ajah Ijeoma on Medium</title>
            <link>https://medium.com/@Aijay27?source=rss-609565ed0c73------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 23:09:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@Aijay27/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[I Built a Cloud Application. Then I Asked: What Happens When 10,000 Users Show Up?]]></title>
            <link>https://awstip.com/i-built-a-cloud-application-then-i-asked-what-happens-when-10-000-users-show-up-015902a612ce?source=rss-609565ed0c73------2</link>
            <guid isPermaLink="false">https://medium.com/p/015902a612ce</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Ajah Ijeoma]]></dc:creator>
            <pubDate>Sun, 16 Aug 2026 21:26:01 GMT</pubDate>
            <atom:updated>2026-08-16T21:26:01.541Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Scaling an application is not just about adding more servers. It is about designing for traffic, failure, performance, availability, and growth.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JwEJ7VYXPLL9bsB872T49A.png" /><figcaption><strong>From 1 server to 10,000 users.</strong></figcaption></figure><p>The application worked.</p><p>That was the exciting part.</p><p>The server was running. The application was accessible from the internet. Requests were reaching the backend, the database was responding, and everything looked fine.</p><p>For a while, that felt like success.</p><p>Then I asked myself a question that changed the way I started looking at cloud engineering:</p><p>What happens when 10,000 people try to use this application at the same time?</p><p>The answer is not simply, “Get a bigger server.”</p><p>That might work for a while, but it does not solve every problem.</p><p>What happens when the server crashes?</p><p>What happens when traffic suddenly increases?</p><p>What happens when the database becomes the bottleneck?</p><p>What happens when users are accessing the application from different parts of the world?</p><p>What happens when we deploy a new version and something breaks?</p><p>And perhaps most importantly, how do we know that something is going wrong before our users start complaining?</p><p>These questions took me beyond the simple idea of putting an application on a cloud server.</p><p>They introduced me to something much more important.</p><p><strong>Architecture.</strong></p><p>Building an application that works is one thing.</p><p>Building an application that can handle growth, survive failures, maintain reasonable performance, and be monitored and updated reliably is a completely different challenge.</p><p>That is where Cloud Engineering and DevOps start becoming much more interesting.</p><p>Before We Scale, Let Us Start with Something Simple</p><p>Imagine our application has three basic parts.</p><p>The frontend is what the user interacts with.</p><p>The backend contains the application logic.</p><p>The database stores the information the application needs.</p><p>At the beginning, everything could technically run on one server.</p><p>It might look something like this: <strong>User → Server → Database</strong></p><p>For a small project, this may be perfectly reasonable.</p><p>There is nothing wrong with starting small.</p><p>In fact, starting with a simple architecture can be a good decision when the application is still small and the requirements are straightforward.</p><p>The problem begins when we assume that the same architecture will continue to work regardless of how much the application grows.</p><p>A server has limits.</p><p>It has a certain amount of CPU.</p><p>It has a certain amount of memory.</p><p>It has a certain network capacity.</p><p>It can only process so many requests at a time.</p><p>Eventually, we reach a point where the server starts struggling.</p><p>The application becomes slower.</p><p>Requests take longer to complete.</p><p>Users begin experiencing errors.</p><p>And if the server completely fails, the entire application could become unavailable.</p><p>That creates another problem.</p><p>The server has become a single point of failure.</p><p>So instead of asking how to make one server do everything, we can start asking a better question:</p><p>How can we design the system so that the workload can be distributed?</p><p>That question leads us to our next component.</p><p><strong>What Happens When One Server Is Not Enough?</strong></p><p>There are two common ways to approach this problem.</p><p>The first is <strong>vertical</strong> <strong>scaling</strong>.</p><p>We make the existing server bigger.</p><p>We give it more CPU, more memory, more storage, or other resources.</p><p>This can be useful, especially when the application is still relatively small.</p><p>But there is a limit to how far we can go.</p><p>A bigger server can also become increasingly expensive.</p><p>Eventually, we may be paying a lot of money for one machine that is still a single point of failure.</p><p>The second approach is <strong>horizontal</strong> <strong>scaling</strong>.</p><p>Instead of making one server bigger, we add more servers.</p><p>For example, we could move from one application server to three.</p><p>Now we have:</p><p><strong>User → Server 1<br> User → Server 2<br> User → Server 3</strong></p><p>But this creates another question.</p><p><strong>How does the user know which server to connect to?</strong></p><p>We do not want users manually choosing servers.</p><p>We need something in front of those servers that can receive incoming requests and distribute them appropriately.</p><p>This is where a load balancer becomes useful.</p><p><strong>The Load Balancer Becomes the Traffic Controller</strong></p><p>Think about a busy restaurant.</p><p>If there is only one waiter and fifty customers arrive at almost the same time, that waiter is going to have a difficult day.</p><p>Now imagine there are five waiters.</p><p>The customers can be distributed among them.</p><p>The same basic idea applies to a load balancer.</p><p>Instead of users connecting directly to one application server, they connect to the load balancer.</p><p>The load balancer receives the incoming requests and distributes them across available servers.</p><p>Our architecture now looks more like this:</p><p><strong>User → Load Balancer → Server 1<br> → Server 2<br> → Server 3</strong></p><p>This immediately gives us an advantage.</p><p>The workload can be distributed.</p><p>If Server 1 is busy, other servers can handle requests.</p><p>If Server 1 becomes unhealthy, the load balancer can stop sending traffic to it while the other servers continue serving users.</p><p>In AWS, Elastic Load Balancing provides this type of traffic distribution.</p><p>But we still have a problem.</p><p><strong>What happens when our three servers are no longer enough?</strong></p><p>What If Traffic Keeps Increasing?</p><p>Suppose our application starts with three servers.</p><p>Everything is working well.</p><p>Then our application becomes popular.</p><p>Traffic increases.</p><p>Our servers are now operating at very high capacity.</p><p>We could manually create more servers.</p><p>But that does not sound particularly efficient.</p><p>Imagine having someone monitoring server usage throughout the night and manually launching new servers whenever traffic increases.</p><p>One of the reasons cloud computing is useful is that we can automate this kind of process.</p><p><strong>This is where Auto Scaling becomes important.</strong></p><p>With an Auto Scaling setup, we can define rules that determine when additional compute resources should be added or removed.</p><p>For example, if the workload remains high for a certain period, additional servers can be launched.</p><p>When demand drops, unnecessary servers can be removed.</p><p>The exact configuration depends on the application and its requirements, but the underlying idea is simple.</p><p>Resources should be able to respond to demand.</p><p>During periods of high traffic, we may need more capacity.</p><p>During periods of low traffic, we may need less.</p><p>This allows infrastructure to become more flexible.</p><p>Instead of building everything around the highest amount of traffic we might ever receive, we can design an environment that can adjust as demand changes.</p><p>But there is still another major part of the system we need to think about.</p><p><strong>The database.</strong></p><p>The Database Can Become the Bottleneck</p><p>Our application servers may be doing well.</p><p>We have three servers.</p><p>We have a load balancer.</p><p>We have Auto Scaling.</p><p>Everything looks great.</p><p>Then we discover that the application is still slow.</p><p>Why?</p><p>The database.</p><p>Every application request that needs data has to communicate with the database.</p><p>Users are logging in.</p><p>Orders are being created.</p><p>Products are being retrieved.</p><p>Messages are being stored.</p><p>Transactions are being processed.</p><p>If all those requests eventually reach one database that cannot handle the workload, the database becomes the bottleneck.</p><p>Adding more application servers will not automatically solve that problem.</p><p>This is one of the things I find interesting about cloud architecture.</p><p>You cannot simply look at one component in isolation.</p><p>You have to understand how the components depend on one another.</p><p>A fast application server does not help much if it spends most of its time waiting for a slow database.</p><p><strong>Using a Managed Database</strong></p><p>Instead of installing and managing a database ourselves on an ordinary server, we can use a managed database service.</p><p><strong>Amazon</strong> <strong>RDS</strong> is one example.</p><p>A managed service does not mean that we no longer have responsibilities.</p><p>We still need to think about the database engine, instance size, storage, security, backups, access permissions, performance, and other configuration decisions.</p><p>However, many of the underlying administrative responsibilities can be handled by the cloud provider.</p><p>That can allow an engineering team to spend more time focusing on the application itself.</p><p>But there is an important lesson here.</p><p>A database is not simply somewhere we put data.</p><p>It is a critical part of the application architecture.</p><p>If the database becomes unavailable, the application may become unavailable too.</p><p>That means reliability and recovery have to be considered from the beginning.</p><p><strong>What Happens When Users Are Far Away?</strong></p><p>Now imagine that our application becomes popular outside our original target location.</p><p>We have users in Nigeria.</p><p>We have users in the United States.</p><p>We have users in India.</p><p>We have users in Australia.</p><p>All of them are accessing infrastructure that may be physically far away from them.</p><p>The internet is incredibly capable, but physical distance still matters when it comes to latency.</p><p><strong>This is where a Content Delivery Network can help.</strong></p><p>A <strong>CDN</strong> can cache and deliver certain types of content from locations closer to users.</p><p>AWS CloudFront is an example.</p><p>Imagine our application contains images, JavaScript files, CSS files, videos, and other static resources.</p><p>Instead of making every user retrieve those files directly from our main infrastructure, a CDN can deliver cached content from locations closer to the users.</p><p>This can improve the user experience while also reducing the amount of traffic reaching the origin infrastructure.</p><p>That gives us another lesson.</p><p>Cloud architecture is also about where content is delivered from, not just where the application is running.</p><p><strong>Where Should User Files Go?</strong></p><p>There is another question we need to answer.</p><p>What happens when users upload files?</p><p>Maybe they upload profile pictures.</p><p>Maybe they upload documents.</p><p>Maybe they upload videos.</p><p>Maybe the application generates reports that need to be stored.</p><p>Should we keep all these files on our application server?</p><p>It might work at first.</p><p>But it creates a problem.</p><p>Application servers should ideally be replaceable.</p><p>If one server disappears, we should not lose important user data because that data happened to be stored on that particular machine.</p><p><strong>This is where object storage becomes useful.</strong></p><p><strong>Amazon</strong> <strong>S3</strong> is an example of an object storage service.</p><p>Instead of treating uploaded files as something that belongs permanently to a particular application server, we can store those objects separately.</p><p>The application can then access them whenever they are needed.</p><p>This separation is important.</p><p>Our application servers can come and go.</p><p>The data should not have to disappear with them.</p><p><strong>Designing for Failure</strong></p><p>One of the biggest changes in my thinking about cloud infrastructure has been understanding that failure is not necessarily an unusual event.</p><p>Servers fail.</p><p>Applications crash.</p><p>Networks have problems.</p><p>Databases can become unavailable.</p><p>Configurations can be wrong.</p><p>Deployments can introduce bugs.</p><p>The question is not simply whether something will fail.</p><p>The better question is:</p><p><strong>What happens when it does?</strong></p><p>Suppose we have three application servers and one suddenly crashes.</p><p>If our load balancer has health checks configured correctly, it can identify that the server is unhealthy and stop sending traffic to it.</p><p>The other servers can continue handling requests.</p><p>Meanwhile, another server can be launched to replace the failed one if the environment is configured for it.</p><p>The users may never know what happened.</p><p>That is the idea behind resilient architecture.</p><p>It does not mean failures stop happening.</p><p>It means one failure does not necessarily bring down the entire system.</p><p><strong>Monitoring Is Not Optional</strong></p><p>There is another part of the architecture that is easy to overlook.</p><p>How do we know what is happening inside the environment?</p><p>Imagine waking up one morning and finding messages from users saying the application is slow.</p><p>You check the application.</p><p>It is running.</p><p>You check the servers.</p><p>They are running.</p><p>But something is clearly wrong.</p><p>Without proper monitoring and logs, you may spend hours guessing.</p><p>With monitoring, you may discover that CPU usage has suddenly increased.</p><p>Maybe memory usage is unusually high.</p><p>Maybe database connections have reached their limit.</p><p>Maybe response times have increased.</p><p>Maybe one API endpoint is returning thousands of errors.</p><p>Monitoring gives us visibility.</p><p>Instead of guessing what is wrong, we can investigate what the infrastructure is actually doing.</p><p>Services such as <strong>Amazon</strong> <strong>CloudWatch</strong> can help collect metrics, logs, and other information that can be used to understand the health and performance of our environment.</p><p>This becomes even more important as the infrastructure grows.</p><p>When you have one server, you might be able to check it manually.</p><p>When you have dozens or hundreds of resources, manual inspection is no longer practical.</p><p><strong>So Where Does DevOps Come In?</strong></p><p>At this point, someone might ask:</p><p>Isn’t everything we have discussed just cloud computing?</p><p>Yes.</p><p>But this is where DevOps connects the different pieces.</p><p>Imagine that a developer makes a change to the application.</p><p>The code is pushed to GitHub.</p><p>A CI pipeline can automatically build the application and run tests.</p><p>If the tests pass, the application can move to the next stage.</p><p>The application can be packaged into a container.</p><p>That container can be stored in a container registry.</p><p>Infrastructure can be provisioned using Infrastructure as Code.</p><p>The application can then be deployed to the required environment.</p><p>After deployment, monitoring can help determine whether the application is behaving as expected.</p><p>If something goes wrong, engineers investigate the problem, fix it, and improve the process.</p><p>This is where DevOps becomes more than knowing how to use individual tools.</p><p>Git is useful.</p><p>Docker is useful.</p><p>Kubernetes is useful.</p><p>Terraform is useful.</p><p>AWS is useful.</p><p>But knowing how these tools fit into the bigger picture is even more important.</p><p>The goal is not to collect tools.</p><p>The goal is to build a reliable process for developing, deploying, operating, monitoring, and improving software.</p><p><strong>The Architecture Keeps Evolving</strong></p><p>Look at where we started.</p><p>One server.</p><p>One application.</p><p>One database.</p><p>Then we encountered problems.</p><p>We needed more capacity, so we introduced additional <strong>servers</strong>.</p><p>We needed a way to distribute traffic, so we introduced <strong>a</strong> <strong>load</strong> <strong>balancer</strong>.</p><p>We needed the infrastructure to respond to changing demand, so we introduced <strong>Auto</strong> <strong>Scaling</strong>.</p><p>We needed to think about database reliability and performance, so we considered a managed database.</p><p>We needed to serve content efficiently to users in different locations, so we introduced a <strong>CDN</strong>.</p><p>We needed somewhere reliable to store files, so we considered <strong>object</strong> <strong>storage</strong>.</p><p>We needed visibility into the environment, so we introduced <strong>monitoring</strong>.</p><p>We needed a reliable way to build and deploy changes, so <strong>DevOps</strong> practices became important.</p><p>Notice something.</p><p>We did not introduce all these components simply because they were available.</p><p>Each one addressed a problem.</p><p>That distinction matters.</p><p>Good cloud architecture is not about using as many services as possible.</p><p>It is about understanding the problem and choosing an appropriate solution.</p><p>More Services Do Not Always Mean a Better Architecture</p><p>There is a temptation when learning cloud computing to think that a more complicated architecture must be a better architecture.</p><p>I do not think that is true.</p><p>If an application has a small number of users and simple requirements, it may not need an elaborate architecture.</p><p>There may be no reason to introduce Kubernetes simply because Kubernetes is popular.</p><p>There may be no reason to build a complicated multi region architecture if the application does not require it.</p><p>There may be no reason to introduce ten different services when three can solve the problem properly.</p><p>Every additional component introduces complexity.</p><p>It needs to be configured.</p><p>It needs to be secured.</p><p>It needs to be monitored.</p><p>It may need to be maintained.</p><p>And it may increase the cost of running the application.</p><p><strong>The goal is not complexity.</strong></p><p>The goal is to build an environment that is reliable, scalable, secure, maintainable, and appropriate for the application’s actual requirements.</p><p>So, What Happens When 10,000 Users Show Up?</p><p>Let’s return to the question that started this whole discussion.</p><p>What happens when 10,000 users show up?</p><p>The answer depends on how we designed the system.</p><p>Users send requests to the application.</p><p>A load balancer receives the traffic and distributes requests across available application servers.</p><p>If demand increases, Auto Scaling can add more compute resources based on the rules we have configured.</p><p>The application servers communicate with the database.</p><p>Files can be stored separately using object storage.</p><p>A CDN can deliver cached content closer to users.</p><p>Monitoring helps us understand what is happening across the environment.</p><p>Automation helps us deploy changes consistently.</p><p>If one application server fails, the remaining servers can continue serving users.</p><p>If traffic decreases, unnecessary compute resources can be removed.</p><p><strong>None of this happens by magic.</strong></p><p>It happens because the architecture was designed with these possibilities in mind.</p><p><strong>What I Took Away From This</strong></p><p>The biggest lesson for me is that cloud engineering is not really about memorising cloud services.</p><p>It is about understanding problems.</p><p>A load balancer exists because distributing traffic can be better than sending everything to one server.</p><p>Auto Scaling exists because demand changes.</p><p>A managed database exists because databases require reliability, performance, backups, and proper management.</p><p>A CDN exists because users are not all sitting next to our servers.</p><p>Object storage exists because application servers should not necessarily be responsible for storing everything.</p><p>Monitoring exists because we cannot manage what we cannot see.</p><p>DevOps practices exist because deploying software manually and repeatedly is not a reliable way to operate modern applications at scale.</p><p>Once I started looking at cloud architecture this way, the services became easier to understand.</p><p>Instead of asking:</p><p><strong>“What does this AWS service do?”</strong></p><p>I started asking:</p><p><strong>“What problem does this solve?”</strong></p><p>That small change in perspective makes a huge difference.</p><p>Because the goal of cloud engineering is not to build the most complicated architecture possible.</p><p>The goal is to build an architecture that makes sense for the problem.</p><p>Maybe your application has ten users today.</p><p>Maybe it will have 10,000 tomorrow.</p><p>You may not need a complicated architecture from day one.</p><p>But you should understand what happens when the simple solution eventually stops being enough.</p><p>That is the part of Cloud and DevOps Engineering I am beginning to appreciate the most.</p><p>It is not just about getting an application to work.</p><p>It is about thinking ahead.</p><p>Because when 10,000 users eventually show up, you do not want to be asking for the first time:</p><p>“What are we going to do now?”</p><p>You want your architecture to already have an answer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=015902a612ce" width="1" height="1" alt=""><hr><p><a href="https://awstip.com/i-built-a-cloud-application-then-i-asked-what-happens-when-10-000-users-show-up-015902a612ce">I Built a Cloud Application. Then I Asked: What Happens When 10,000 Users Show Up?</a> was originally published in <a href="https://awstip.com/">AWS Tip</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Establishing a Proper Version Control Architecture in a Production Environment]]></title>
            <link>https://awstip.com/establishing-a-proper-version-control-architecture-in-a-production-environment-33d59fa8cf6a?source=rss-609565ed0c73------2</link>
            <guid isPermaLink="false">https://medium.com/p/33d59fa8cf6a</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Ajah Ijeoma]]></dc:creator>
            <pubDate>Fri, 14 Aug 2026 21:26:01 GMT</pubDate>
            <atom:updated>2026-08-14T21:26:01.566Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FhMPaEWS1ZgsmdcRj5LgJQ.png" /><figcaption><strong>Gitflow production strategy.</strong></figcaption></figure><p>I suppose a lot of people enter the software engineering space expecting everything to be fully automated from day one. I certainly had that mindset when I first started exploring infrastructure. You see tutorials online where someone runs a single script, and suddenly a massive architecture spins up flawlessly in the cloud. However, stepping into a proper production environment usually shatters that illusion pretty quickly. Real engineering is incredibly granular. It requires a fundamental understanding of how the gears turn before you even think about attaching a motor to them.</p><p>Recently, I wrapped up an internship training program focused heavily on DevOps engineering practices. The core focus was not just on writing flashy code or deploying rapid instances. Part of it was about establishing the rock solid baseline repository architecture that actually keeps a team functioning. You simply cannot build a reliable application if your version control is a mess. I am going to walk you through exactly what is expected when you are managing repositories and establishing a GitFlow strategy in a professional setting.</p><p>I will keep things completely manual, strictly through the command line. When I served as the designated infrastructure engineer for a ten person microservices project utilizing the distributed Spring PetClinic platform, I was actually supposed to configure everything manually. Please eliminate any idea that you should be automating this initial deployment stage. That manual constraint turned out to be the best thing for my skill set. By forcing myself to structure modular directory paths and execute every repository step by hand in an Ubuntu terminal, I caught configuration issues that an automated script would have just buried under generic error logs. This same logic applies to your Git repositories. Relying on graphical interfaces creates severe blind spots. Therefore, opening up a terminal and typing out the commands is non negotiable for building true expertise.</p><p><strong>The First Step Is Securing the Source Code</strong></p><p>Almost every project starts with a baseline. You rarely write a massive application completely from scratch. Usually, you find a reliable open source template, perhaps an e commerce boilerplate, and you use that as your foundation.</p><p>The very first thing you need to do is bring that code down to your local machine. You open your terminal and run the standard clone command targeting the public URL.</p><p>Sometimes, this fails immediately. I have spent hours troubleshooting multi stage Docker architectures and rootless container networks, only to be stopped completely by a simple local network error. If your terminal spits out a message saying it could not resolve the GitHub host, your machine is failing to translate the domain name into an IP address. You can usually test this by pinging a public nameserver like Google. If the ping succeeds, you just need to open your resolver configuration file with root privileges and manually add a nameserver line. Once your DNS is cooperating, the clone will pull all the files down into a new directory.</p><p>Once the download finishes, you have a complete local copy of the project. However, this copy is still fundamentally tethered to the original public source. If you try to push your new modifications right now, Git will attempt to send them straight back to the original author. They will reject your push, and you will receive a permission error. Therefore, you need to sever this invisible connection. You do this by navigating into your project folder and removing the origin remote entirely. It feels a bit destructive, but I guess it is the only way to truly claim the repository as your own private workspace.</p><p>At this point, you head over to your GitHub account in a web browser. You create a brand new repository and make absolutely sure you select the private option. You are building proprietary infrastructure, so you cannot have your source code sitting out in the open. You must also leave this new repository completely empty. Do not initialize it with a readme file or a license. You want a completely blank shell because you are about to push your existing local history into it.</p><p>Back in your terminal, you add a new remote origin pointing directly to your private URL. Finally, you push your local code up to this new destination. You have successfully privatized a public baseline, completely manually.</p><p><strong>Understanding the GitFlow Branching Strategy</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/823/1*Lu-DZW2mDaoLchJpsx_-Uw.png" /><figcaption><strong>An image showing gitflow upward merge work strategy</strong></figcaption></figure><p>You now have a private repository, but pushing all your code directly to the main branch is a terrible idea. In a production team, multiple engineers are working simultaneously. If everyone pushes to the same place, the codebase will break constantly. This is exactly why the GitFlow branching strategy exists. It creates isolated environments for different stages of the development lifecycle.</p><p>Before typing any more commands, you need to understand the hierarchy of the branches you are about to create.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*vdcBApkJol0W-ukbCBBGJw.png" /><figcaption><strong>A table showing the four critical pillars of a standard GitFlow architecture.</strong></figcaption></figure><p>The table above outlines the four critical pillars of a standard GitFlow architecture. You begin with the main branch, which represents the code currently running for your actual users. You never write code directly here. The stg branch is your staging environment, functioning as an exact replica of main where QA testers can verify changes without breaking the live application. The dev branch is your development area, where all engineers send their completed work to be combined and tested together. Finally, the feature branches are personal sandboxes attached to individual developers, allowing you to experiment and break things without affecting anyone else.</p><p><strong>Executing the Branch Architecture Locally</strong></p><p>Now that the theory is clear, you have to actually build this structure in your terminal. Since you just pushed your initial baseline, your local environment is sitting squarely on the main branch.</p><p>You want to build the hierarchy sequentially. First, you create the staging branch directly off main. You run a command to checkout a new branch named stg, and then you immediately push it up to your remote repository, ensuring you set the upstream tracking flag. This tracking flag is crucial because it permanently links your local staging branch to the staging branch on GitHub.</p><pre>git checkout -b stg<br>git push -u origin stg</pre><p>Next, you repeat the exact same process for the development branch. You create dev while sitting on stg, and you push it up. Finally, you create your personal workspace. You might name it something like feature followed by a slash and your specific identifier. You create this branch while sitting on dev, and you push it up as well.</p><pre>git checkout -b dev<br>git push -u origin dev</pre><p>By creating these sequentially without adding any new code in between, you guarantee that main, stg, dev, and your feature branch all share the exact same starting commit. You have manually established a perfect, clean baseline. I suppose you could branch them all individually off main, but the sequential method feels much more logical for a fresh setup. You are currently sitting on your feature branch, fully isolated and ready to begin real engineering work.</p><p><strong>The Integration Checkpoint and Pull Requests</strong></p><p>Let us assume you have been working in your feature branch for a few hours. Perhaps you updated the documentation, modified a database schema, or adjusted some server configurations. You check your local status, stage your modified files, and commit them with a clear, descriptive message. Then, you push those commits up to your remote feature branch.</p><p>Your local work is now safely stored on GitHub. However, your code is still completely isolated. The rest of your team cannot use it, and the application is not running it. You have to move your code upward through the GitFlow hierarchy.</p><p>You do not just aggressively merge your files into the development branch. That would bypass all quality control. Instead, you create a Pull Request.</p><p>A Pull Request is a formal request to merge your isolated feature branch into a target branch, which in this first step will always be dev. It is a dedicated security checkpoint. It provides a visual interface on GitHub where your team can review your exact code changes line by line, discuss potential issues, and run automated tests before anything is actually integrated.</p><p>When you open the Pull Request, you must be incredibly careful to set the base branch correctly. The default target is almost always main, and trying to merge a raw feature directly into production will rightfully cause a panic in a professional environment. You must manually change the target to dev.</p><p>You then fill out a detailed description. You explain exactly what you changed, why you changed it, and how it impacts the existing infrastructure. You treat this description like a professional report. I have conducted econometric data modeling and built structural stability forecasts using standard citation guidelines. Writing a Pull Request description requires that exact same level of rigor and clarity. You want your reviewers to understand your logic completely before they even look at the code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_R6D9u9UJzUB2DfUGBLx8g.png" /><figcaption><strong>An image showing a completed PR gitflow strategy.</strong></figcaption></figure><p><strong>Addressing Feedback and Pushing Forward</strong></p><p>Once the Pull Request is open, your teammates will review it. They will probably find something you missed. They might ask you to rename a variable, optimize a function, or add more comments.</p><p>When you receive this feedback, you do not close the Pull Request or panic. You simply go back to your terminal, ensure you are still on your feature branch, and make the requested adjustments manually. You stage those new changes, create a new commit, and push it up again. The existing Pull Request on GitHub will automatically update to include your latest fixes.</p><p>Eventually, someone will approve your work. At that moment, you click the merge button. Your feature branch is officially swallowed by the dev branch. Your code is now part of the shared integration environment.</p><p>The upward flow does not stop there. Once dev accumulates enough approved features from various team members, a senior engineer will open a new Pull Request to merge dev into stg. This moves the combined code into the pre production mirror for intense testing. If it survives staging without crashing, a final Pull Request is opened to merge stg into main. That final merge is what triggers an actual deployment to the live users.</p><p><strong>Dealing With Merge Conflicts Manually</strong></p><p>Everything I have described sounds incredibly smooth. In reality, things break constantly. The most common hurdle you will face is a merge conflict.</p><p>Merge conflicts happen when two developers edit the exact same line of code in different feature branches, and both try to merge their work into dev. Git is very smart, but it cannot read minds. It does not know which version of the line is correct. Therefore, it halts the merge entirely and demands that a human fix the discrepancy.</p><p>When I first encountered a conflict while evaluating live market structures and rigid boundaries in a separate project, my initial reaction was to just delete my local repository and start over. That is the worst possible way to handle it. You have to confront conflicts directly in the terminal.</p><p>Git will modify the conflicting files, injecting distinct markers that highlight exactly where the collision occurred. You will see a section showing your local changes, separated by a line of equals signs, followed by a section showing the incoming changes from the target branch.</p><p>You have to open the file, read both versions, and manually delete the code that you do not want to keep. You also have to delete the markers that Git inserted. Once the file looks exactly how you want it to look, you save it. You then go back to your terminal, stage the resolved file, and finalize the merge commit. It is a tedious, entirely manual process, but it is a necessary skill. Avoiding conflicts just leads to messy, unstable code later on.</p><p><strong>Maintaining a Clean Local Environment</strong></p><p>As you cycle through countless feature branches and Pull Requests, your local machine will start to accumulate a lot of obsolete data. You will have dozens of old feature branches cluttering your terminal space.</p><p>It is a good habit to aggressively clean your local environment. Once your feature is successfully merged into dev on GitHub, you should switch your local terminal to the dev branch and pull down the latest updates. Then, you should manually delete your old local feature branch. You do not need it anymore, and keeping it around only increases the risk that you might accidentally branch off outdated code in the future.</p><p>Always ensure you are starting fresh. Before you create a new feature branch for your next assignment, verify that you are sitting on dev, and verify that dev is completely synchronized with the remote repository.</p><p><strong>Building the Right Foundation for the Future</strong></p><p>I have spent a lot of time debugging terminal environment variables and successfully configuring automated background services inside local environments. I deeply understand the value of continuous integration and deployment pipelines. However, none of that advanced automation matters if your version control foundation is weak.</p><p>If your team does not respect the GitFlow strategy, or if developers do not understand how to manually manipulate branches in the terminal, your automated pipelines will just push broken code into production faster.</p><p>Taking the time to build a private repository from scratch, establishing strict staging gates, and forcing every line of code through a rigorous Pull Request pipeline builds discipline. It teaches you how the codebase truly evolves. I suppose it takes a bit more effort upfront to configure everything manually without relying on graphical shortcuts, but the resulting stability in your production environment is absolutely worth the effort. It is the only way to genuinely operate like a professional infrastructure engineer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=33d59fa8cf6a" width="1" height="1" alt=""><hr><p><a href="https://awstip.com/establishing-a-proper-version-control-architecture-in-a-production-environment-33d59fa8cf6a">Establishing a Proper Version Control Architecture in a Production Environment</a> was originally published in <a href="https://awstip.com/">AWS Tip</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond EC2 and S3: 15 AWS AI and Machine Learning Services Every Cloud & DevOps Engineer Should…]]></title>
            <link>https://awstip.com/beyond-ec2-and-s3-15-aws-ai-and-machine-learning-services-every-cloud-devops-engineer-should-d1ccec23994c?source=rss-609565ed0c73------2</link>
            <guid isPermaLink="false">https://medium.com/p/d1ccec23994c</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[mlops]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Ajah Ijeoma]]></dc:creator>
            <pubDate>Sun, 09 Aug 2026 20:41:01 GMT</pubDate>
            <atom:updated>2026-08-09T20:41:01.303Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Beyond EC2 and S3: 15 AWS AI and Machine Learning Services Every Cloud &amp; DevOps Engineer Should Know</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lByWFPbOg0e6WpgHKPbvWQ.png" /><figcaption>AI and ML educative image.</figcaption></figure><p>When people begin learning AWS, they usually focus on services like EC2, S3, IAM, VPC, RDS, Lambda, CloudFormation, and ECS. These are the building blocks of cloud infrastructure and are essential for anyone pursuing a career in Cloud Computing or DevOps.</p><p>However, AWS is no longer just a cloud infrastructure provider.</p><p>It has become one of the leading platforms for Artificial Intelligence (AI) and Machine Learning (ML), offering managed services that enable organizations to build intelligent applications without developing complex models from scratch.</p><p>Many engineers assume these services are only useful to data scientists.</p><p>That is no longer the case.</p><p>Modern Cloud and DevOps Engineers are increasingly expected to understand how AI and ML services fit into cloud-native architectures. You may not be responsible for training models, but you are often responsible for deploying, securing, automating, monitoring, and integrating the infrastructure that powers them.</p><p>Understanding these services gives you an advantage as cloud technology continues to evolve.</p><p><strong>AI vs. Machine Learning: What’s the Difference?</strong></p><p>Although the terms are often used interchangeably, they are not the same.</p><p><strong>Artificial Intelligence (AI)</strong> refers to systems designed to perform tasks that typically require human intelligence, such as understanding language, recognizing images, answering questions, or generating content.</p><p><strong>Machine Learning (ML)</strong> is a branch of AI in which computers learn patterns from data and improve their performance without being explicitly programmed for every task.</p><p>In simple terms:</p><ul><li><strong>AI</strong> focuses on making systems intelligent.</li><li><strong>ML</strong> is one of the methods used to achieve that intelligence.</li></ul><p>Many AWS services are AI-powered, while others are designed specifically to build, train, and deploy machine learning models.</p><p><strong>AWS Artificial Intelligence Services</strong></p><p><strong>1. Amazon Comprehend</strong></p><p>Amazon Comprehend uses Natural Language Processing (NLP) to understand written text.</p><p>It can:</p><ul><li>Detect sentiment</li><li>Identify people, places, organizations, and dates</li><li>Extract key phrases</li><li>Recognize languages</li><li>Discover common topics across large collections of documents</li></ul><p><strong>Example</strong></p><p>A company receiving thousands of customer reviews can automatically identify complaints, positive feedback, and recurring issues without reading every review manually.</p><p><strong>Why it matters to DevOps</strong></p><p>A DevOps team can integrate Comprehend into automated customer feedback pipelines, allowing applications to analyze user sentiment after every software release. This helps teams identify issues earlier and make data-driven deployment decisions.</p><p><strong>2. Amazon Translate</strong></p><p>Amazon Translate converts text between multiple languages using neural machine translation.</p><p><strong>Common uses</strong></p><ul><li>Websites</li><li>Customer support</li><li>Product catalogues</li><li>Mobile applications</li><li>Internal documentation</li></ul><p><strong>DevOps relevance</strong></p><p>Applications serving global users can automatically translate content as part of CI/CD deployment workflows, ensuring localized experiences without maintaining separate translation processes.</p><p><strong>3. Amazon Textract</strong></p><p>Amazon Textract extracts text, forms, tables, and structured information from scanned documents and images.</p><p>Unlike traditional OCR, it understands document layouts.</p><p><strong>Typical use cases</strong></p><ul><li>Bank forms</li><li>Insurance claims</li><li>Medical records</li><li>Receipts</li><li>Invoices</li></ul><p><strong>DevOps relevance</strong></p><p>Textract can be integrated into automated document-processing pipelines using Lambda, Step Functions, and EventBridge, eliminating manual processing while improving speed and accuracy.</p><p><strong>4. Amazon Lex</strong></p><p>Amazon Lex enables developers to build conversational chatbots and voice assistants.</p><p>It combines speech recognition with natural language understanding.</p><p><strong>Common applications</strong></p><ul><li>Customer support</li><li>HR portals</li><li>Banking assistants</li><li>Appointment scheduling</li></ul><p><strong>DevOps relevance</strong></p><p>DevOps engineers deploy, monitor, and automate chatbot infrastructure, ensuring high availability, scalability, logging, and continuous delivery of conversational applications.</p><p><strong>5. Amazon Polly</strong></p><p>Amazon Polly converts written text into realistic speech.</p><p><strong>Common applications</strong></p><ul><li>Accessibility tools</li><li>Audiobooks</li><li>Navigation systems</li><li>Virtual assistants</li><li>E-learning platforms</li></ul><p><strong>DevOps relevance</strong></p><p>Teams can automate voice generation as part of application workflows while ensuring scalable, highly available speech services.</p><p><strong>6. Amazon Transcribe</strong></p><p>Amazon Transcribe converts spoken audio into searchable text.</p><p>Features include speaker identification, timestamps, automatic punctuation, and custom vocabularies.</p><p><strong>Applications</strong></p><ul><li>Meeting transcripts</li><li>Call centres</li><li>Podcasts</li><li>Video captions</li><li>Medical dictation</li></ul><p><strong>DevOps relevance</strong></p><p>Automated media-processing pipelines can trigger transcription whenever new audio files are uploaded to Amazon S3.</p><p><strong>7. Amazon Rekognition</strong></p><p>Amazon Rekognition analyzes images and videos.</p><p>It can identify:</p><ul><li>Faces</li><li>Objects</li><li>Activities</li><li>Text</li><li>Unsafe content</li><li>Personal protective equipment (PPE)</li></ul><p><strong>Applications</strong></p><ul><li>Security systems</li><li>Content moderation</li><li>Retail analytics</li><li>Media management</li></ul><p><strong>DevOps relevance</strong></p><p>DevOps teams automate image analysis workflows while ensuring scalable infrastructure capable of processing millions of files reliably.</p><p><strong>8. Amazon Kendra</strong></p><p>Amazon Kendra is an intelligent enterprise search service.</p><p>Instead of simply matching keywords, it understands natural-language questions and retrieves relevant answers from organizational data.</p><p><strong>Applications</strong></p><ul><li>Internal documentation</li><li>Company knowledge bases</li><li>Policy search</li><li>Customer support</li></ul><p><strong>DevOps relevance</strong></p><p>Organizations can integrate Kendra into internal developer portals, allowing engineers to quickly locate documentation, runbooks, deployment guides, and troubleshooting procedures.</p><p><strong>9. Amazon Personalize</strong></p><p>Amazon Personalize creates recommendation engines using machine learning.</p><p>Examples include:</p><ul><li>Product recommendations</li><li>News feeds</li><li>Video suggestions</li><li>Music recommendations</li></ul><p><strong>DevOps relevance</strong></p><p>DevOps engineers automate the deployment, monitoring, scaling, and integration of personalization services into production environments.</p><p><strong>10. Amazon Q</strong></p><p>Amazon Q is AWS’s generative AI assistant for business users.</p><p>It can answer questions using organizational data, summarize information, assist with documentation, and improve productivity across different business functions.</p><p><strong>DevOps relevance</strong></p><p>Teams can quickly search operational documentation, deployment guides, incident reports, and internal knowledge bases without manually browsing multiple systems.</p><p><strong>11. Amazon Q Developer</strong></p><p>Amazon Q Developer is specifically designed for software developers and DevOps engineers.</p><p>It assists with:</p><ul><li>Writing code</li><li>Explaining code</li><li>Generating unit tests</li><li>Troubleshooting errors</li><li>Infrastructure as Code</li><li>AWS resource recommendations</li><li>Security improvements</li></ul><p><strong>Why it matters</strong></p><p>A DevOps engineer working with Terraform, CloudFormation, Docker, Kubernetes, or CI/CD pipelines can use Amazon Q Developer to write infrastructure code faster, troubleshoot deployment failures, understand unfamiliar codebases, and improve operational efficiency. Rather than replacing engineers, it acts as an intelligent coding assistant that helps reduce repetitive work.</p><p><strong>12. Amazon Bedrock</strong></p><p>Amazon Bedrock provides access to multiple foundation models from Amazon and leading AI companies through a fully managed service.</p><p>Developers can build generative AI applications without managing the underlying infrastructure.</p><p><strong>Typical use cases</strong></p><ul><li>Chatbots</li><li>Content generation</li><li>Document summarization</li><li>AI assistants</li><li>Question-answering systems</li></ul><p><strong>DevOps relevance</strong></p><p>DevOps engineers automate deployments of Bedrock-powered applications, manage security, monitor performance, and integrate foundation models into production environments using CI/CD pipelines.</p><p><strong>AWS Machine Learning Services</strong></p><p><strong>13. Amazon SageMaker</strong></p><p>Amazon SageMaker is AWS’s flagship machine learning platform.</p><p>It enables developers and data scientists to:</p><ul><li>Prepare data</li><li>Build ML models</li><li>Train models</li><li>Deploy models</li><li>Monitor model performance</li></ul><p>All within one managed environment.</p><p><strong>Why DevOps engineers should care</strong></p><p>Once a machine learning model is ready, someone has to deploy it, automate updates, secure endpoints, monitor performance, and maintain availability.</p><p>This is where DevOps plays a critical role through practices commonly known as MLOps (Machine Learning Operations).</p><p><strong>14. Amazon SageMaker JumpStart</strong></p><p>SageMaker JumpStart provides pre-trained models, solution templates, and notebooks that help teams begin ML projects quickly.</p><p>Instead of building everything from scratch, organizations can customize existing models for their own use cases.</p><p><strong>DevOps relevance</strong></p><p>JumpStart reduces deployment time. DevOps teams can automate model deployment through CI/CD pipelines while maintaining consistent environments across development, testing, and production.</p><p><strong>15. AWS DeepRacer</strong></p><p>AWS DeepRacer is an educational platform designed to teach Reinforcement Learning.</p><p>Users train autonomous race cars that continuously improve by learning from rewards and penalties.</p><p><strong>Why it matters</strong></p><p>DeepRacer transforms an advanced machine learning concept into a practical, hands-on learning experience.</p><p>For anyone interested in AI, it is one of the most engaging ways to understand how reinforcement learning works.</p><p><strong>Why Should DevOps Engineers Learn These Services?</strong></p><p>Traditional DevOps focused primarily on infrastructure automation, CI/CD, monitoring, containers, Kubernetes, and cloud provisioning.</p><p>Today’s cloud landscape is evolving rapidly.</p><p>Modern DevOps engineers are increasingly expected to support AI-powered applications alongside traditional workloads.</p><p>That means understanding how to:</p><ul><li>Deploy AI applications reliably</li><li>Build automated CI/CD pipelines for AI services</li><li>Secure AI workloads and APIs</li><li>Monitor model endpoints and application performance</li><li>Manage infrastructure with Terraform or CloudFormation</li><li>Scale AI services efficiently</li><li>Control costs through automation</li><li>Implement observability and incident response for AI-powered systems</li></ul><p>These responsibilities have given rise to <strong>MLOps</strong>, which extends DevOps principles into machine learning by applying automation, version control, testing, deployment, monitoring, and governance to ML systems.</p><p>As organizations continue adopting AI, engineers who understand both cloud infrastructure and intelligent services will be in high demand.</p><p><strong>To Conclude</strong></p><p>Cloud computing is entering a new era where infrastructure, automation, Artificial Intelligence, and Machine Learning are becoming deeply interconnected.</p><p>You do not need to become a data scientist to remain relevant.</p><p>However, understanding what these AWS services do, where they fit into an architecture, and how to deploy and operate them will make you a stronger Cloud or DevOps Engineer.</p><p>The future belongs to engineers who can build reliable infrastructure <strong>and</strong> confidently support intelligent applications running on it.</p><p><strong>Which of these AWS AI or Machine Learning services have you explored, and which one are you planning to learn next? Let’s discuss in the comments.</strong></p><p>#AWS #CloudComputing #DevOps #CloudEngineering #ArtificialIntelligence #MachineLearning #MLOps #AmazonBedrock #AmazonQ #SageMaker #AWSCloud #CloudNative #ContinuousLearning</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d1ccec23994c" width="1" height="1" alt=""><hr><p><a href="https://awstip.com/beyond-ec2-and-s3-15-aws-ai-and-machine-learning-services-every-cloud-devops-engineer-should-d1ccec23994c">Beyond EC2 and S3: 15 AWS AI and Machine Learning Services Every Cloud &amp; DevOps Engineer Should…</a> was originally published in <a href="https://awstip.com/">AWS Tip</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Coding Tools Broke Your CI/CD Pipeline. Here’s How to Fix It]]></title>
            <link>https://awstip.com/ai-coding-tools-broke-your-ci-cd-pipeline-heres-how-to-fix-it-b6c6780c5506?source=rss-609565ed0c73------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6c6780c5506</guid>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <dc:creator><![CDATA[Ajah Ijeoma]]></dc:creator>
            <pubDate>Sun, 02 Aug 2026 21:21:01 GMT</pubDate>
            <atom:updated>2026-08-02T21:21:01.399Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qI_gfuU3NXzryxuIX3Hthg.png" /><figcaption>AI code overwhelming a CI_CD pipeline gate.</figcaption></figure><p>A few months ago, a friend who leads platform engineering at a mid-sized fintech told me something that stuck with me. His team hadn’t hired anyone new in over a year, yet their deployment volume had tripled. Nobody on the team was working more hours. Nobody had suddenly become three times more productive through sheer effort. The answer was simpler and, in hindsight, obvious: half his engineers were now writing code with Claude and Cursor doing the heavy lifting, and the other half were quietly doing the same without admitting it in standup.</p><p>That conversation is the reason I wanted to write this piece. Because what happened to his team is happening everywhere, quietly, and most engineering organizations have not caught up to it. We spent the last decade building CI/CD pipelines around a very specific assumption: that a human being sits down, writes some code over the course of an hour or a day, and then pushes it. That assumption is now false for a growing share of commits, and the infrastructure we built on top of it is starting to crack under the weight of a workflow it was never designed for.</p><p><strong>The Pace Problem Nobody Planned For</strong></p><p>Here is the uncomfortable part. AI coding assistants did not make engineers write better code. They made engineers write more code, faster, and with far less friction between having an idea and having something committable. A task that used to take half a day of thinking, typing, and debugging can now take twenty minutes. Multiply that across a team, and you get a genuine step change in throughput.</p><p>The numbers back this up in ways that would have sounded absurd two years ago. OpenAI reportedly runs somewhere in the neighborhood of a million builds a day internally. A startup called Hermetic, barely three weeks old at the time it was mentioned publicly, was already handling half a million of those builds. Whatever you think about the specifics of that example, the direction is unmistakable. Build volume is exploding, and it is exploding specifically because the bottleneck of writing code has been partially removed.</p><p>Most CI/CD systems were not built for this. They were built for a world where a pull request represented hours of human thought, where a handful of pipeline runs per engineer per day was the norm, and where the queue rarely backed up because the rate of code production was naturally throttled by how fast a person can think and type. Take that throttle away, and everything downstream starts to strain. Build queues get longer. Test suites that used to run comfortably in the background now become the thing everyone is staring at, waiting on. Infrastructure costs for CI runners creep up in a way that finance starts asking questions about.</p><p><strong>Two Worlds Colliding</strong></p><p>There is a deeper issue here than just volume, though, and it is the one I think matters most. Engineers using AI tools today are effectively living in two different worlds that were never designed to talk to each other.</p><p>The first world is the experimentation world. This is where an engineer, or increasingly an AI agent acting semi-autonomously on an engineer’s behalf, tries something, sees if it works, throws it away if it doesn’t, and tries again. This loop wants to be fast. It wants near instant feedback. Waiting five minutes for a full CI run just to find out a one-line change broke a test is painful when you’re iterating at the speed AI tools now allow. So naturally, people start looking for shortcuts. Push straight to a preview environment. Skip a few checks “just for now.” Let the agent deploy directly to a sandbox without going through the usual gates.</p><p>The second world is the production world, the one built around safety, auditability, and the assumption that every change has been reviewed by a human who understands the consequences. This world moves deliberately and for good reason. It has checks because checks catch real problems. It has approval gates because someone, somewhere, learned the hard way what happens without them.</p><p>The trouble is that the boundary between these two worlds is getting blurry fast. When an AI agent can go from a plain English instruction to a running deployment in minutes, the line between “just experimenting” and “actually shipping to something real” starts to disappear. I’ve watched teams accidentally let a fast, loose experimentation habit creep into paths that touch production, not because anyone decided that was fine, but because nobody drew a clear enough line to stop it from happening gradually.</p><p><strong>What Breaks First</strong></p><p>If you’re running a platform or DevOps team right now, there are a few places where this pressure shows up before anywhere else, and it’s worth knowing what to watch for.</p><p>Build and test infrastructure is usually the first casualty. Queue times start creeping up. What used to be a two minute wait for a pipeline slot becomes fifteen. Engineers, understandably impatient, start finding workarounds, which usually means skipping steps rather than waiting.</p><p>Audit and traceability come apart next, and this one is sneakier because it doesn’t show up immediately. When a human writes and commits code, there’s a reasonably clear story of who did what and why, even if it’s just a commit message and a linked ticket. When an AI agent is generating and pushing changes on someone’s behalf, that story gets murkier. Was this deploy authorized by the engineer, or did the agent take an action the engineer didn’t fully review? Six months from now, when you’re trying to figure out why a particular change went out, that ambiguity is going to cost someone a very bad afternoon.</p><p>Cost visibility is the third pressure point, and it tends to sneak up on finance before it sneaks up on engineering. Ten times the deployment frequency does not mean ten times the value delivered. It can just as easily mean ten times the compute burned on iterations that never should have made it past a first draft. Without any kind of governance on how agents consume build and deploy resources, the bill shows up as a surprise rather than a plan.</p><p><strong>Rethinking the Pipeline, Not Just Scaling It</strong></p><p>The instinctive fix here is to just throw more compute at the problem. Bigger runners, more parallel jobs, a fatter budget for CI infrastructure. That helps, briefly, but it treats a structural problem as if it were a capacity problem, and it isn’t. You can’t out-spend your way past a pipeline that was designed around a different pace of work.</p><p>What actually helps is rethinking the shape of the pipeline itself, and specifically, giving the experimentation world and the production world separate paths that both feed into the same source of truth.</p><p>Picture it as three lanes rather than one. A fast lane for genuine experimentation, where an agent or engineer can iterate quickly against a lightweight, disposable environment with minimal gatekeeping, because nothing there is real yet. A staging lane that runs a fuller set of checks once something looks promising and is being considered for a real merge. And a production lane that keeps every gate it currently has, plus a clear, non-negotiable requirement that a human signs off before anything crosses into it, regardless of whether a person or an agent wrote the underlying change.</p><p>The part that ties this together, and that a lot of teams skip because it feels like extra work, is a unified audit trail across all three lanes. Every action needs an identity attached to it, and increasingly that means agent identities as well as human ones. Who or what triggered this build. What model or tool generated this change. Who reviewed it before it moved to the next lane. This isn’t bureaucracy for its own sake. It’s the thing that lets you answer, six months later, exactly how a specific change ended up in production, and it’s the thing regulators and security teams are going to start asking about whether you’re ready for it or not.</p><p>Role based access matters more here than it used to as well. An agent operating in the fast lane should have permissions scoped tightly to that lane. It should not be able to reach into production simply because a human granted it broad access once and forgot to revisit that decision. The blast radius of a misbehaving or overly eager agent needs a hard ceiling, and that ceiling has to be enforced by the platform, not by hoping everyone remembers to be careful.</p><p><strong>The Human Question Underneath All This</strong></p><p>There’s a temptation to frame this whole shift purely as a tooling and infrastructure problem, something you solve by buying the right platform or configuring the right runner limits. I don’t think that’s the whole picture. Underneath the technical fixes sits a more human question: as more of this loop runs on autopilot, where does human judgment still need to have the final say?</p><p>Speed is not inherently dangerous. What’s dangerous is speed without a corresponding increase in the checks that catch mistakes before they matter. An engineer who ships ten times more code with AI assistance but reviews every single one of those changes with the same care they used to bring to one change a day is in a fundamentally different position than an engineer who ships ten times more code and reviews none of it more carefully than before, trusting the tool to have gotten it right.</p><p>I don’t think most teams have consciously chosen one of those paths over the other. It’s happened by accident, shaped by whichever habits were already in place before the tools got fast enough to matter. That’s the actual risk here, not that AI tools write bad code, but that the review and governance layer around them hasn’t caught up to how much trust we’ve quietly started extending to their output.</p><p><strong>Where This Leaves Us</strong></p><p>None of this means slowing down. The productivity gains from AI assisted development are real, and no engineering ‘leader’ I’ve talked to wants to give them back. But there is a difference between fast and reckless, and the gap between the two is exactly where a well designed pipeline earns its keep.</p><p>If your build queues are getting longer, if nobody can quite explain how a particular change made it to production, or if your cloud bill has a line item that’s grown suspiciously in step with your team’s AI tool adoption, that’s not a sign you need more infrastructure. It’s a sign the shape of your pipeline hasn’t caught up to the shape of the work happening inside it.</p><p>The teams that get ahead of this now, by drawing clear lanes, keeping audit trails honest, and scoping agent permissions deliberately rather than by default, are going to be in a much better position a year from now than the ones still trying to patch the problem with bigger servers.</p><p>There’s also a cultural piece to this that rarely makes it into the technical writeups. Teams that have handled this transition well tend to talk about it openly instead of pretending nothing has changed. They’ve had the conversation about which parts of the pipeline are fine to move fast in and which parts absolutely are not, and they’ve written that decision down somewhere everyone can see it, rather than leaving it as an unspoken assumption that eventually gets tested the hard way. The teams that struggle are usually the ones where every engineer has quietly formed their own private opinion about how much they trust the tooling, with no shared baseline and no forum where those opinions get reconciled before something goes wrong.</p><p>It also helps to treat this as a moving target rather than a problem you solve once and move on from. The tools themselves are changing quickly. What an AI coding assistant could reliably do a year ago is different from what it can do now, and that gap is only going to widen. A pipeline structure that felt generous and safe six months ago might already be too permissive today, simply because the agents operating within it have gotten more capable and more autonomous in that time. Revisiting the lanes, the permissions, and the audit setup on a regular cadence, rather than treating them as a one time setup task, is probably the single most underrated habit a platform team can build right now.</p><p>How is your team handling the jump in deployment volume from AI assisted coding? I’d genuinely like to know whether this is showing up the same way for you, or whether you’re seeing a different failure mode entirely.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6c6780c5506" width="1" height="1" alt=""><hr><p><a href="https://awstip.com/ai-coding-tools-broke-your-ci-cd-pipeline-heres-how-to-fix-it-b6c6780c5506">AI Coding Tools Broke Your CI/CD Pipeline. Here’s How to Fix It</a> was originally published in <a href="https://awstip.com/">AWS Tip</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Most Of Your DevOps Stack Exists Because Someone Else Failed First]]></title>
            <link>https://awstip.com/most-of-your-devops-stack-exists-because-someone-else-failed-first-24d3b2d7570a?source=rss-609565ed0c73------2</link>
            <guid isPermaLink="false">https://medium.com/p/24d3b2d7570a</guid>
            <category><![CDATA[devops-tool]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[operating-systems]]></category>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Ajah Ijeoma]]></dc:creator>
            <pubDate>Sun, 19 Jul 2026 20:51:01 GMT</pubDate>
            <atom:updated>2026-07-19T20:51:01.573Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*1iMe_PT2CoZtWuxkbezCJg.png" /><figcaption>DevOps Toolbox</figcaption></figure><p>Nobody tells junior engineers this part. Every tool in a modern DevOps stack is a tombstone. It marks the spot where a team got burned badly enough that an entire industry decided never to repeat that mistake again. Terraform exists because manual infrastructure changes destroyed production environments. Docker exists because &quot;it works on my machine&quot; cost companies real money. Kubernetes exists because Docker alone was not enough once anyone had more than a handful of containers to manage.</p><p>Here is the uncomfortable part. Most engineers learn these tools backwards. They install Kubernetes before they understand what problem it solves. They write Terraform before they have ever felt the pain of manual infrastructure drift. That is like handing someone a fire extinguisher and never telling them what a fire looks like. They will hold the tool and still not understand why it matters.</p><p>This piece goes category by category through the DevOps toolchain, picks the one or two tools that matter most in each, and explains the actual failure each tool was built to fix. Not the marketing description. The failure. If you are learning this stack, read this before you touch the tools, not after.</p><p><strong>Operating Systems: The Layer Everyone Skips (Linux, Windows Os, MacOs)</strong></p><p>Every container, every pipeline, every cloud instance sits on top of an operating system, and yet most DevOps learning paths treat the OS layer as a formality instead of a foundation.</p><p><strong>Linux</strong> is the one that matters most. Depending on the survey, somewhere around ninety percent of cloud workloads and the overwhelming majority of container base images run on some Linux distribution, whether that is Ubuntu, Debian, RHEL, CentOS successor distributions, or Alpine for lightweight containers. Before Linux distributions matured and standardized, running production infrastructure meant dealing with proprietary Unix variants that were expensive, inconsistent, and often locked to specific hardware vendors. Linux solved that by being free, portable, and eventually the default target for every piece of infrastructure tooling built afterward. Today it solves something else too: predictability. A container built on Alpine behaves the same way on a laptop, a CI runner, and a production cluster, because the kernel underneath is the same family of software everywhere.</p><p><strong>MacOS</strong> deserves its own mention here, not because it runs production servers, but because it is where an enormous share of DevOps engineers actually write and test their code before anything reaches Linux. macOS is a Unix-like system under the hood, which means shell scripts, package managers like Homebrew, and container tooling like Docker Desktop behave close enough to Linux that local development feels native. The problem it solves is friction between a developer&#39;s daily machine and the production target. The problem it does not solve, and this trips people up constantly, is that &quot;close enough to Linux&quot; is not the same as identical to Linux, which is exactly why containerization became necessary in the first place.</p><p>What a newbie should learn before anything else: basic Linux command line skills. Processes, file permissions, networking basics with tools like curl and netstat, and how systemd manages services. None of the tools further up this list make sense without this foundation. You cannot debug a failing container if you do not understand what a process and a file descriptor are.</p><p><strong>Infrastructure as Code: </strong>Terraform, Pulumi, AWS CloudFormation, Ansible, Chef, Puppet</p><p>Before infrastructure as code existed, provisioning a server meant someone logging into a cloud console or SSHing into a machine and making changes by hand. This worked fine until a team had more than one engineer touching infrastructure, at which point nobody could say with confidence what state production was actually in. Configuration drift became a constant, quiet source of outages. A firewall rule added manually in March and forgotten by June. A load balancer setting that only one person remembered changing.</p><p><strong>Terraform </strong>solved this by making infrastructure declarative. You describe the end state you want in configuration files, and Terraform figures out what needs to change to get there, then shows you a plan before applying it. That plan step is the actual innovation. It converts infrastructure changes from an act of faith into something reviewable, almost like a code review for your cloud environment. It currently solves version-controlled, auditable, repeatable infrastructure changes across almost every major cloud provider through a single consistent workflow.</p><p>What a newbie should learn concurrently: basic cloud provider concepts, meaning what a virtual machine, a subnet, and an IAM role actually are on at least one platform. Terraform is a language for describing cloud resources. Without knowing what those resources are, the language is just syntax.</p><p><strong>Containers and Orchestration: </strong>Docker, Kubernetes, Podman, containerd, Docker Compose</p><p><strong>Docker</strong> answered a problem every engineer has lived through. An application runs perfectly on a developer&#39;s laptop and then breaks in staging because of a mismatched library version, a missing environment variable, or a different operating system patch level entirely. Docker packages an application together with everything it needs to run, the runtime, the libraries, the configuration, into a single portable image. That image runs the same way regardless of where it is deployed. The problem it solves is environmental inconsistency, full stop.</p><p>But Docker alone does not answer what happens when you have fifty containers across ten machines and one of them crashes at three in the morning. That is where <strong>Kubernetes </strong>comes in. It watches your containers, restarts the ones that fail, distributes them across available machines, and scales them up or down based on load, all without a human needing to intervene at three in the morning. It currently solves the operational overhead of running containers at any meaningful scale, though it is worth being honest that Kubernetes introduces a real amount of complexity in exchange for that automation, which is why it is frequently overused by teams who do not actually have the scale to justify it.</p><p>What a newbie should learn before Kubernetes: Docker itself, thoroughly. Understand images, layers, volumes, and networking at the single-container level first. Jumping straight to Kubernetes without this foundation is the single most common reason engineers feel lost in their first few months with it.</p><p><strong>CI/CD: </strong>Jenkins, GitHub Actions, GitLab CI, CircleCI, Argo CD, Spinnaker, Tekton</p><p>Before continuous integration existed, teams merged code changes infrequently, sometimes only at the end of a sprint, and the resulting merge conflicts and integration bugs could take days to untangle. The longer code sits unmerged, the more expensive it becomes to reconcile.</p><p><strong>Jenkins </strong>was one of the original tools that made automated builds and tests practical at scale, and it remains heavily used, particularly in older or highly customized enterprise environments, because of its enormous plugin ecosystem and flexibility.</p><p><strong>GitHub Actions </strong>solves the same core problem with a different philosophy, tying automation directly into the same platform where code already lives, with configuration as simple YAML files stored alongside the code itself. Both solve the same underlying issue: catching integration problems within minutes of a code change instead of days later, and automating the path from a code commit to a deployed artifact.</p><p>What a newbie should learn concurrently: basic Git workflows, particularly branching and pull requests, since CI/CD pipelines are triggered by and built around those events. You cannot reason about a pipeline if you do not understand the events that fire it.</p><p><strong>Monitoring and Observability: </strong>Prometheus, Grafana, Datadog, New Relic, OpenTelemetry, ELK Stack (Elasticsearch, Logstash, Kibana)</p><p>Early infrastructure monitoring often meant checking a server was up or down, with little visibility into why an application was slow or what was happening moments before a crash. Teams were frequently debugging blind, reconstructing incidents after the fact from scattered log files.</p><p><strong>Prometheus </strong>solved this by continuously scraping and storing time series metrics from applications and infrastructure, then allowing engineers to query that data and set alerts based on real conditions, like error rates climbing or memory usage trending upward before it becomes critical.</p><p><strong>Grafana</strong> pairs with it to turn that raw data into dashboards that make patterns visible at a glance instead of buried in numbers. Together they currently solve the problem of understanding system behavior in real time rather than reconstructing it after an incident.</p><p>What a newbie should learn before this: what metrics, logs, and traces each actually represent and how they differ. Observability tooling is only useful once you know what question you are trying to answer with it.</p><p><strong>Secrets and Configuration Management: </strong>HashiCorp Vault, Consul, etcd, AWS Secrets Manager</p><p>For years, credentials and API keys ended up hardcoded in application code or sitting in plaintext configuration files, sometimes even committed to version control by accident. This has caused some of the more expensive security incidents in recent memory.</p><p><strong>HashiCorp Vault </strong>solved this by centralizing secrets storage with tight access controls, encryption, and audit logging, along with the ability to issue short-lived, automatically expiring credentials instead of static ones that live forever. It currently solves the problem of secrets sprawl, where sensitive values end up duplicated across a dozen systems with no single source of truth or accountability.</p><p>What a newbie should learn concurrently: basic encryption concepts and the principle of least privilege access, since Vault is only as effective as the access policies configured around it.</p><p><strong>Service Mesh and Networking</strong>: Istio, Linkerd, Envoy, NGINX, Traefik</p><p>As applications split into many small services instead of one large one, routing traffic between those services reliably, securely, and with visibility became its own significant problem, one that used to require custom networking code scattered across every service.</p><p><strong>NGINX </strong>solved the earlier version of this problem as a reverse proxy and load balancer, distributing incoming traffic and handling basic routing rules reliably for years before service meshes existed. Istio solves a more advanced version of the same category of problem, handling service-to-service traffic within a cluster, adding encryption between services automatically, and giving engineers detailed visibility into how requests flow through a distributed system without changing any application code.</p><p>What a newbie should learn before Istio specifically: basic networking concepts, ports, DNS, and load balancing, along with NGINX itself as a simpler entry point into the same domain.</p><p><strong>Cloud Platforms</strong>: AWS, Azure, GCP, Oracle Cloud, IBM Cloud and DigitalOcean</p><p>Before public cloud existed, standing up infrastructure meant buying physical servers, waiting weeks for delivery, and paying for capacity whether you used it or not. That upfront cost and lead time killed a lot of ideas before they ever got tested.</p><p><strong>AWS </strong>solved this first at real scale, letting anyone provision compute and storage in minutes and pay only for what they used, and it remains the largest platform by market share. Microsoft Azure and Google Cloud followed with strong offerings of their own, Azure benefiting heavily from existing enterprise relationships built around Windows and Active Directory, and Google Cloud carrying a reputation for strength in data and machine learning workloads.</p><p>The two platforms that get skipped in most conversations deserve real mention. <strong>Oracle </strong>Cloud Infrastructure has built a genuine niche in database-heavy enterprise workloads, particularly for companies already running Oracle databases, offering competitive pricing on compute and networking that has pulled some cost-sensitive workloads away from the bigger three. <strong>IBM </strong>Cloud carries particular weight in regulated industries like banking and insurance, and through its ownership of Red Hat, it has a strong hybrid cloud story built around OpenShift for companies that cannot or will not move everything into a single public cloud.</p><p>What a newbie should learn concurrently: pick one cloud provider and learn its core services deeply, compute, storage, networking, and identity access management, rather than spreading thin across all five early on. The concepts transfer between providers far more easily than the specific tooling does.</p><p><strong>Version Control and Collaboration</strong>: Git, GitHub, GitLab, Bitbucket</p><p>Before distributed version control, teams often worked with centralized systems where a single point of failure could lock an entire team out of their own code history, and merging changes from multiple people was fragile and slow.</p><p><strong>Git </strong>solved this by giving every developer a full copy of the project history locally, making branching and merging fast and largely conflict-tolerant.</p><p><strong>GitHub </strong>built a collaboration layer on top of Git, adding pull requests, code review workflows, and integrations that turned version control into a social, auditable process rather than a purely mechanical one. Together they currently solve both the technical problem of tracking changes and the human problem of reviewing and discussing those changes before they ship.</p><p>What a newbie should learn before anything else on this entire list: Git. It is genuinely the prerequisite for every other category here, since nearly all of them are triggered by or built around code changes tracked in version control.</p><p><strong>Package and Artifact Management</strong>: Artifactory, Nexus, Helm (for Kubernetes packages)</p><p>As Kubernetes deployments grew more complex, managing dozens of YAML files by hand for a single application became unmanageable, and reusing configuration across environments meant a lot of manual copying and error-prone editing.</p><p><strong>Helm </strong>solved this by packaging Kubernetes resources into reusable templates called charts, with variables that can change per environment without duplicating the underlying configuration. It currently solves the problem of deploying complex applications consistently across development, staging, and production without hand editing dozens of files each time.</p><p>What a newbie should learn before Helm: Kubernetes YAML manifests themselves, written by hand at least a few times, so the templating Helm provides is understood as a convenience rather than a mystery.</p><p><strong>Incident Management</strong>: PagerDuty, Opsgenie, Statuspage</p><p>Before dedicated incident tooling, on call rotations were often managed through spreadsheets and phone trees, and critical alerts sometimes went unnoticed for hours because there was no reliable escalation path when the first responder did not answer.</p><p><strong>PagerDuty </strong>solved this by automating escalation policies, routing alerts to the right person based on schedules, and escalating automatically if nobody acknowledges within a set time window. It currently solves the reliability problem of making sure a critical alert actually reaches a human being who can act on it, not just the technical problem of detecting that something is wrong.</p><p>What a newbie should learn concurrently: the monitoring tools that feed alerts into PagerDuty in the first place, since an incident management tool is only as good as the signal quality coming into it.</p><h3>The Real Lesson Here</h3><p>Every tool on this list was somebody’s answer to a problem that hurt enough to fix. The mistake most newcomers make is trying to learn the tool without ever understanding the pain that created it. Learn the failure first. The tool will make far more sense once you do, and you will be much better equipped to judge when a tool from this list is actually solving your problem, versus when it is just adding complexity you do not need yet.</p><p>If you are starting from zero, the order that tends to work best is Linux fundamentals first, then Git, then Docker, then a single cloud provider, then Terraform, then CI/CD, then Kubernetes, and only after all of that, the more specialized tools like service mesh, secrets management, and dedicated observability stacks. Skipping ahead is how people end up holding a fire extinguisher with no idea what a fire looks like.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=24d3b2d7570a" width="1" height="1" alt=""><hr><p><a href="https://awstip.com/most-of-your-devops-stack-exists-because-someone-else-failed-first-24d3b2d7570a">Most Of Your DevOps Stack Exists Because Someone Else Failed First</a> was originally published in <a href="https://awstip.com/">AWS Tip</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Agentic AI Will Not Replace DevOps Engineers. It Will Replace the Ones Who Do Not Understand It.]]></title>
            <link>https://awstip.com/agentic-ai-will-not-replace-devops-engineers-it-will-replace-the-ones-who-do-not-understand-it-39f78599e0df?source=rss-609565ed0c73------2</link>
            <guid isPermaLink="false">https://medium.com/p/39f78599e0df</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[devops-engineer]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Ajah Ijeoma]]></dc:creator>
            <pubDate>Sun, 05 Jul 2026 20:46:00 GMT</pubDate>
            <atom:updated>2026-07-05T20:46:00.748Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tZkVe4BBi1_ZWgqEfjKhlQ.png" /></figure><p>There is a quiet shift happening inside the world of software engineering. It is not loud. It is not arriving in a press release. It is arriving in pipelines that are beginning to think, in incident response systems that are beginning to act, and in codebases that are beginning to fix themselves. Agentic AI is not the next version of the chatbot. It is something categorically different and engineers who recognise that early will operate at a level the rest will struggle to reach.</p><p>This article is for the DevOps engineer, the cloud practitioner, the SRE, and the infrastructure architect who wants to understand not just what Agentic AI is, but how it works, where it is headed, and which tools are already building it.</p><p><strong>What Agentic AI Actually Is</strong></p><p>Most people encountered AI as a responder. You ask; it answers. That is the chatbot model, a single-turn exchange where the model processes a prompt and returns a completion. Useful, but fundamentally passive.</p><p>Agentic AI operates on a different principle entirely. An AI agent is a system designed to pursue a goal. It does not simply respond to a single prompt; it reasons through a problem, breaks it into steps, uses tools to take action, evaluates the results, and loops — iterating until the task is complete or a decision point requires human input.</p><p><strong>The architecture has four core elements:</strong></p><p><strong><em>Reasoning:</em></strong> The agent analyses a situation and determines what needs to happen. It reads context, identifies gaps, and plans a sequence of actions before moving.</p><p><strong><em>Tool use: </em></strong>Agents are not confined to text outputs. They can call APIs, write and execute code, query databases, browse the web, trigger deployments, open tickets, and interact with virtually any system they are given access to. The tool layer is what makes an agent operationally real.</p><p><strong><em>Memory: </em></strong>Agents maintain context across a session. More advanced implementations maintain long-term memory, persisted state from prior runs so the agent learns from experience rather than starting fresh every time.</p><p><strong><em>Action loops:</em></strong> Unlike a chatbot that terminates after one response, an agent continues. It checks whether its action achieved the desired outcome. If not, it adjusts and tries again. This loop is the defining behaviour that separates an agent from a simple model call.</p><p><strong>What This Looks Like Inside a DevOps Pipeline</strong></p><p>Agentic AI is not a theoretical future for DevOps. It is an operational present for teams that are paying attention. Here is what it looks like in practice.</p><p>An agent monitors a production environment in real time. It detects a spike in error rates, runs automated diagnostics, identifies that a recent deployment introduced a memory leak, rolls back to the last stable version, scales the affected service to absorb load while the rollback completes, and files a structured post-incident report all without paging a single engineer.</p><p>A separate agent watches a Kubernetes cluster. It identifies resource contention across multiple pods, computes the optimal scaling configuration, adjusts resource requests and limits, and documents the change with a timestamp and a rationale.</p><p>Another agent sits in the CI/CD pipeline as an autonomous reviewer. It reads every pull request, checks for security vulnerabilities using static analysis tools, flags issues with suggested fixes, verifies test coverage thresholds, and only surfaces the PR to a human reviewer when it meets a defined quality bar.</p><p>These are not aspirational examples. They are the natural outcome of connecting a capable reasoning model to the right toolset with a well-defined goal.</p><p><strong>The Ecosystem: Tools and Frameworks Building the Agentic Layer</strong></p><p>The tooling landscape has matured significantly. Below is a comprehensive map of the frameworks and platforms that matter — including those covered in the foundational LinkedIn post and the ones now expanding the frontier.</p><p><strong><em>LangGraph </em></strong>(<strong>LangChain</strong>): Stateful, multi-step agent workflows built on a graph model. LangGraph supports conditional logic, looping, branching, and human-in-the-loop checkpoints. It is the go-to framework for complex, stateful agent pipelines.</p><p><strong><em>CrewAI: </em></strong>Role-based multi-agent collaboration. You define agents with specific roles — analyst, coder, reviewer, manager — and CrewAI orchestrates how they communicate and hand off work to each other. Excellent for simulating a team dynamic.</p><p><strong><em>AutoGen </em></strong>(<strong>Microsoft</strong>): A conversational multi-agent framework where agents solve problems through structured, iterative dialogue. Particularly strong for code generation, debugging, and reasoning tasks that benefit from back-and-forth deliberation.</p><p><strong><em>OpenAI </em>Agents SDK: </strong>The official framework for building agents powered by GPT-4o-class models. Supports tool use, memory, handoffs between agents, and structured output. It is the cleanest path to production if you are building on the OpenAI stack.</p><p><strong><em>Amazon </em>Bedrock Agents: </strong>Fully managed agent deployment on AWS. Bedrock Agents connects to foundation models, defines action groups, integrates with Lambda and Knowledgebases, and handles the orchestration layer natively within the AWS ecosystem — making it the natural choice for teams already on AWS.</p><p><strong><em>Semantic </em>Kernel </strong>(<strong>Microsoft</strong>): An enterprise-grade AI orchestration SDK for .NET and Python. It treats AI capabilities as pluggable functions inside a kernel, making it well-suited for large organisations that need AI agents embedded in existing software systems.</p><p><strong>Dify: </strong>An open-source LLM application platform that allows teams to build, deploy, and manage agents visually. It is self-hostable, supports RAG pipelines, and makes agent development accessible without deep framework expertise.</p><p><strong><em>Claude Code </em></strong>(<strong>Anthropic</strong>): An autonomous coding agent that reads repositories, runs terminal commands, writes and edits code, and completes multi-step engineering tasks end to end. It is particularly powerful for refactoring, debugging, and implementing features from a specification.</p><p><strong><em>Google Agent </em>Development Kit </strong>(<strong>ADK</strong>): Google’s open-source framework, released in 2025, for building production-grade multi-agent systems. ADK is model-agnostic, supports hierarchical agent architectures, and integrates natively with Google Cloud infrastructure and Vertex AI. It is rapidly becoming a serious enterprise option.</p><p><strong><em>Vertex </em>AI Agent Builder: </strong>Google Cloud’s managed platform for deploying agents with built-in grounding, retrieval-augmented generation, and integration across Google Workspace, BigQuery, and Cloud Run. Strong choice for teams deep in the Google Cloud ecosystem.</p><p><strong>Phidata: </strong>A Python-native framework for building agents with persistent memory, knowledge bases, and a clean interface for tool registration. Phidata is developer-first and opinionated in a way that makes rapid prototyping fast without sacrificing production readiness.</p><p><strong>MetaGPT: </strong>A multi-agent framework that models software development as a structured workflow with assigned roles: product manager, architect, engineer, QA. Given a single requirement, MetaGPT can generate a product requirements document, a system design, code, and a test suite autonomously.</p><p>SuperAGI: An open-source framework for building autonomous AI agents at scale. It supports concurrent agent execution, a visual workflow builder, a marketplace of pre-built tools, and a cloud-hosted deployment layer.</p><p><strong><em>Flowise: </em></strong>An open-source, drag-and-drop builder for LLM-powered applications and agents. It sits on top of LangChain and makes it possible to build agent pipelines visually, export them as APIs, and deploy them without writing orchestration code from scratch.</p><p><strong><em>TaskWeaver </em></strong>(<strong>Microsoft</strong>): A code-first agent framework designed specifically for data analytics workflows. TaskWeaver converts user requests into executable Python code, runs the code in a sandboxed environment, and returns structured results — making it ideal for data engineering and analysis pipelines.</p><p>**<strong><em>E2B </em></strong>(<strong>Engineering to Build</strong>): A sandboxed cloud environment specifically designed for AI agents that write and execute code. E2B provides isolated, secure runtime environments so agents can run arbitrary code safely, without the risk of compromising the host system.</p><p><strong>The Real Shift: Where Human Expertise Moves</strong></p><p>It would be a mistake to read this landscape as a threat to engineering talent. It is a redefinition of where engineering talent creates value.</p><p>DevOps has always been fundamentally about removing friction, the friction between writing code and running it reliably in production. Agentic AI extends that mission. It removes the friction between detecting a problem and resolving it, between a deployment decision and its execution, between a security scan and a remediation action.</p><p>The human role does not disappear. It moves upstream. The engineers who will thrive are those who design the agents, define the guardrails, construct the tool layers, and review the decisions that carry too much consequence for an automated system to make alone. The ceiling for what a single engineer can operate and maintain rises significantly. The floor — for those who choose not to engage — drops.</p><p><strong>The Time to Engage Is Now</strong></p><p>The tools are here. The frameworks are maturing. The teams that build fluency in Agentic AI today will not just be more productive they will be operating in an entirely different category within two years.</p><p>The question is no longer whether Agentic AI will change DevOps. The question is which side of that change you will be on when it fully arrives.</p><p>Which of these frameworks have you explored? And where, in your current workflow, do you see the highest-value opportunity for an agent to take the wheel?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=39f78599e0df" width="1" height="1" alt=""><hr><p><a href="https://awstip.com/agentic-ai-will-not-replace-devops-engineers-it-will-replace-the-ones-who-do-not-understand-it-39f78599e0df">Agentic AI Will Not Replace DevOps Engineers. It Will Replace the Ones Who Do Not Understand It.</a> was originally published in <a href="https://awstip.com/">AWS Tip</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Azure DevOps: the stages to mastery]]></title>
            <link>https://medium.com/@Aijay27/azure-devops-the-stages-to-mastery-930e5ce6ff60?source=rss-609565ed0c73------2</link>
            <guid isPermaLink="false">https://medium.com/p/930e5ce6ff60</guid>
            <category><![CDATA[microsoft-azure]]></category>
            <category><![CDATA[azure-devops]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <dc:creator><![CDATA[Ajah Ijeoma]]></dc:creator>
            <pubDate>Mon, 04 May 2026 23:55:05 GMT</pubDate>
            <atom:updated>2026-05-04T23:55:05.166Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SQ3diL14K91W71F_oVGcJQ.png" /><figcaption><strong>Azure DevOps Repo.</strong></figcaption></figure><p>Azure DevOps is Microsoft’s integrated platform for planning, developing, building, testing, and deploying software. It includes Boards, Repos, Pipelines, Artifacts, and Test Plans. Use it for end-to-end traceability and faster, reliable delivery.</p><h3>Beginner: First Steps</h3><ol><li>Go to dev.azure.com. Sign in with Microsoft or GitHub account. Create an organization, then a project. Choose Agile, Scrum, Basic, or CMMI process.</li><li><strong>Boards</strong>: Create Epics &gt; Features &gt; User Stories/Tasks/Bugs. Use Kanban board to move items. Set up sprints and capacity. Add custom fields if needed.</li><li><strong>Repos</strong>: Create a Git repository (use Git, avoid TFVC for new projects). Clone locally. Commit, push, create branches. Link commits to work items with #ID.</li><li><strong>Pipelines</strong>: New pipeline &gt; select repo &gt; starter YAML. Basic example for .NET:</li></ol><p>YAML</p><pre>trigger:<br>- main</pre><pre>pool:<br>  vmImage: &#39;windows-latest&#39;</pre><pre>steps:<br>- task: UseDotNet@2<br>  inputs:<br>    versionSpec: &#39;8.x&#39;<br>- script: dotnet build<br>  displayName: &#39;Build&#39;</pre><p>Commit and watch it run. First success: code change triggers green build.</p><h3>Intermediate: Connected Workflow</h3><p><strong>Boards Deep Dive</strong></p><ul><li>Queries, charts, dashboards.</li><li>Link work items to PRs, commits, builds.</li><li>Area paths, iterations, tags, delivery plans.</li><li>Portfolio backlogs for large projects.</li></ul><p><strong>Repos</strong></p><ul><li>Branch policies: required reviewers, build validation, linked work items, merge strategies (squash, rebase).</li><li>Pull requests with threaded comments, suggestions.</li><li>Git LFS for large files.</li><li>Protected branches, code owners file.</li></ul><p><strong>Pipelines</strong> Move to YAML stored in repo. Multi-stage pipelines. Variables, variable groups, library secrets. Example multi-stage skeleton:</p><p>YAML</p><pre>trigger:<br>- main</pre><pre><br>stages:<br>- stage: Build<br>  jobs:<br>  - job: BuildJob<br>    pool: vmImage: &#39;ubuntu-latest&#39;<br>    steps:<br>    - script: echo Build</pre><pre>- stage: DeployDev<br>  dependsOn: Build<br>  condition: succeeded()<br>  jobs:<br>  - deployment: Deploy<br>    environment: dev<br>    pool: vmImage: &#39;ubuntu-latest&#39;<br>    strategy:<br>      runOnce:<br>        deploy:<br>          steps:<br>          - script: echo Deploy</pre><p><strong>Artifacts</strong> Publish packages (NuGet, npm, Maven, Python, Universal). Set up feeds. Use upstream sources for public registries. Version and promote packages.</p><p><strong>Test Plans</strong> Manual test cases, test suites, parameters. Exploratory testing. Link tests to requirements and pipelines. Publish test results from pipelines.</p><p>Connect the chain: work item → branch → PR → build → test → artifact → deploy.</p><h3>Advanced: Scale, Automate, Secure</h3><p><strong>Environments and Deployments</strong> Environments with approvals, checks (Azure Monitor gates, query gates). Deployment slots for App Service. Target AKS, VMs, on-prem via service connections. Use deployment jobs in YAML.</p><p><strong>Templates</strong> Reusable YAML templates (step, job, stage). Parameters for flexibility. Extend and include templates. Store in central repo for organization-wide use.</p><p><strong>Agents</strong> Microsoft-hosted (ubuntu-latest, windows-latest, macOS). Self-hosted for custom needs: legacy tools, GPU, compliance, large artifacts. Configure as service or interactive. Demands and capabilities. Scale with VMSS agents.</p><p><strong>IaC Integration</strong> Run Bicep, ARM, Terraform in pipelines. Store state in secure locations. Use tasks for validation and what-if. Scan IaC for security.</p><p><strong>Security &amp; Compliance</strong></p><ul><li>Secret scanning, dependency scanning.</li><li>Microsoft Defender for DevOps / GitHub Advanced Security integration.</li><li>Conditional access, RBAC at org/project/repo level.</li><li>Audit logs, retention policies.</li><li>Service connections with managed identities.</li><li>Pipeline approvals and environments for gates.</li></ul><p><strong>Analytics &amp; Reporting</strong> Widgets, Power BI integration. Track velocity, burndown, cumulative flow. Custom queries and OData feeds.</p><h3>Mastery: Elite Delivery</h3><p>Adopt trunk-based development. Short-lived branches or feature flags. Everything as code: pipelines, policies, infrastructure, dashboards.</p><p>Full CI/CD with quality gates: unit + integration + E2E + security + performance tests. Shift-left everything.</p><p><strong>DORA Metrics</strong> Measure and improve:</p><ul><li>Deployment frequency</li><li>Lead time for changes</li><li>Change failure rate</li><li>Mean time to recovery</li></ul><p>Build dashboards for these. Elite performers deploy multiple times daily with low failure rates.</p><p><strong>Advanced Patterns</strong></p><ul><li>Modular pipelines with templates.</li><li>Fan-out/fan-in for microservices.</li><li>Blue-green, canary deployments.</li><li>Automated rollbacks.</li><li>Cross-project sharing via service hooks, APIs.</li><li>REST API + Azure CLI + PowerShell for automation.</li><li>GitHub Advanced Security for Azure DevOps: CodeQL, secret scanning.</li></ul><p><strong>Monitoring &amp; Observability</strong> Integrate Application Insights, Azure Monitor. Release gates based on live metrics. Distributed tracing.</p><p><strong>Team &amp; Process</strong></p><ul><li>Definition of Done tied to pipelines.</li><li>Automated PR templates.</li><li>Weekly pipeline health reviews.</li><li>On-call rotations linked to alerts.</li><li>Continuous improvement via retrospectives on metrics.</li></ul><p><strong>Common Pitfalls</strong></p><ul><li>Classic editor pipelines (avoid).</li><li>Monolithic YAML files.</li><li>Hardcoded secrets or credentials.</li><li>No branch protection.</li><li>Ignoring test flakiness.</li><li>Over-permissioned service accounts.</li><li>No package promotion workflow.</li></ul><p><strong>Daily Habits for Pros</strong></p><ol><li>Every task starts from a work item.</li><li>Small, frequent commits with clear messages.</li><li>PRs under 400 lines.</li><li>Fix broken builds instantly.</li><li>Review metrics and logs regularly.</li><li>Keep templates and policies updated.</li><li>Automate repetitive manual steps.</li></ol><p>Azure DevOps works best when treated as code. Version it, review it, test it. Combine with Azure services for full power: App Service, AKS, Key Vault, Policy, Monitor.</p><p>Start today with one project and one pipeline. Iterate daily. In months, you’ll achieve consistent, traceable, high-velocity delivery that scales across teams. The platform evolves (better YAML, AI assistance, security), but core principles stay: automate relentlessly, collaborate visibly, measure what matters, improve continuously.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=930e5ce6ff60" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes Labs Deep Dive: From Pods to Production-Ready Services]]></title>
            <link>https://medium.com/@Aijay27/kubernetes-labs-deep-dive-from-pods-to-production-ready-services-4565fc09856a?source=rss-609565ed0c73------2</link>
            <guid isPermaLink="false">https://medium.com/p/4565fc09856a</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[kubernetes-cluster]]></category>
            <category><![CDATA[azure-devops]]></category>
            <dc:creator><![CDATA[Ajah Ijeoma]]></dc:creator>
            <pubDate>Sun, 03 May 2026 20:17:24 GMT</pubDate>
            <atom:updated>2026-05-03T20:17:24.379Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xgs332vRJqlKDqHH478xxA.png" /><figcaption>Kubernetes nine labs.</figcaption></figure><p>Kubernetes is not just a container orchestrator — it is a declarative system for managing distributed applications at scale. This guide walks through core Kubernetes primitives using a lab-driven progression, moving from Pods to fully exposed services with production-grade behaviors like self-healing, scaling, and traffic routing.</p><p>1. Creating Your First Pod</p><p>A Pod is the smallest deployable unit in Kubernetes. It encapsulates one or more containers, shared storage, and networking.</p><p><strong>Key Concepts</strong></p><p>• Each Pod gets a unique IP within the cluster.</p><p>• Containers inside a Pod share localhost networking.</p><p>• Pods are ephemeral — Kubernetes expects them to be replaceable.</p><p>Example</p><p>apiVersion: v1</p><p>kind: Pod</p><p>metadata:</p><p>name: nginx-pod</p><p>spec:</p><p>containers:</p><p>- name: nginx</p><p>image: nginx:latest</p><p>ports:</p><p>- containerPort: 80</p><p>Apply &amp; Verify</p><p>kubectl apply -f pod.yaml</p><p>kubectl get pods</p><p>kubectl describe pod nginx-pod</p><p>2.ReplicaSets — Keeping Pods Alive</p><p>ReplicaSets ensure a specified number of identical Pods are always running.</p><p>Why It Matters</p><p>• Handles Pod failures automatically</p><p>• Maintains availability</p><p>Example</p><p>apiVersion: apps/v1</p><p>kind: ReplicaSet</p><p>metadata:</p><p>name: nginx-rs</p><p>spec:</p><p>replicas: 3</p><p>selector:</p><p>matchLabels:</p><p>app: nginx</p><p>template:</p><p>metadata:</p><p>labels:</p><p>app: nginx</p><p>spec:</p><p>containers:</p><p>- name: nginx</p><p>image: nginx</p><p>Behavior</p><p>• If a Pod crashes → ReplicaSet creates a replacement</p><p>• If manually deleted → it is recreated automatically</p><p>3. Deployments — Rolling Updates &amp; Version Control</p><p>Deployments sit above ReplicaSets and provide declarative updates.</p><p>Key Features</p><p>• Rolling updates (zero downtime)</p><p>• Rollbacks</p><p>• Version history</p><p>Example</p><p>apiVersion: apps/v1</p><p>kind: Deployment</p><p>metadata:</p><p>name: nginx-deploy</p><p>spec:</p><p>replicas: 3</p><p>selector:</p><p>matchLabels:</p><p>app: nginx</p><p>strategy:</p><p>type: RollingUpdate</p><p>template:</p><p>metadata:</p><p>labels:</p><p>app: nginx</p><p>spec:</p><p>containers:</p><p>- name: nginx</p><p>image: nginx:1.25</p><p>Update Image</p><p>kubectl set image deployment/nginx-deploy nginx=nginx:1.26</p><p>Rollback</p><p>kubectl rollout undo deployment/nginx-deploy</p><p>4. Auto-Scaling &amp; Self-Healing</p><p>Horizontal Pod Autoscaler (HPA)</p><p>Automatically scales Pods based on CPU/memory usage.</p><p>kubectl autoscale deployment nginx-deploy — cpu-percent=50 — min=2 — max=10</p><p>Self-Healing</p><p>• Failed containers are restarted</p><p>• Unhealthy Pods are replaced</p><p>• Nodes failing → Pods rescheduled elsewhere</p><p>5. Readiness Probes</p><p>Readiness probes determine if a Pod is ready to receive traffic.</p><p>Why Important</p><p>• Prevents sending traffic to unready apps</p><p>• Ensures smooth deployments</p><p>Example</p><p>readinessProbe:</p><p>httpGet:</p><p>path: /</p><p>port: 80</p><p>initialDelaySeconds: 5</p><p>periodSeconds: 10</p><p>6. Liveness Probes</p><p>Liveness probes check if a container is still alive.</p><p>Why is it Important</p><p>• It detects deadlocks or frozen apps</p><p>• It automatically restarts broken containers</p><p>Example</p><p>livenessProbe:</p><p>httpGet:</p><p>path: /</p><p>port: 80</p><p>initialDelaySeconds: 15</p><p>periodSeconds: 20</p><p>7. Kubernetes Services — Networking Your App</p><p>Pods are ephemeral. Services provide stable access.</p><p>ClusterIP (Default)</p><p>• Internal-only communication</p><p>• Accessible within the cluster</p><p>apiVersion: v1</p><p>kind: Service</p><p>metadata:</p><p>name: nginx-clusterip</p><p>spec:</p><p>type: ClusterIP</p><p>selector:</p><p>app: nginx</p><p>ports:</p><p>- port: 80</p><p>targetPort: 80</p><p>NodePort</p><p>• Exposes service on each node’s IP</p><p>• Accessible externally via &lt;NodeIP&gt;:NodePort</p><p>type: NodePort</p><p>ports:</p><p>- port: 80</p><p>targetPort: 80</p><p>nodePort: 30007</p><p>LoadBalancer</p><p>• Provisions external load balancer (cloud environments)</p><p>• Distributes traffic across nodes</p><p>type: LoadBalancer</p><p>End-to-End Flow</p><p>1. Pod → runs container</p><p>2. ReplicaSet → ensures availability</p><p>3. Deployment → manages updates</p><p>4. Probes → ensure health</p><p>5. HPA → scales dynamically</p><p>6. Service → exposes application</p><p>Best Practices</p><p>• Always use Deployments instead of raw Pods</p><p>• Define resource limits (CPU/memory)</p><p>• Use probes for production workloads</p><p>• Prefer ClusterIP + Ingress over NodePort in production</p><p>• Implement rolling updates to avoid downtime</p><p>Common Pitfalls</p><p>• Missing labels → Services won’t route traffic</p><p>• Incorrect selectors → Pods not managed properly</p><p>• No probes → unhealthy apps receive traffic</p><p>• Hardcoding NodePorts → conflicts in large clusters</p><p>Final Insight</p><p>Kubernetes is fundamentally about desired state management:</p><p>You declare what you want, and Kubernetes ensures it stays that way.</p><p>Mastering these building blocks transforms you from “running containers” to engineering resilient, scalable systems.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4565fc09856a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Container Revolution: Why Modern Engineering Starts with Docker]]></title>
            <link>https://medium.com/@Aijay27/the-container-revolution-why-modern-engineering-starts-with-docker-912b527d4b65?source=rss-609565ed0c73------2</link>
            <guid isPermaLink="false">https://medium.com/p/912b527d4b65</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[containerization]]></category>
            <category><![CDATA[deployment]]></category>
            <dc:creator><![CDATA[Ajah Ijeoma]]></dc:creator>
            <pubDate>Sat, 02 May 2026 15:49:19 GMT</pubDate>
            <atom:updated>2026-05-02T15:49:19.001Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CrCxG2TLVW2JSm2rLdkAww.png" /><figcaption><strong>An image showing a healthy test on the terminal of Theepicbook app containers and their reliability.</strong></figcaption></figure><p>There is a specific kind of frustration reserved for the moment a perfectly written piece of code hits a production server and breaks. Usually, the culprit isn’t the logic itself, but a subtle mismatch in the environment a different Node version, a missing library, or a conflicting port. This is the “Environment Gap,” and for years, it was the primary bottleneck in software delivery. Docker didn’t just solve this; it fundamentally changed how we think about the lifecycle of an application.</p><p><strong>The Architecture of Consistency</strong></p><p>At its core, Docker is about <strong>immutable infrastructure</strong>. Traditionally, we treated servers like pets we named them, we manually updated them, and we hoped they stayed healthy. With Docker, we treat them like cattle. If a container misbehaves, we don’t fix it; we kill it and start a fresh one from a pre-defined image. This philosophy was the driving force behind my recent work on <strong>TheEpicBook</strong>, a full-stack Node.js and MySQL application. I wanted to move past a basic “it runs” setup and implement a workflow that mirrors how the world’s top engineering teams operate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l3UOwRoTdrcle1v6KsNWnQ.png" /><figcaption>docker compose build</figcaption></figure><p><strong>Beyond the “Heavy” Image: Multi-Stage Builds</strong></p><p>In the early days of containerization, people would ship everything: source code, compilers, test suites, and even documentation. This resulted in “bloated” images that were slow to pull and full of security vulnerabilities. I addressed this by implementing <strong>Multi-Stage Builds</strong>. By using a temporary “builder” stage to handle the heavy lifting of npm install and then copying only the production-ready assets into a second, minimal alpine stage, I was able to keep the images lean and fast.</p><ul><li><strong>Significant Size Reductions</strong>: On a recent React project, I managed to reduce an image from 755MB down to a staggering 26.3MB using these techniques.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t0GjumGRf9S1wDNw7JCU-Q.png" /><figcaption>my-react-app project showing the size reduction from 755mb of a single-stage build to 26.3mb of a multi-stage build.</figcaption></figure><ul><li><strong>Security Benefit</strong>: By stripping away the build tools, there are fewer utilities for an attacker to use if they ever gained access to the container.</li><li><strong>Operational Benefit</strong>: Smaller images mean faster CI/CD pipelines and less bandwidth consumption.</li></ul><p><strong>Orchestration and the “Health” Problem</strong></p><p>Running a single container is easy, but modern apps are distributed systems. TheEpicbook project involved a three-tier stack: a reverse proxy, the Node.js backend, and a MySQL database. The challenge here is <strong>startup order</strong>. A backend that tries to connect to a database before the database has finished initializing will simply crash. In my docker-compose.yml, I didn’t just link the services; I implemented <strong>Healthchecks</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*10_SThHs6pf39Igd34ACbA.png" /></figure><ul><li>The system monitors the database’s internal state via administrative pings.</li><li>The backend service is instructed to wait until the database reports a “healthy” status before it attempts to boot.</li><li>This creates a self-healing stack that can recover from a total power-off without manual intervention.</li></ul><p><strong>The Future: Agentic DevOps and Autonomous Auditing</strong></p><p>While containerization provides the “box,” the next frontier is how we manage these boxes. I’ve also been heavily involved in <strong>Agentic DevOps</strong>, specifically exploring how AI agents can autonomously reason and execute infrastructure tasks. Using the <strong>Model Context Protocol (MCP)</strong>, I’ve worked on frameworks like “Claude Code” to implement <strong>SAY-DO-LOG</strong> safety protocols.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FzOp0q4TQx2Dx0feVNdtWQ.png" /></figure><ul><li><strong>Autonomous Auditing</strong>: We are moving toward a world where a subagent can audit a Dockerfile for security vulnerabilities before it ever hits a repository.</li><li><strong>Safety Frameworks</strong>: I recently implemented a security-auditing subagent that successfully blocked and logged destructive terminal commands, ensuring that autonomous agents don’t accidentally bring down a production cluster.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FzOp0q4TQx2Dx0feVNdtWQ.png" /></figure><p><strong>Data Persistence and Cloud Strategy</strong></p><p>One of the most common mistakes is treating a container like a virtual machine. Containers are meant to be temporary. If you store your MySQL data inside the container’s writable layer, that data is lost the moment the container is updated. To handle this for <strong>TheEpicBook</strong>, I utilized <strong>Named Volumes</strong>. By mapping the database storage to a persistent volume on the host, the data is decoupled from the application lifecycle.</p><p>Moving this to the cloud (AWS) required a strict focus on the <strong>Reverse Proxy</strong> pattern. By using Nginx to handle the “front door,” I could route traffic to the appropriate containers while keeping the database completely isolated from the public internet.</p><p><strong>Final Thoughts</strong></p><p>Mastering Docker isn’t just about learning commands like docker build or docker push. It’s about understanding the discipline of <strong>Infrastructure as Code</strong> and preparing for an AI-driven future. Whether I was shrinking image sizes or drafting a runbook for disaster recovery, the goal was the same: creating a system that is predictable, scalable, and resilient. In modern engineering, we don’t just want code that works; we want systems that last.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=912b527d4b65" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond the Bash Script: How I Learned to Stop SSHing and Love Ansible]]></title>
            <link>https://medium.com/@Aijay27/beyond-the-bash-script-how-i-learned-to-stop-sshing-and-love-ansible-15ab2b65c81c?source=rss-609565ed0c73------2</link>
            <guid isPermaLink="false">https://medium.com/p/15ab2b65c81c</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[idempotency]]></category>
            <dc:creator><![CDATA[Ajah Ijeoma]]></dc:creator>
            <pubDate>Fri, 01 May 2026 00:47:28 GMT</pubDate>
            <atom:updated>2026-05-01T00:47:28.880Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sepZwMl7yXnf3DIULMUDUA.png" /><figcaption><strong>mini-finance application successfully deployed</strong></figcaption></figure><p>There’s a specific kind of “inventory anxiety” that hits you when you realize you have four different VMs to configure, and you’ve already forgotten which version of Python you installed on the second one.</p><p>For the longest time, I was the one manually SSHing into servers, running apt-get install by hand, and hoping I didn’t miss a configuration line in Nginx. It works for one server. It’s a nightmare for three. It’s an impossibility for fifty.</p><p>This week, I decided to fix my workflow. As part of my journey in the DMI internship, I moved away from manual “snowflake” servers and got under the hood of <strong>Ansible</strong>. Here is how I went from manual tinkering to automated orchestration.</p><p><strong>The Setup: Building the Workstation</strong></p><p>You can’t build a high-performance engine in a messy garage. I started by prepping a dedicated DevOps workstation. Instead of cluttering my global system, I isolated Ansible within a clean Python environment, mapped out my SSH keys, and established a “passwordless” handshake between my control node and my targets.</p><p>It sounds like a small step, but getting that initial connectivity right where your terminal can “talk” to a cluster of VMs without you typing a password every thirty seconds is where the magic actually begins.</p><p><strong>Ad-Hoc vs. The Master Plan</strong></p><p>I spent the first few days playing with <strong>Ad-Hoc commands</strong>. They are the “quick wins” of the Ansible world. Need to check the disk space on four servers at once? One command. Need to restart a service across the whole fleet? Done in seconds.</p><p>But the real power came when I moved into <strong>Structured Playbooks</strong>. This is where I stopped giving commands and started defining “state.” I wasn’t telling the server <em>how</em> to install Nginx; I was telling Ansible that Nginx <em>must</em> be there, and it must look <em>exactly</em> like this.</p><p><strong>The Build: The “Mini-Finance” Deployment</strong></p><p>To put this into practice, I didn’t just want to install a package; I wanted to deploy a real-world replica application. I used <strong>Terraform</strong> to provision the infrastructure, a multi-tier Azure environment with dedicated Web, App, and Database roles.</p><p>Then, I let Ansible take the lead. My playbook didn’t just “run.” It orchestrated. It updated caches, pulled my Mini-Finance application from GitHub, mapped the correct permissions for the www-data user, and ensured the web-root was configured correctly.</p><p>The most satisfying part? I added a final “Verification Play.” The playbook finishes by pinging the public IP and asserting an HTTP 200 status. If the site isn’t live, the playbook tells me. No more manual browser refreshing.</p><p><strong>Why This Matters</strong></p><p>If I’m being honest, the transition wasn’t perfectly smooth. I hit walls with CIDR blocks that didn’t align and permission errors that forced me to rethink my become: true logic. But that’s the point.</p><p><strong>Here is what I walked away with:</strong></p><ul><li><strong>Environment Parity is King:</strong> If your control node (where you run Ansible) doesn’t match the logic of your target, you’re going to have a bad time. Migrating my workspace to a native Linux environment (WSL/Ubuntu) was the best decision I made.</li><li><strong>Permissions are the Silent Killer:</strong> Most automation fails not because the code is wrong, but because the user running the code doesn’t have the “keys to the kingdom.”</li><li><strong>Document through Code:</strong> My site.yml is now my documentation. I don’t need a Word doc explaining how the server is set up. I have the code that does it.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mpPWWnJM6L_5DtA2HkAA1A.png" /></figure><p><strong>The Verdict</strong></p><p>We’re moving into an era where “Infrastructure as Code” isn’t a luxury it’s the standard. The ability to spin up a four-VM environment and have it fully configured in three minutes is a superpower.</p><p>I’m done with manual SSH sessions. From here on out, if it isn’t automated, it isn’t finished.</p><p>P.S. This post is part of the DevOps Micro Internship (DMI) Cohort-2 by Pravin Mishra. You can start your DevOps journey by joining this Discord community ( <a href="https://discord.pravinmishra.com/">https://discord.pravinmishra.com/</a> ).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=15ab2b65c81c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>