<?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 Henrietta Ogochukwu Okechukwu on Medium]]></title>
        <description><![CDATA[Stories by Henrietta Ogochukwu Okechukwu on Medium]]></description>
        <link>https://medium.com/@harietogochukwu?source=rss-e05192996f59------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*KpRzcGH1yBLlaX3fxHXaAA.jpeg</url>
            <title>Stories by Henrietta Ogochukwu Okechukwu on Medium</title>
            <link>https://medium.com/@harietogochukwu?source=rss-e05192996f59------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:40:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@harietogochukwu/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[Breaking Free from “It Works on My Machine”: My 8-Step Journey Mastering Docker]]></title>
            <link>https://medium.com/@harietogochukwu/breaking-free-from-it-works-on-my-machine-my-8-step-journey-mastering-docker-9634d81f74c8?source=rss-e05192996f59------2</link>
            <guid isPermaLink="false">https://medium.com/p/9634d81f74c8</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[container-orchestration]]></category>
            <dc:creator><![CDATA[Henrietta Ogochukwu Okechukwu]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 17:36:06 GMT</pubDate>
            <atom:updated>2026-10-15T17:36:06.373Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zi8Wh_UIweQ1GjaAI-Kmlw.jpeg" /></figure><p>Every software engineer remembers the exact moment of absolute frustration when an application runs perfectly on a local laptop, only to completely crash the moment it touches a cloud server or staging environment. Environment mismatches, missing dependencies, and conflicting runtime versions are the silent killers of developer productivity.</p><p>For the longest time, I treated containerization as a black box — just another set of CLI commands to memorize. But if you want to transition from writing code to engineering reliable cloud-native infrastructure, you have to understand how containers actually isolate and ship software.</p><p>To break out of that cycle, I committed to an intensive 8-step Docker hands-on journey. Moving from raw cloud VMs to multi-stage builds, container networking, persistent storage, and production-grade Docker Compose stacks, here is the story of how I mastered Docker from the ground up.</p><h3>Phase 1: From Cloud VMs to Optimized Builds (Assignments 1–2)</h3><h3>Assignment 1: Deploy a Static Website on a Cloud VM Using Docker</h3><p>My journey began with the basics: provisioning a cloud Virtual Machine and manually deploying a static website inside a Docker container. Moving away from bare-metal file copying to running isolated Nginx containers taught me the foundational power of containerization — decoupling application delivery from underlying host operating systems.</p><h3>Assignment 2: Multi-Stage Docker Build for a React Application</h3><p>As web apps grow, image size becomes a critical bottleneck. In Assignment 2, I tackled <strong>multi-stage builds</strong> for a React application. By using a heavy build container to compile static assets and then copying only the lean, production-ready output into a minimal runtime image, I slashed container footprints and accelerated deployment speeds.</p><h3>Phase 2: Networking, Persistence, and Sharing (Assignments 3–5)</h3><h3>Assignment 3: Docker Networking</h3><p>Containers in isolation cannot talk to each other unless explicitly wired. Assignment 3 explored Docker bridge networks and custom subnet configurations, teaching me how containers communicate securely using container names and internal DNS rather than fragile, hardcoded IP addresses.</p><h3>Assignment 4: Docker Volumes and Bind Mounts</h3><p>Stateless containers are great, but applications need data survival. Here, I explored <strong>volumes and bind mounts</strong>. By attaching persistent Docker named volumes to database containers, I learned how data survives container termination, restarts, and recreation cycles.</p><h3>Assignment 5: Publish a Docker Container on Docker Hub</h3><p>Building images locally is only half the battle. In Assignment 5, I authenticated with Docker Hub, tagged custom images properly, and pushed my container artifacts to a public registry, transforming local experiments into globally shareable software packages.</p><h3>Phase 3: Multi-Container Stacks &amp; Production Hardening (Assignments 6–8)</h3><h3>Assignment 6: Deploy the Book Review App with Docker Compose</h3><p>Managing multiple individual container commands quickly becomes messy. Assignment 6 introduced <strong>Docker Compose</strong>. I orchestrated a complete multi-container application stack — tying together a frontend UI, a backend API, and a MySQL database into a single declarative YAML file complete with health checks and startup dependencies.</p><h3>Assignment 7: Capstone — Deploy a Production-Grade Stack for The EpicBook</h3><p>In Assignment 7, all these concepts culminated in a production-grade capstone. I deployed the <strong>EpicBook</strong> application stack on an AWS cloud VM. This involved setting up an Nginx reverse proxy as the single public entry point, configuring internal network isolation so backend and database tiers remained hidden from the public internet, and implementing persistent storage and container health monitoring.</p><h3>Assignment 8: AI-Assisted Docker Container Hardening Audit</h3><p>In the final assignment, I explored security and container hardening. Using automated auditing workflows, I evaluated container configurations for security vulnerabilities, enforced non-root user execution, and optimized image layers to ensure production workloads were secure against common threat vectors.</p><h3>Final Thoughts</h3><p>Looking back at these 8 assignments, containerization completely changed how I build and think about software. Docker turned deployment from a nerve-wracking, platform-dependent gamble into a repeatable, elegant science.</p><p>Once you experience the seamless consistency of spinning up a multi-tier production stack with a single docker compose up command, there is simply no going back.</p><p>If you want to dive deeper into the core mechanics of containerization, you might find this explanation helpful: <a href="https://www.youtube.com/shorts/pzICe_5xqs4">Docker Workflow Explained in 180 Seconds</a>.</p><p>P.S. This post is part of the DevOps Micro Internship with Agentic AI Cohort 3 by <a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">Pravin Mishra</a> (<a href="https://dmi.pravinmishra.com/">https://dmi.pravinmishra.com</a>) . You can begin your DevOps journey by joining the DMI waiting list. ( <a href="https://www.linkedin.com/safety/go/?url=https%3A%2F%2Flnkd.in%2Fd735Nsd7&amp;urlhash=awdv&amp;mt=qcQV2qn317G-nf9sbpffsLfSN2ZWQgvnC1UOxENJnpY9Ft3pSF1fAtAAq-ITH1oKZj6p6EAe-b-150SlRQXVaEQ8__kpd-8-ZFVIsIl1fVioVziolhjRdaWs4w&amp;isSdui=true">https://lnkd.in/d735Nsd7</a>)</p><p>View my progress here: (<a href="https://dmi.pravinmishra.com/s/Harietonyeabor.html">https://dmi.pravinmishra.com/s/Harietonyeabor.html</a>)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9634d81f74c8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Day My App Broke in Production (And How 11 Kubernetes Projects Saved Me)]]></title>
            <link>https://medium.com/@harietogochukwu/the-day-my-app-broke-in-production-and-how-11-kubernetes-projects-saved-me-5d09b9c9f24c?source=rss-e05192996f59------2</link>
            <guid isPermaLink="false">https://medium.com/p/5d09b9c9f24c</guid>
            <category><![CDATA[kubernetes-pods]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[kubernetes-cluster]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Henrietta Ogochukwu Okechukwu]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 16:58:07 GMT</pubDate>
            <atom:updated>2026-10-15T16:58:07.741Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xuJc34nevXF2jYAvb6DUUg.jpeg" /></figure><p>There is a quiet panic every developer knows too well: pushing code to production, hitting refresh, and watching the screen light up with errors.</p><p>For a long time, I treated Kubernetes like a black box. I knew it orchestrated containers, but the moment things went wrong, I found myself panic-typing random kubectl commands and hoping for the best. I realized that if I wanted to grow from someone who just writes code into an engineer who builds reliable systems, I needed to open that black box.</p><p>So, I decided to stop avoiding infrastructure. I committed to an intensive 11-step Kubernetes gauntlet — building, breaking, scaling, and ultimately securing a full-stack application from the ground up.</p><p>Here is how I went from writing my very first fragile pod manifest to building a bulletproof, human-in-the-loop AI incident triage pipeline.</p><h3>Phase 1: Moving Beyond a Single Pod (Assignments 1–3)</h3><p>Every cloud architecture starts with the basics. My journey began in <strong>Assignment 1</strong> by writing a raw manifest for my very first Kubernetes <strong>Pod</strong>. Seeing a pod successfully transition from pending to running on my local kind cluster was a great milestone.</p><p>The reality check hit immediately: <em>single pods are fragile.</em> If a node drops, your app goes down with it.</p><p>That drove me into <strong>Assignment 2 (ReplicaSets)</strong> and <strong>Assignment 3 (Deployments)</strong>. By managing a pool of pod replicas, I saw firsthand what self-healing infrastructure actually looks like — deleting a pod just to watch Kubernetes instantly spin up a replacement. More importantly, Deployments introduced me to <strong>rolling updates</strong>, allowing me to update container images seamlessly without a single second of downtime.</p><h3>Phase 2: Teaching Apps How to Heal Themselves (Assignments 4–6)</h3><p>A running app isn’t always a healthy app. What happens when your API deadlocks because a database connection drops, but the container process itself technically stays alive?</p><p>That is where health checks change everything:</p><ul><li><strong>Readiness Probes (Assignment 5):</strong> Acts as a traffic bouncer. If a pod isn’t ready to serve users, readiness probes stop traffic from hitting it until it recovers.</li><li><strong>Liveness Probes (Assignment 6):</strong> Acts as the restart switch. When an app hits an unrecoverable crash loop, liveness probes notice and restart the container automatically.</li><li><strong>Auto-Scaling (Assignment 4):</strong> Hooking up Horizontal Pod Autoscalers taught me how Kubernetes dynamically scales replicas up and down based on real-time CPU and memory usage.</li></ul><p>Suddenly, my deployments weren’t just static boxes — they had a real pulse.</p><h3>Phase 3: Wiring Up the Network (Assignments 7–9)</h3><p>A pod in isolation cannot do much. To build a real application, pods need to talk to each other, and users need a way to reach them.</p><p>Navigating Kubernetes networking felt like building a city’s utility grid:</p><ul><li><strong>ClusterIP (Assignment 7):</strong> Established secure internal communication so backend APIs could talk to databases without exposing internal data to the public internet.</li><li><strong>NodePort (Assignment 8):</strong> Opened specific static ports across cluster nodes so external clients could access the app during testing.</li><li><strong>LoadBalancer (Assignment 9):</strong> Stepped up to enterprise cloud routing on AKS, provisioning automated external load balancers to handle incoming traffic smoothly.</li></ul><h3>Phase 4: The Capstone &amp; Intelligent Operations (Assignments 10–11)</h3><p>All these pieces finally came together in <strong>Assignment 10: The Book Review App Capstone</strong>, where I deployed a complete three-tier application — React/Nginx frontend, Node.js/Express backend, and persistent MySQL storage managed via StatefulSets, ConfigMaps, and Secrets.</p><p>But deploying an app is only half the job. What happens when something breaks in production?</p><p>In <strong>Assignment 11</strong>, I tackled AI-Assisted Incident Triage. Instead of guessing during a simulated failure (where I intentionally broke the backend with a bad image tag), I built a disciplined operational model: <strong>Gather → Analyze → Human Act → Verify</strong>.</p><ol><li><strong>Gather:</strong> A deterministic Bash script (k8s-triage.sh) systematically checks pod status, readiness, restart counts, warning events, and EndpointSlices.</li><li><strong>Analyze:</strong> I connected this script to Claude Code via a custom /k8s-triage skill to analyze telemetry and suggest root causes.</li><li><strong>Human Act:</strong> Safety first — <strong>AI never touches the cluster.</strong> While Claude acted as an analytical co-pilot, the actual fix (rolling back the bad image) was executed manually by me in the terminal.</li><li><strong>Verify:</strong> The triage script ran a second time to provide mathematical, automated proof of recovery.</li></ol><h3>Final Thoughts</h3><p>Looking back at these 11 assignments, the growth is night and day. I started out intimidated by YAML syntax and pod errors; now, I can orchestrate resilient, self-healing architectures and manage incident response with confidence.</p><p>Kubernetes isn’t just about configuration files. It’s a shift toward declarative thinking — building systems that expect failure, heal themselves, and stay online no matter what. And once you see your first self-healing workload recover automatically, there’s no going back.</p><p>P.S. This post is part of the DevOps Micro Internship with Agentic AI Cohort 3 by <a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">Pravin Mishra</a> (<a href="https://dmi.pravinmishra.com/">https://dmi.pravinmishra.com</a>) . You can begin your DevOps journey by joining the DMI waiting list. ( <a href="https://www.linkedin.com/safety/go/?url=https%3A%2F%2Flnkd.in%2Fd735Nsd7&amp;urlhash=awdv&amp;mt=qcQV2qn317G-nf9sbpffsLfSN2ZWQgvnC1UOxENJnpY9Ft3pSF1fAtAAq-ITH1oKZj6p6EAe-b-150SlRQXVaEQ8__kpd-8-ZFVIsIl1fVioVziolhjRdaWs4w&amp;isSdui=true">https://lnkd.in/d735Nsd7</a>)</p><p>View my progress here: (<a href="https://dmi.pravinmishra.com/s/Harietonyeabor.html">https://dmi.pravinmishra.com/s/Harietonyeabor.html</a>)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d09b9c9f24c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Let an AI Triage My Broken CI/CD Pipeline. Here’s Why I Refused to Give It the Car Keys.]]></title>
            <link>https://medium.com/@harietogochukwu/i-let-an-ai-triage-my-broken-ci-cd-pipeline-heres-why-i-refused-to-give-it-the-car-keys-67492adbcf22?source=rss-e05192996f59------2</link>
            <guid isPermaLink="false">https://medium.com/p/67492adbcf22</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Henrietta Ogochukwu Okechukwu]]></dc:creator>
            <pubDate>Mon, 21 Sep 2026 23:22:28 GMT</pubDate>
            <atom:updated>2026-09-21T23:22:28.469Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*54utOreq8RV-VdKOIWVfCg.png" /></figure><h3>What happened when I built a dual-pipeline engine on AWS, broke it on purpose, and taught Claude Code to find the needle in my haystack.</h3><p><strong>By Henrietta Ogochukwu Okechukwu</strong></p><p>There is a very specific flavor of panic known only to developers and DevOps engineers.</p><p>You’ve spent days wiring together cloud resources. Everything looks clean. You commit a small update, push your branch, and walk away to make a cup of tea. When you come back, your screen is screaming red.</p><p>You click the build log. It’s 4,000 lines long.</p><p>You find yourself squinting at a terminal window at 11 PM, grepping for words like fatal, exit code 1, or error, wondering which of the twenty tasks failed, why it failed, and what you’re supposed to do to fix it.</p><p>During Week 10 of my DevOps journey, I decided I was tired of squinting at logs.</p><p>I wanted to see if an AI assistant could handle the forensic nightmare of failure triage for me. But I also knew the horror stories: AI agents hallucinating fixes, triggering endless rebuild loops, or accidentally running destructive scripts against live cloud infrastructure.</p><p>So I spent this week building a decoupled, multi-tier delivery system on AWS with Azure DevOps — and then gave it an AI diagnostic partner with one ironclad rule:</p><p><strong>You can diagnose the crime scene. But you are never allowed to touch the evidence or drive the car.</strong></p><p>Here is the story of how it worked, how it failed, and what it taught me about the future of shipping code.</p><h3>The Anatomy of the Monster</h3><p>To build something realistic, you can’t use a toy “Hello World” app. Our project — a book platform called <strong>EpicBook</strong> — mirrors a modern production setup.</p><p>Instead of cramming everything into one messy pipeline script, we decoupled the architecture into two separate lifecycles:</p><pre>[ Git Push ]<br>     │<br>     ├──► 1. Infrastructure Pipeline (Terraform) ──► VPC, Subnets, EC2, RDS MySQL<br>     │<br>     └──► 2. Application Pipeline (Ansible)      ──► Nginx, Node.js, Health Checks</pre><p>Why separate them? Because your cloud network rarely changes, but your application code changes fifty times a week. If you tie them together, every single CSS tweak or typo fix forces Terraform to re-evaluate thirty AWS resources. That’s slow, expensive, and risky.</p><p>Across the first four phases of the project, we systematically built this out:</p><ul><li><strong>The Zero-Trust Handshake:</strong> We connected Azure DevOps to AWS using scoped IAM service principals — meaning zero plain-text passwords or permanent access keys living in config files.</li><li><strong>Infrastructure as Code:</strong> We wrote Terraform modules to provision an isolated Virtual Private Cloud (VPC), multi-AZ subnets, security groups, EC2 instances, and an Amazon RDS MySQL database cluster. One click could stand up or tear down the entire cloud footprint.</li><li><strong>Automated Configuration:</strong> We used Ansible playbooks to configure our servers, set up reverse proxies with Nginx, link the Node.js backend to MySQL, and deploy the application.</li><li><strong>Hardening the Perimeter:</strong> We masked secrets in console output, locked Terraform remote state to prevent concurrent run collisions, and ensured an application crash could never pull down the underlying database or network.</li></ul><p>Once the pipelines were running green and steady, it was time for the real experiment.</p><h3>The Golden Rule: AI Gathers, Humans Act</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zONNbYcqpq9eSbXYRgLpcg.png" /></figure><p>The buzzword right now is <em>Agentic AI</em> — letting models execute commands, commit code, and fix bugs autonomously.</p><p>In a production CI/CD environment, that sounds less like innovation and more like a terrifying recipe for an out-of-control AWS bill.</p><p>What happens if an AI agent misreads an Ansible error, pushes a bad patch, triggers a new build, fails again, and enters a recursive retry loop while you sleep? What if it runs a command that wipes a database subnet?</p><p>I wanted speed, not chaos. So I implemented a strict <strong>Human-in-the-Loop</strong> operating model:</p><pre>Gather (Bash) ──► Analyze (Claude Code) ──► Human Act (Engineer) ──► Verify (Claude Code)</pre><ul><li><strong>Deterministic Gathering:</strong> I wrote a dedicated Bash script (pipeline-triage.sh). It talks to the Azure DevOps REST API, fetches the latest run across branches, and strips out every token, password, and sensitive header.</li><li><strong>Read-Only AI Analysis:</strong> Using Claude Code, I built a custom skill (/pipeline-triage) governed by a strict CLAUDE.md policy. The AI was given read access to sanitized logs, but <strong>zero write permissions</strong>. It was forbidden from editing files, pushing commits, or triggering pipelines.</li><li><strong>Human Action:</strong> The AI tells the engineer <em>what</em> broke and <em>why</em>. The human reviews it, decides if it makes sense, applies the fix, and hits Run.</li><li><strong>Verification:</strong> The AI inspects the new run to confirm the system is genuinely healthy.</li></ul><h3>The Fire Drill: Breaking Production on Purpose</h3><p>To test whether the co-pilot was actually useful or just a parlor trick, I staged a controlled failure drill on a temporary branch: drill/pipeline-failure.</p><p>I opened our core deployment playbook, ansible/site.yml, and dropped a deliberate bomb right into the middle of it:</p><p>YAML</p><pre>- deliberate_syntax_error: [invalid yaml indentation</pre><p>An unclosed bracket. Bad indentation. Invalid YAML.</p><p>I pushed the branch and kicked off the Application Pipeline.</p><p>Predictably, the screen flashed red. <strong>Run 26 failed</strong> at the Ansible Syntax Check stage. The pipeline stopped dead in its tracks before anything touched our live AWS servers.</p><pre>● Application Pipeline (ID 5) — Run 26<br>Status: FAILED ❌</pre><h3>The 15-Second Diagnosis</h3><p>Normally, this is where the scrolling begins. Instead, I stayed in my terminal, launched Claude Code, and typed two words:</p><p>Bash</p><pre>/pipeline-triage</pre><p>What happened next was genuinely exciting.</p><p>Instead of generic advice or a wall of hallucinatory code, Claude Code ran the triage script, parsed the sanitized error stream, and spit out this crisp breakdown:</p><pre>PIPELINE TRIAGE REPORT</pre><pre>● Status: FAILED (Exit Code: 2)<br>● Pipeline: Application Pipeline (Run 26)<br>● Category: Build Failure — Ansible Playbook Syntax Error</pre><pre>Exact Evidence:<br>[ERROR]: YAML parsing failed: While parsing a block mapping did not find expected key.<br>19   - deliberate_syntax_error: [invalid yaml indentation<br>##[error]Bash exited with code &#39;4&#39;.</pre><pre>Root Cause:<br>The playbook site.yml contains invalid YAML syntax on line 19. <br>The opening bracket &#39;[&#39; is unclosed, causing the parser to fail.</pre><pre>Recommended Human Action:<br>1. Open ansible/site.yml at line 19.<br>2. Remove or correct the line: - deliberate_syntax_error: [invalid yaml indentation<br>3. Commit, push to drill/pipeline-failure, and manually trigger the pipeline.</pre><p>No scrolling. No manual log searching. In under 15 seconds, the AI pulled the exact line number, identified the syntax mistake, and told me how to fix it — without trying to touch the file itself.</p><h3>The Recovery Loop</h3><p>I took the steering wheel:</p><ul><li>I checked out drill/pipeline-failure on my machine.</li><li>I reverted the corrupt line in site.yml.</li><li>I committed the fix: fix: resolve deliberate YAML syntax error in site.yml.</li><li>I pushed to GitHub and manually kicked off <strong>Run 27</strong>.</li></ul><p>Two minutes later: <strong>Run 27 turned bright green.</strong></p><p>To close the loop, I ran /pipeline-triage one last time.</p><p>The report instantly flipped:</p><pre>PIPELINE TRIAGE REPORT</pre><pre>✅ HEALTHY — All checks passing.<br>- Infrastructure Pipeline: Run 20 (Succeeded)<br>- Application Pipeline:    Run 27 (Succeeded)<br>- Exit Code: 0</pre><p>I merged what was needed, deleted the drill branch, and returned my workspace to a clean state. The entire incident — from injected failure to verified recovery — took less than five minutes.</p><h3>What This Taught Me About AI in DevOps</h3><p>Building this system changed how I think about automation. Three major lessons stuck with me:</p><h4>1. Give AI the Magnifying Glass, Not the Steering Wheel</h4><p>AI doesn’t need to be autonomous to be valuable. Finding the error in a massive log is the tedious part of engineering; deciding how to fix it and verifying the blast radius is the skilled part. By keeping the AI strictly read-only, I got 90% of the speed boost with 0% of the operational risk.</p><h4>2. Deterministic Code Beats Clever Prompts</h4><p>If you simply ask an LLM to “check your Azure DevOps pipelines,” it will stumble over missing tokens, hallucinate run IDs, and guess at error logs. Writing a simple, 150-line Bash script that handles authentication, fetches the exact queueTimeDescending record, and scrubs secrets created a reliable bridge that made the AI 100x sharper.</p><h4>3. Decoupling Is Your Best Insurance Policy</h4><p>When our application playbook failed during the drill, our database didn’t flicker, our VPC didn’t reset, and our AWS bill didn’t spike. Splitting infrastructure from application deployment kept our blast radius contained to a single pre-flight check.</p><h3>Final Thoughts</h3><p>AI isn’t coming to replace the DevOps engineer. But the engineer who knows how to build safe, deterministic guardrails around AI tools is going to troubleshoot ten times faster than the one still manually scrolling through thousands of lines of terminal output.</p><p>The future of operations isn’t an unchecked autopilot. It’s an intelligent, accountable co-pilot.</p><p><em>What’s your take? Would you ever give an AI write access to your production deployment pipelines, or do you keep humans strictly in the loop? Let’s talk in the comments below.</em></p><p>P.S. This post is part of the DevOps Micro Internship with Agentic AI Cohort 3 by <a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">Pravin Mishra</a> (<a href="https://dmi.pravinmishra.com/">https://dmi.pravinmishra.com</a>) . You can begin your DevOps journey by joining the DMI waiting list. ( <a href="https://www.linkedin.com/safety/go/?url=https%3A%2F%2Flnkd.in%2Fd735Nsd7&amp;urlhash=awdv&amp;mt=qcQV2qn317G-nf9sbpffsLfSN2ZWQgvnC1UOxENJnpY9Ft3pSF1fAtAAq-ITH1oKZj6p6EAe-b-150SlRQXVaEQ8__kpd-8-ZFVIsIl1fVioVziolhjRdaWs4w&amp;isSdui=true">https://lnkd.in/d735Nsd7</a>)</p><p>View my progress here: (<a href="https://dmi.pravinmishra.com/s/Harietonyeabor.html">https://dmi.pravinmishra.com/s/Harietonyeabor.html</a>)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67492adbcf22" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Code to Cloud Safely: When Automation Knows What to Do — and When to Stop]]></title>
            <link>https://medium.com/@harietogochukwu/from-code-to-cloud-safely-when-automation-knows-what-to-do-and-when-to-stop-6f5bd95e473d?source=rss-e05192996f59------2</link>
            <guid isPermaLink="false">https://medium.com/p/6f5bd95e473d</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Henrietta Ogochukwu Okechukwu]]></dc:creator>
            <pubDate>Sat, 12 Sep 2026 19:54:14 GMT</pubDate>
            <atom:updated>2026-09-12T19:55:42.484Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kj4qsRSJknh-DNXYuKZ69w.png" /></figure><p>There is something amazing about watching cloud servers appear out of plain text.</p><p>You run a couple of commands, wait a few minutes, and an entire system comes alive: networks, firewalls, a virtual server, a database, and a web app, all connected and working together.</p><p>Once the initial excitement settles, an important question comes up:</p><p><strong>What happens when you need to update a system that is already running live?</strong></p><p>That question became the heart of my Week 9 capstone in the <strong>DevOps Micro Internship (DMI) Cohort 3 with Agentic AI</strong>, led by Pravin Mishra.</p><p>I started the project thinking my only goal was to deploy a web application. By the end, I was thinking about a much bigger problem:</p><blockquote><strong><em>How do we automate cloud systems without giving automation — or AI — the power to break what we already built?</em></strong></blockquote><h3>1. Setting Up the Foundation: Terraform and Ansible</h3><p>The first goal was simple: deploy a book-review web app called <strong>EpicBook</strong> on Amazon Web Services (AWS).</p><p>Plaintext</p><pre>[ Internet User ] <br>       ↓ (Port 80)<br>[ Nginx Web Proxy ] <br>       ↓ (Internal Port 8080)<br>[ Node.js Application ] <br>       ↓ (Database Port 3306)<br>[ Private MySQL Database ]</pre><h3>Building the Network with Terraform</h3><p>I started by writing Terraform code to create the infrastructure. Instead of putting everything in one open network, I kept things secure:</p><ul><li><strong>Custom Network (VPC):</strong> One public subnet for the web server and two private subnets for the database.</li><li><strong>Tight Security Rules:</strong> SSH access was locked down strictly to my own computer’s IP address.</li><li><strong>Hidden Database:</strong> The Amazon RDS MySQL database was completely cut off from the public internet. Only our web server was allowed to connect to it.</li></ul><p>A database does not belong on the public internet just because your application needs to talk to it.</p><h3>Configuring the Server with Ansible Roles</h3><p>Once the server was up, Ansible took over the setup. Instead of dumping everything into one long, messy script, I split the work into three clean, focused roles:</p><ul><li>common: Installs basic tools like Git, Curl, and MySQL client utilities.</li><li>nginx: Installs and configures Nginx to act as a reverse proxy, directing outside web traffic to our app.</li><li>epicbook: Downloads the application code, installs dependencies, connects the database, and keeps the Node.js app running in the background using PM2.</li></ul><p>To keep database passwords safe, I used <strong>Ansible Vault</strong> to encrypt them with AES-256 so no sensitive secrets were ever stored in plain text.</p><p>The server was built. The setup commands finished. The terminal reported success.</p><p>Or so it seemed.</p><h3>2. The 404 Error That Taught Me a Lesson</h3><p>I copied the server’s public IP address into my browser, pressed enter, and was greeted by:</p><p>404 Not Found</p><p>Few things humble an engineer faster than an error page right after a “successful” run.</p><p>The terminal said everything went fine. The server was on. The code was downloaded. But anyone visiting the site saw a broken page.</p><p>Instead of guessing, I traced the path of the web request step by step:</p><ul><li><strong>Check the App Directly:</strong> Inside the server, I checked if the Node.js application was actually responding:</li><li>Bash</li><li>curl -I <a href="http://localhost:8080/">http://localhost:8080</a></li><li>It returned HTTP 200 OK. The application was alive and working behind the scenes.</li><li><strong>Check the Web Server (Nginx):</strong> Next, I checked Nginx. The configuration file was created, but Nginx hadn’t reloaded its active memory to pick up the new routing rules.</li></ul><p>A simple restart of Nginx fixed the issue immediately. I refreshed the page, saw EpicBook load, and placed a test order to make sure data saved properly to our private MySQL database.</p><p>That small bug taught me an invaluable lesson:</p><blockquote><strong><em>Just because an automation command finishes without errors doesn’t mean your application is actually working for your users.</em></strong></blockquote><p>There is a big difference between a command that succeeds and a system that delivers.</p><h3>3. The Real Challenge: Making Updates Safely</h3><p>Deploying on day one is exciting. Managing updates on day two is where things get tricky.</p><p>Over time, code changes, packages need security updates, and settings shift. Every single change you make to a live server carries the risk of breaking something.</p><p>Running automation blindly on a live server is risky:</p><ul><li>A small configuration change can restart a critical service at the wrong time.</li><li>An updated firewall rule might accidentally lock you out.</li><li>A cleanup script could delete important user files.</li></ul><p>This is where <strong>AI agents</strong> enter the picture.</p><p>Everyone talks about how fast AI can write code and apply changes. But in production engineering, the much more important question is:</p><p><strong>What should an AI agent never be allowed to do on its own?</strong></p><h3>4. Building the Guardrails: Check First, Apply Later</h3><p>To make updates safe and predictable, I built a 4-step safety workflow:</p><pre>[ Gather ]  ──&gt; Run a dry run to see what would change<br>    ↓<br>[ Analyze ] ──&gt; Bash script + Claude Code inspect the risks<br>    ↓<br>[ Act ]     ──&gt; A human engineer reviews and approves the change<br>    ↓<br>[ Verify ]  ──&gt; Run a final check to confirm zero leftover issues</pre><h3>Step 1: Gathering Hard Facts</h3><p>Instead of asking an AI to read my files and guess if they were safe, I used Ansible’s dry-run mode:</p><p>Bash</p><pre>ansible-playbook -i inventory.ini site.yml --check --diff</pre><p>This tells Ansible: <em>“Show me exactly what lines and files you would change on the live server, but do not touch anything yet.”</em></p><h3>Step 2: Catching Risky Changes with Bash</h3><p>I wrote a Bash script (ansible-check-review.sh) to scan the dry-run output for sensitive actions:</p><ul><li><strong>Service Restarts:</strong> Actions that stop or restart live services.</li><li><strong>Firewall Tweaks:</strong> Changes to network ports or security settings.</li><li><strong>User &amp; Sudo Permissions:</strong> Changes that touch admin rights.</li><li><strong>File Deletions:</strong> Any task set to remove or delete files.</li></ul><p>The script then gave a clear status code:</p><ul><li>0 (Healthy): The server already matches the code. Zero changes needed.</li><li>1 (Warning): Normal, low-risk updates detected (like minor config tweaks).</li><li>2 (Failed): High-risk actions detected (like service restarts or file removals).</li></ul><p>The script was built to flag danger, not to decide whether to push the button. That final choice was reserved for a human.</p><h3>5. Giving AI a Seat at the Table, Not the Steering Wheel</h3><p>Next, I turned this process into a custom skill for <strong>Claude Code</strong> called /ansible-risk-review.</p><p>To make sure the AI acted as a trusted advisor rather than an unsupervised operator, I set strict ground rules in a CLAUDE.md file:</p><ul><li><strong>Allowed:</strong> Running diagnostic read commands, reading logs, and searching text.</li><li><strong>Forbidden:</strong> Editing playbooks, changing server settings, or applying updates to live servers.</li></ul><p>Telling an AI to “be careful” isn’t a safety plan. <strong>A real safety plan is a technical boundary the AI cannot cross.</strong></p><p>Claude Code could inspect the dry run, explain the blast radius in plain English, and warn me if something looked dangerous. But it was physically blocked from applying changes on its own.</p><h3>6. Testing the Safety Net</h3><p>A safety net is useless if you never test whether it catches you.</p><p>To test the system, I manually created a dummy file on the remote server:</p><p>Bash</p><pre>touch /tmp/epicbook-risk-test</pre><p>Then, I added a task to our Ansible code to delete it:</p><p>YAML</p><pre>- name: Remove temporary EpicBook risk test file<br>  ansible.builtin.file:<br>    path: /tmp/epicbook-risk-test<br>    state: absent</pre><p>I ran the review script:</p><p>Bash</p><pre>./ansible-check-review.sh</pre><p>The script caught the deletion instantly:</p><p>Plaintext</p><pre>[FAIL] Risky tasks detected matching: remove|absent|delete<br>TASK: Remove temporary EpicBook risk test file<br>Overall Status: FAIL - risky changes present, do not apply without review<br>Captured Exit Code: 2</pre><p>I then ran the /ansible-risk-review skill inside Claude Code.</p><p>The AI read the report, pointed out the exact file marked for deletion, and gave a clear warning:</p><blockquote><strong><em>“High-risk deletion detected. Do not apply automatically. A human engineer must review and approve this first.”</em></strong></blockquote><p>The guardrail did its job. The AI didn’t attempt to run the command or fix anything automatically. It flagged the risk, explained the impact, and paused.</p><h3>7. The Human Decision and Final Check</h3><p>Because this was a planned test, I reviewed the details and chose to apply the change myself:</p><p>Bash</p><pre>ansible-playbook -i inventory.ini site.yml --vault-password-file ~/.vault_pass</pre><p>The task finished cleanly with zero errors.</p><p>Then came the final step: <strong>verification</strong>.</p><p>I ran the risk-review script one more time to check our work:</p><pre>==================================================<br>ANSIBLE RISK REVIEW SUMMARY<br>==================================================<br>Tasks Changed:       0<br>Risky Tasks:         0<br>Overall Status:      HEALTHY - no changes detected<br>Script Exit Code:    0<br>==================================================</pre><p>The server was fully up to date, and a fresh dry run proved there were no pending changes or unexpected side effects.</p><p>Automation isn’t finished when a script stops running. It is finished when you confirm the system is in the exact state you intended.</p><h3>Key Takeaways</h3><ul><li><strong>Clear Boundaries Matter:</strong> Use Terraform to build the infrastructure and Ansible to manage the software. Keeping them separate makes systems easier to maintain.</li><li><strong>Always Preview First:</strong> Never run updates on a live server without a dry run (--check --diff). If you don&#39;t inspect what will change, you are testing in production.</li><li><strong>AI Needs Real Facts:</strong> An AI model cannot know if your system is safe just by reading a code snippet. It needs actual dry-run data from the real server.</li><li><strong>Keep Humans in the Loop:</strong> AI is a fantastic copilot for reading diffs and explaining risks. But deciding what actually changes on a production system must always remain the engineer’s responsibility.</li></ul><p>The goal of modern DevOps isn’t to remove human judgment. It is to build smart, safe systems that give engineers the visibility and confidence to move fast without breaking things.</p><p><strong>Build boldly. Automate thoughtfully. And never confuse autonomy with permission.</strong></p><p>P.S. This post is part of the DevOps Micro Internship with Agentic AI Cohort 3 by <a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">Pravin Mishra</a> (<a href="https://dmi.pravinmishra.com/">https://dmi.pravinmishra.com</a>) . You can begin your DevOps journey by joining the DMI waiting list. ( <a href="https://www.linkedin.com/safety/go/?url=https%3A%2F%2Flnkd.in%2Fd735Nsd7&amp;urlhash=awdv&amp;mt=qcQV2qn317G-nf9sbpffsLfSN2ZWQgvnC1UOxENJnpY9Ft3pSF1fAtAAq-ITH1oKZj6p6EAe-b-150SlRQXVaEQ8__kpd-8-ZFVIsIl1fVioVziolhjRdaWs4w&amp;isSdui=true">https://lnkd.in/d735Nsd7</a>)</p><p>View my progress here: (<a href="https://dmi.pravinmishra.com/s/Harietonyeabor.html">https://dmi.pravinmishra.com/s/Harietonyeabor.html</a>)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f5bd95e473d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I Let an AI Agent Audit My AWS Infrastructure (And Why I Still Refuse to Let It Run terraform…]]></title>
            <link>https://medium.com/@harietogochukwu/why-i-let-an-ai-agent-audit-my-aws-infrastructure-and-why-i-still-refuse-to-let-it-run-terraform-732665e8b084?source=rss-e05192996f59------2</link>
            <guid isPermaLink="false">https://medium.com/p/732665e8b084</guid>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Henrietta Ogochukwu Okechukwu]]></dc:creator>
            <pubDate>Tue, 01 Sep 2026 14:19:53 GMT</pubDate>
            <atom:updated>2026-09-12T19:59:27.454Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LKvXG-IfxjrFQPyKFdsd-w.png" /></figure><h3>Why I Let an AI Agent Audit My AWS Infrastructure (And Why I Still Refuse to Let It Run terraform apply)</h3><p>Every DevOps engineer knows the quiet dread of running terraform plan on a Friday afternoon only to see:</p><pre>Plan: 3 to add, 2 to change, 1 to destroy.</pre><p><em>Wait. Destroy? Who changed what in the console?</em></p><p>Infrastructure drift is one of the most frustrating challenges in cloud operations. When team members bypass Infrastructure as Code (IaC) to apply hotfixes directly in the AWS console, the source of truth shatters. If you blindly run terraform apply, you might drop a production database or overwrite a critical network fix.</p><p>Over the past week, I engineered a full 3-tier Book Review application on AWS using Terraform. But instead of stopping at deployment, I tackled the bigger operational question:</p><blockquote><strong><em>How can we use Agentic AI to detect drift and audit security risks without giving it the authority to accidentally nuke our cloud environment?</em></strong></blockquote><p>Here is how I built a production-grade 3-tier AWS infrastructure and wired an evidence-based, safety-gated AI drift workflow around it.</p><h3>Part 1: Architecting the 3-Tier Enterprise Stack</h3><p>Before you can detect drift, you need a deterministic baseline. I provisioned a multi-AZ AWS topology using modular Terraform:</p><ul><li><strong>Presentation Tier (Public Subnets):</strong> An internet-facing Public Application Load Balancer (ALB) routes incoming traffic across multi-AZ Nginx web instances serving a Next.js frontend.</li><li><strong>Logic Tier (Private Subnets):</strong> A fleet of Node.js/Express application instances managed by PM2, strictly shielded from the public internet and accessed only via an Internal ALB.</li><li><strong>Data Tier (Isolated Subnets):</strong> A Multi-AZ Amazon RDS MySQL cluster configured with automated failovers and least-privilege security groups allowing ingress on port 3306 <em>only</em> from the application tier.</li></ul><pre>[Internet]<br>    │<br>[Public ALB] ──&gt; [Web Tier: Next.js + Nginx] (Public Subnet)<br>                       │<br>             [Internal ALB] ──&gt; [App Tier: Node.js API] (Private Subnet)<br>                                     │<br>                               [RDS MySQL] (Isolated Data Subnet)</pre><p>By decoupling tiers across isolated subnets, the database and backend remain entirely invisible to the outside world.</p><h3>Part 2: The Drift Problem &amp; The Agentic Loop</h3><p>Deploying infrastructure is the easy part. Managing state divergence in a team environment is where systems break down.</p><p>To solve this, I designed an <strong>Agentic AI Review Loop</strong>:</p><p>$$\text{Gather Evidence} \longrightarrow \text{Analyze with AI} \longrightarrow \text{Human Review \&amp; Act} \longrightarrow \text{Verify}$$</p><p>The golden rule of this pipeline: <strong>Bash gathers facts. Claude analyzes context. The engineer approves mutations.</strong></p><pre>┌───────────────────────────────┐<br>       │     Bash + jq Automation      │ ──&gt; Gathers machine-readable facts<br>       └──────────────┬────────────────┘<br>                      ▼<br>       ┌───────────────────────────────┐<br>       │     Agentic AI (Claude)       │ ──&gt; Contextual reasoning &amp; risk analysis<br>       └──────────────┬────────────────┘<br>                      ▼<br>       ┌───────────────────────────────┐<br>       │     Human DevOps Engineer     │ ──&gt; Reviews &amp; executes manual apply<br>       └──────────────┬────────────────┘<br>                      ▼<br>       ┌───────────────────────────────┐<br>       │       Re-Verification         │ ──&gt; Confirms return to HEALTHY state<br>       └───────────────────────────────┘</pre><h3>Part 3: Deterministic Evidence Gathering (tf-drift-check.sh)</h3><p>Large Language Models (LLMs) are great at synthesis, but terrible at guessing whether infrastructure is safe without structured data. I wrote a Bash script that extracts hard evidence directly from the Terraform engine:</p><ul><li><strong>Leveraging Exit Codes:</strong> Runs terraform plan -detailed-exitcode.</li><li>0 = Clean (no drift).</li><li>1 = Terraform engine error.</li><li>2 = Pending infrastructure diff detected.</li><li><strong>Converting to Machine-Readable JSON:</strong> Converts execution plans into JSON via terraform show -json.</li><li><strong>Automated Policy Checks with </strong>jq<strong>:</strong></li><li><strong>Destructive Change Detector:</strong> Flags any plan action containing &quot;delete&quot;, catching full resource terminations and replacements before they happen.</li><li><strong>Ingress Guard:</strong> Scans security group updates for unauthorized open access (0.0.0.0/0 or *).</li></ul><h3>Part 4: The AI Drift Review Skill &amp; The Hard Safety Gate</h3><p>Once the structured report is generated, a custom Claude Code skill (/tf-drift-review) ingests the JSON artifact and performs a human-readable risk audit:</p><ul><li>Explains what changed in plain language (e.g., <em>“Web Tier security group opened port 22 to 0.0.0.0/0”</em>).</li><li>Assesses business and security impact.</li><li>Produces clear remediation steps for the engineer.</li></ul><h3>The Catch: Why Prompts Are Not Enough</h3><p>Telling an AI in a prompt <em>“Please do not apply changes”</em> is a suggestion, not a guarantee. Probabilistic models can hallucinate or misinterpret user intent under complex conditions.</p><p>To enforce zero-tolerance security, I implemented a PreToolUse<strong> hook</strong> in .claude/settings.json. The hook acts as a deterministic firewall in front of the execution shell:</p><pre># Intercepts every command before execution<br>if [[ &quot;$cmd&quot; =~ &quot;terraform apply&quot; ]] &amp;&amp; grep -q &quot;Overall Status: FAIL&quot; reports/tf-drift-report.txt; then<br>  echo &quot;SAFETY BLOCK: Cannot execute terraform apply while drift report has FAIL status.&quot; &gt;&amp;2<br>  exit 1<br>fi</pre><p>When tested, Claude Code actively refused unauthorized execution attempts:</p><blockquote><strong><em>Claude:</em></strong><em> </em>“I can’t do that. The project’s CLAUDE.md file includes explicit safety rules: Never run terraform apply automatically. Instead, review the findings and apply manually.”</blockquote><p>And if an agent ever tries to force a shell tool call, the PreToolUse hook drops the execution at the operating system level.</p><h3>Key Lessons from the Trenches</h3><ul><li><strong>Deterministic Guardrails Beat Prompt Engineering:</strong> Never trust high-impact actions solely to prompt instructions. Use deterministic runtime hooks to hard-block destructive commands.</li><li><strong>Standardized JSON &gt; Raw Terminal Logs:</strong> Parsing terraform show -json with jq provides an unshakeable, structured pipeline that eliminates regex failures across CLI versions.</li><li><strong>Keep the Human in the Loop:</strong> AI excels at synthesizing technical diffs into executive risk summaries, but accountability for state changes must always rest with the engineer.</li></ul><p>P.S. This post is part of the DevOps Micro Internship with Agentic AI Cohort 3 by <a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">Pravin Mishra</a> (<a href="https://dmi.pravinmishra.com/">https://dmi.pravinmishra.com</a>) . You can begin your DevOps journey by joining the DMI waiting list. ( <a href="https://www.linkedin.com/safety/go/?url=https%3A%2F%2Flnkd.in%2Fd735Nsd7&amp;urlhash=awdv&amp;mt=qcQV2qn317G-nf9sbpffsLfSN2ZWQgvnC1UOxENJnpY9Ft3pSF1fAtAAq-ITH1oKZj6p6EAe-b-150SlRQXVaEQ8__kpd-8-ZFVIsIl1fVioVziolhjRdaWs4w&amp;isSdui=true">https://lnkd.in/d735Nsd7</a>)</p><p>View my progress here: (<a href="https://dmi.pravinmishra.com/s/Harietonyeabor.html">https://dmi.pravinmishra.com/s/Harietonyeabor.html</a>)</p><p><em>What guardrails do you enforce before allowing automation to touch your production infrastructure? Let’s discuss in the comments below!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=732665e8b084" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Azure Infrastructure to AI-Assisted Cloud Security: What Week 7 of My DevOps Journey Taught Me]]></title>
            <link>https://medium.com/@harietogochukwu/from-azure-infrastructure-to-ai-assisted-cloud-security-what-week-7-of-my-devops-journey-taught-me-b540dc9f27c2?source=rss-e05192996f59------2</link>
            <guid isPermaLink="false">https://medium.com/p/b540dc9f27c2</guid>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[azure-devops]]></category>
            <category><![CDATA[microsoft-azure]]></category>
            <dc:creator><![CDATA[Henrietta Ogochukwu Okechukwu]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 14:43:34 GMT</pubDate>
            <atom:updated>2026-09-12T19:51:44.988Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I_m-SOxgP40jU6Vm6Gopuw.png" /></figure><p><strong>I started Week 7 thinking I was learning Azure. I finished it realizing I was learning something much bigger: how to build cloud systems that can be trusted.</strong></p><p>There is a difference between getting an application to work and building an infrastructure that can continue working securely when things change.</p><p>That difference became very clear to me during <strong>Week 7 of the DevOps Micro Internship (DMI) with Pravin Mishra</strong>.</p><p>This week took me from provisioning Azure resources and designing a three-tier architecture to building an AI-assisted security auditing workflow with <strong>Azure CLI, Bash, and Claude Code</strong>.</p><p>But the most valuable part wasn’t simply learning new Azure commands.</p><p>It was learning how <strong>architecture, security, automation, AI, and human judgment fit together.</strong></p><h3>Starting With the Foundation</h3><p>Every application needs somewhere to live.</p><p>But simply creating a virtual machine and putting an application on it isn’t enough.</p><p>I started the week by working with the building blocks of an Azure environment: resource groups, virtual machines, networking, subnets, routing, and storage.</p><p>One of the first things I had to think about was:</p><blockquote><strong><em>What should be public, and what should never be public?</em></strong></blockquote><p>That question became the foundation for everything that followed.</p><p>I designed a <strong>three-tier Azure architecture</strong> with separate layers for the web, application, and database workloads.</p><p>The idea was simple:</p><p><strong>Expose only what needs to be exposed.<br>Isolate everything else.</strong></p><h3>Designing the Three-Tier Architecture</h3><p>The architecture was divided into three major tiers:</p><h3>1. Web Tier</h3><p>This is the layer users interact with.</p><p>I deployed a frontend application on an Ubuntu Azure Virtual Machine and configured <strong>Nginx as a reverse proxy</strong>.</p><p>Instead of allowing users to communicate directly with the application services, Nginx acts as the controlled entry point.</p><p>This immediately reinforced something I had been learning in software engineering:</p><p><strong>Separation of concerns isn’t just a programming concept.</strong></p><p>It applies to infrastructure too.</p><h3>2. Application Tier</h3><p>Behind the web layer sits the application logic.</p><p>The backend was placed inside a <strong>private subnet</strong>, meaning it wasn’t directly exposed to the public internet.</p><p>An <strong>Azure Internal Load Balancer</strong> was used to distribute internal traffic to the application layer.</p><p>This creates another important boundary:</p><pre>Internet<br>   ↓<br>Web Tier<br>   ↓<br>Internal Load Balancer<br>   ↓<br>Application Tier<br>   ↓<br>Database Tier</pre><p>The user doesn’t need direct access to the backend.</p><p>And the backend doesn’t need to be publicly reachable.</p><p>That is defense in depth.</p><h3>3. Database Tier</h3><p>At the deepest layer sits the data.</p><p>For the database tier, I worked with <strong>Azure Database for MySQL Flexible Server</strong>.</p><p>The database was configured so that application traffic could reach it internally while unnecessary public exposure was restricted.</p><p>Credentials and connection information were also handled through environment variables rather than being hardcoded into the application.</p><p>Again, the principle was simple:</p><p><strong>Every layer should have a reason to trust the layer communicating with it.</strong></p><h3>Then Came the Part That Changed the Way I Think About Cloud Security</h3><p>Getting the application running was one thing.</p><p>Knowing whether the environment remained secure was another.</p><p>That led to my next question:</p><blockquote><strong><em>What happens when we automate security checks?</em></strong></blockquote><p>And more importantly:</p><blockquote><strong><em>How much control should we give an AI agent over real cloud infrastructure?</em></strong></blockquote><p>This is where the final assignment became particularly interesting.</p><p>Instead of allowing an AI agent to freely modify my Azure environment, I designed a workflow around a simple principle:</p><p><strong>Let the machine gather the facts.<br>Let AI help understand the facts.<br>Let the human make the change.<br>Then verify everything again.</strong></p><p>I called this the <strong>Agentic Loop</strong>.</p><h3>The Four-Phase Agentic Loop</h3><pre>┌────────────┐<br>│  1. GATHER │<br>│ Azure CLI  │<br>│ + Bash     │<br>└─────┬──────┘<br>      ↓<br>┌────────────┐<br>│ 2. ANALYZE │<br>│ Claude Code│<br>│ Read-Only  │<br>└─────┬──────┘<br>      ↓<br>┌────────────┐<br>│ 3. HUMAN   │<br>│    ACT     │<br>│ Engineer   │<br>└─────┬──────┘<br>      ↓<br>┌────────────┐<br>│ 4. VERIFY  │<br>│ Re-run     │<br>│ Audit      │<br>└────────────┘</pre><p>This became one of my biggest lessons from the entire week.</p><h3>Phase 1: Gather — Let the Script Find the Facts</h3><p>I created a Bash-based audit script:</p><pre>scripts/azure-audit.sh</pre><p>The script used the <strong>Azure CLI</strong> to inspect important security configurations.</p><p>Among the checks were:</p><ul><li>Network Security Groups and exposed management ports</li><li>Storage account public access</li><li>VM disk encryption status</li><li>MySQL public network access</li></ul><p>The goal wasn’t to make the script “smart.”</p><p>The goal was to make it <strong>deterministic</strong>.</p><p>The same infrastructure should produce the same security findings.</p><p>On the initial audit, one of the findings immediately stood out:</p><pre>[FAIL] NSG rule(s) allow inbound 0.0.0.0/0 on port 22/3389</pre><p>In other words, SSH access was exposed to the entire internet.</p><p>That is exactly the kind of configuration you don’t want to discover after an attack.</p><h3>Phase 2: Analyze — Where AI Enters the Picture</h3><p>This is where <strong>Claude Code</strong> came into the workflow.</p><p>I created a dedicated Azure audit skill that could read the audit results and help interpret them.</p><p>But there was an important restriction.</p><p>The AI was <strong>not given permission to modify the infrastructure.</strong></p><p>Its role was to:</p><ul><li>Read the audit report</li><li>Explain the security implications</li><li>Identify potential risks</li><li>Suggest an appropriate remediation command</li><li>Help the engineer understand what should change</li></ul><p>This distinction matters.</p><p>AI can be extremely useful in cloud operations.</p><p>But useful does not have to mean autonomous.</p><p>For infrastructure that can affect real users, data, and costs, I believe there is enormous value in keeping a <strong>human approval gate</strong> between recommendation and execution.</p><h3>Phase 3: Human Act — The Engineer Makes the Change</h3><p>The audit identified the problem.</p><p>Claude helped explain it.</p><p>But I still had to make the change.</p><p>I retrieved my workstation’s public IP address and restricted SSH access from:</p><pre>0.0.0.0/0</pre><p>to:</p><pre>&lt;my-ip&gt;/32</pre><p>That tiny change represents a major security improvement.</p><p>Instead of saying:</p><blockquote><em>“Anyone on the internet can attempt SSH access.”</em></blockquote><p>the rule effectively says:</p><blockquote><em>“Only this authorized address can connect.”</em></blockquote><p>That is the practical meaning of <strong>least privilege</strong>.</p><h3>Phase 4: Verify — Never Assume the Fix Worked</h3><p>This was perhaps the most important step.</p><p>I didn’t make the change and simply assume everything was fine.</p><p>I ran the audit again.</p><p>The result changed from:</p><pre>FAIL: 1<br>WARN: 1<br>PASS: 2</pre><p>to:</p><pre>FAIL: 0<br>WARN: 1<br>PASS: 2</pre><p>The unrestricted SSH finding was gone.</p><p>The infrastructure had been changed.</p><p>Then the system checked itself again.</p><p><strong>That closes the loop.</strong></p><h3>Something Interesting Happened When I Compared Azure With AWS</h3><p>This wasn’t my first cloud security audit.</p><p>The previous week, I worked through a similar workflow on <strong>AWS</strong>.</p><p>And comparing the two weeks revealed something I hadn’t fully appreciated before.</p><p>The commands are different.</p><p>The services are different.</p><p>The terminology is different.</p><p>But the <strong>security principles remain remarkably similar.</strong></p><p>Security ConcernAWSAzureNetwork accessSecurity GroupsNetwork Security GroupsObject storageS3Blob StorageDatabase isolationRDSMySQL Flexible ServerEncryptionEBS encryptionAzure disk encryptionPublic exposureSecurity Group rulesNSG rules</p><p>The cloud provider changes.</p><p>The engineering principles don’t.</p><p><strong>Least privilege remains least privilege.</strong></p><p><strong>Network isolation remains network isolation.</strong></p><p><strong>Defense in depth remains defense in depth.</strong></p><p>That realization was one of my biggest takeaways from moving between AWS and Azure.</p><h3>What Software Engineering Is Teaching Me About DevOps</h3><p>Interestingly, some of the concepts I am currently learning in my Software Engineering program are starting to make more sense when I apply them to cloud infrastructure.</p><p>Take <strong>encapsulation</strong>.</p><p>In software development, we encapsulate functionality and hide unnecessary internal details.</p><p>In cloud architecture, we can apply a similar mindset by isolating application components behind controlled interfaces and network boundaries.</p><p>Then there is <strong>abstraction</strong>.</p><p>Users shouldn’t need to understand everything happening underneath an application to use it.</p><p>The same principle applies to infrastructure.</p><p>A user interacts with the application.</p><p>They don’t need direct access to the database, backend servers, or internal services.</p><p>The architecture hides unnecessary complexity while controlling how the different components communicate.</p><p>Seeing these concepts appear in both software engineering and DevOps has helped me understand that they aren’t isolated subjects.</p><p>They are different pieces of the same engineering puzzle.</p><h3>The Biggest Lesson I Took Away</h3><p>At the beginning of the week, I thought I was learning how to deploy applications on Azure.</p><p>By the end, I realized I was learning something much more important:</p><p><strong>Good cloud engineering isn’t just about making systems work.</strong></p><p>It’s about making them:</p><ul><li><strong>Secure</strong></li><li><strong>Scalable</strong></li><li><strong>Isolated</strong></li><li><strong>Observable</strong></li><li><strong>Recoverable</strong></li><li><strong>Auditable</strong></li><li><strong>Maintainable</strong></li></ul><p>And when AI enters the picture, another question becomes critical:</p><blockquote><strong><em>How do we make AI useful without giving up control?</em></strong></blockquote><p>My answer, at least for this project, was:</p><p><strong>Gather → Analyze → Human Act → Verify.</strong></p><p>Not:</p><p><strong>Give AI the keys and hope for the best.</strong></p><h3>What’s Next?</h3><p>Week 7 strengthened my understanding of Azure networking, three-tier architecture, security boundaries, Bash automation, Azure CLI, and AI-assisted cloud governance.</p><p>It also gave me a stronger appreciation for something I am discovering throughout this DevOps journey:</p><p><strong>The goal isn’t to automate everything.</strong></p><p>The goal is to automate the right things, preserve the right controls, and continuously verify the result.</p><p>Next, I’m moving deeper into <strong>Infrastructure as Code and Terraform</strong>.</p><p>And I’m taking these lessons with me:</p><p><strong>Design intentionally.<br>Automate carefully.<br>Give AI boundaries.<br>Keep humans in the loop.<br>And always verify.</strong></p><p>This is still very much a learning journey for me, but every assignment is making the bigger picture a little clearer.</p><p>And honestly?</p><p>That’s the part I am enjoying most. 🚀</p><h3>About This Project</h3><p>P.S. This post is part of the DevOps Micro Internship with Agentic AI Cohort 3 by <a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">Pravin Mishra</a> (<a href="https://dmi.pravinmishra.com/">https://dmi.pravinmishra.com</a>) . You can begin your DevOps journey by joining the DMI waiting list. ( <a href="https://www.linkedin.com/safety/go/?url=https%3A%2F%2Flnkd.in%2Fd735Nsd7&amp;urlhash=awdv&amp;mt=qcQV2qn317G-nf9sbpffsLfSN2ZWQgvnC1UOxENJnpY9Ft3pSF1fAtAAq-ITH1oKZj6p6EAe-b-150SlRQXVaEQ8__kpd-8-ZFVIsIl1fVioVziolhjRdaWs4w&amp;isSdui=true">https://lnkd.in/d735Nsd7</a>)</p><p>View my progress here: (<a href="https://dmi.pravinmishra.com/s/Harietonyeabor.html">https://dmi.pravinmishra.com/s/Harietonyeabor.html</a>)</p><p>The project covered Azure infrastructure deployment, three-tier architecture, networking, security hardening, Bash automation, Azure CLI, Claude Code, and agentic cloud auditing.</p><p>If you’re also learning DevOps, cloud engineering, or AI-assisted infrastructure, I’d love to hear from you:</p><p><strong>What has been the biggest cloud engineering lesson you’ve learned so far?</strong></p><p>#DevOps #Azure #CloudEngineering #CloudSecurity #AgenticAI #ClaudeCode #AzureCLI #SoftwareEngineering #DevSecOps #CloudArchitecture #InfrastructureAsCode #LearningInPublic</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b540dc9f27c2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Architecting Resilient Cloud Systems: From a Three-Tier AWS Application to an AI-Assisted Security…]]></title>
            <link>https://medium.com/@harietogochukwu/architecting-resilient-cloud-systems-from-a-three-tier-aws-application-to-an-ai-assisted-security-f9de1bd7cbdb?source=rss-e05192996f59------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9de1bd7cbdb</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Henrietta Ogochukwu Okechukwu]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 13:56:15 GMT</pubDate>
            <atom:updated>2026-08-26T13:56:15.079Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_pmYRjoZhCApvWUFTVblKQ.png" /></figure><h3>Architecting Resilient Cloud Systems: From a Three-Tier AWS Application to an AI-Assisted Security Audit</h3><p><strong>What happens after your application works?</strong></p><p>That was the question I found myself asking during Week 6 of my DevOps Micro Internship with Agentic AI.</p><p>Getting an application running is one thing.</p><p>Getting it to survive failures, protect sensitive components, scale properly, and continuously tell you when something is wrong?</p><p>That is a completely different challenge.</p><p>This week took me beyond simply deploying an application. I had to think about <strong>architecture, availability, security, isolation, observability, and controlled automation</strong>.</p><p>I worked on two connected challenges:</p><ol><li>Deploying a resilient three-tier Book Review application on AWS.</li><li>Building an AI-assisted security and cost auditing workflow that could inspect the infrastructure without being allowed to modify it.</li></ol><p>3. And somewhere between troubleshooting reverse proxies and investigating an S3 security finding, I started seeing cloud infrastructure differently.</p><h3>From “It Works” to “What Happens When Something Goes Wrong?”</h3><p>My first instinct when learning cloud deployment was simple:</p><blockquote><em>Get the application running.</em></blockquote><p>But production systems demand better questions.</p><p>What happens if an EC2 instance fails?</p><p>What happens if an Availability Zone becomes unavailable?</p><p>Can users reach the database directly?</p><p>What happens if a security configuration changes?</p><p>Can we detect the problem before it becomes an incident?</p><p>And perhaps most importantly:</p><p><strong>Can we design the system so that failure in one component doesn’t bring everything down?</strong></p><p>Those questions shaped the architecture I built.</p><h3>1. Building the Three-Tier Architecture</h3><p>The application I worked with was a <strong>Book Review application</strong> deployed inside a custom AWS VPC using the 10.0.0.0/16 CIDR range across two Availability Zones in us-east-1.</p><p>Instead of putting everything on publicly accessible servers, I separated the application into three logical tiers:</p><pre>INTERNET<br>                       │<br>                       ▼<br>              ┌─────────────────┐<br>              │  Public ALB     │<br>              └────────┬────────┘<br>                       │<br>                       ▼<br>              ┌─────────────────┐<br>              │  Web Tier       │<br>              │ EC2 + Nginx     │<br>              │ Next.js + PM2   │<br>              └────────┬────────┘<br>                       │<br>                       ▼<br>              ┌─────────────────┐<br>              │  App Tier       │<br>              │ Node.js/Express │<br>              │ Private Subnet  │<br>              └────────┬────────┘<br>                       │<br>                       ▼<br>              ┌─────────────────┐<br>              │ Database Tier   │<br>              │ RDS MySQL       │<br>              │ Private Subnet  │<br>              └─────────────────┘</pre><p>The idea was straightforward:</p><p><strong>The public should reach the web layer, not everything behind it.</strong></p><p>The frontend lived in public subnets behind an Internet-facing Application Load Balancer.</p><p>The Node.js/Express API lived in private subnets.</p><p>The MySQL database lived even deeper in private subnets using Amazon RDS Multi-AZ.</p><p>This separation wasn’t just about organization.</p><p>It was about reducing the blast radius when something goes wrong.</p><h3>2. Why the Architecture Matters</h3><p>One thing software engineering has been teaching me is that good systems are rarely about one component working perfectly.</p><p>They’re about <strong>how components interact</strong>.</p><p>The web tier shouldn’t need unrestricted access to everything.</p><p>The application tier shouldn’t be directly exposed to the internet.</p><p>The database shouldn’t be sitting on a public subnet waiting for someone to discover it.</p><p>Instead, communication should happen through clearly defined boundaries.</p><p>This is where concepts I’ve been learning in software engineering started making much more sense to me.</p><p><strong>Encapsulation.</strong></p><p><strong>Abstraction.</strong></p><p><strong>Separation of concerns.</strong></p><p>These aren’t just terms to memorize for an exam.</p><p>They show up in real infrastructure.</p><p>The user doesn’t need to know how the database works.</p><p>The frontend doesn’t need direct access to the database.</p><p>The application doesn’t need to expose every internal implementation detail.</p><p>Each layer has a responsibility.</p><p>And each layer communicates through controlled interfaces.</p><p>That is software engineering thinking applied to cloud architecture.</p><h3>3. Then Everything Broke 😅</h3><p>Well… not everything.</p><p>But enough to remind me that architecture diagrams always look cleaner than real deployments.</p><p>During the deployment, I encountered <strong>504 Gateway Timeouts</strong> and frontend API requests returning errors such as:</p><pre>/api/api/books</pre><p>That tiny duplicated /api told me something was wrong with the way the frontend, reverse proxy, and backend were communicating.</p><p>So the debugging began.</p><p>I had to investigate:</p><ul><li>Security group rules</li><li>Nginx proxy configuration</li><li>Backend port 3001</li><li>Request paths</li><li>Forwarded headers</li><li>Next.js environment variables</li><li>Production builds</li></ul><p>One of the issues came down to how the API base URL and Nginx proxy_pass configuration interacted.</p><p>The frontend was effectively constructing a path that already contained /api, while the proxy configuration was adding it again.</p><p>The result?</p><pre>/api/api/books</pre><p>Not exactly what we wanted. 😅</p><p>After correcting the routing configuration and rebuilding the Next.js application with the appropriate API origin, requests began flowing correctly.</p><p>That debugging session taught me something important:</p><p><strong>A system can fail at the boundaries between components even when every individual component appears to be working.</strong></p><p>That is why understanding the architecture matters.</p><h3>4. Building the Security Audit</h3><p>Once the application was deployed, another question emerged:</p><p><strong>How do I know the infrastructure is still configured safely?</strong></p><p>This led to the second part of the work: building an <strong>AI-assisted AWS security and cost audit workflow</strong>.</p><p>I didn’t want an AI agent making unrestricted changes to my AWS environment.</p><p>That would be convenient.</p><p>It would also be dangerous.</p><p>Instead, I designed the workflow around four stages:</p><pre>GATHER<br>   ↓<br>ANALYZE<br>   ↓<br>HUMAN ACT<br>   ↓<br>VERIFY</pre><p>The goal was simple:</p><p><strong>Let automation investigate. Let AI explain. Let humans decide. Let the system verify.</strong></p><h3>5. Gather — Deterministic Infrastructure Checks</h3><p>The first stage uses Bash and AWS CLI commands to inspect the environment.</p><p>The audit checks several security and configuration areas, including:</p><ul><li>S3 public access settings</li><li>SSH exposure on port 22</li><li>MySQL exposure on port 3306</li><li>RDS public accessibility</li><li>EBS encryption</li></ul><p>The scripts are intentionally <strong>read-only</strong>.</p><p>They gather facts.</p><p>They don’t make decisions.</p><p>They don’t modify infrastructure.</p><p>They simply tell me:</p><blockquote><em>“This is what currently exists.”</em></blockquote><p>That distinction matters.</p><h3>6. Analyze — Bringing AI Into the Workflow</h3><p>This is where Claude Code enters the picture.</p><p>I connected the audit process to an /aws-audit skill designed to interpret the generated report.</p><p>The AI could:</p><ul><li>Analyze the findings</li><li>Explain potential risks</li><li>Identify areas requiring attention</li><li>Estimate potential cost implications</li><li>Recommend precise remediation commands</li></ul><p>But there was an important restriction:</p><p><strong>The AI had no write access to AWS.</strong></p><p>It could recommend.</p><p>It could explain.</p><p>It could reason about the findings.</p><p>But it could not independently change my infrastructure.</p><p>That kept the human engineer in the loop.</p><h3>7. Human Act — The Engineer Still Makes the Decision</h3><p>The audit identified an S3 configuration that needed attention.</p><p>The baseline report showed:</p><pre>[FAIL] S3 bucket does not block public ACLs</pre><p>Specifically:</p><pre>BlockPublicAcls=False<br>IgnorePublicAcls=False</pre><p>The AI explained the finding and generated a scoped remediation command.</p><p>But I still had to review and execute the change.</p><p>This was intentional.</p><p><strong>AI-assisted does not have to mean AI-controlled.</strong></p><p>For infrastructure, that distinction can be the difference between useful automation and an expensive mistake.</p><h3>8. Verify — Trust, But Verify</h3><p>After applying the remediation, I ran the audit again.</p><p>The result changed from:</p><pre>[FAIL] S3 bucket does not block public ACLs</pre><p>to:</p><pre>[PASS] S3 bucket blocks &amp; ignores public ACLs</pre><p>The overall status moved from:</p><pre>FAIL</pre><p>to:</p><pre>WARN</pre><p>The remaining warning related to EBS volumes that were not encrypted.</p><p>That was a valuable reminder:</p><p><strong>A change isn’t complete because you executed a command.</strong></p><p>It is complete when you verify that the desired state actually exists.</p><h3>9. The Bigger Lesson: Resilience Is a Design Decision</h3><p>This experience changed the way I think about DevOps.</p><p>I used to think of deployment as the finish line.</p><p>Now I see deployment as the beginning of another set of questions.</p><p>Can it scale?</p><p>Can it recover?</p><p>Can we isolate failures?</p><p>Can we detect misconfigurations?</p><p>Can we verify changes?</p><p>Can we safely automate repetitive work?</p><p>Can humans remain in control of high-impact decisions?</p><p>Those questions are where infrastructure engineering becomes much more interesting.</p><h3>What Software Engineering Is Teaching Me About DevOps</h3><p>Interestingly, the more I learn about DevOps, the more I see connections to the software engineering concepts I’m studying.</p><p><strong>Abstraction</strong> reminds us to hide unnecessary complexity.</p><p><strong>Encapsulation</strong> gives components clear boundaries.</p><p><strong>Separation of concerns</strong> prevents one layer from taking responsibility for everything.</p><p><strong>Modularity</strong> makes systems easier to change and maintain.</p><p>And <strong>good architecture</strong> helps us design for change instead of simply designing for today.</p><p>These ideas don’t stop at application code.</p><p>They extend into networks, infrastructure, security, deployment pipelines, and cloud architecture.</p><h3>My Biggest Takeaways</h3><h3>1. Architecture matters before failure happens.</h3><p>High availability isn’t something you bolt onto an application after disaster strikes.</p><p>You design for resilience from the beginning.</p><h3>2. Private doesn’t automatically mean secure.</h3><p>Security depends on the entire chain: routing, security groups, identity, application configuration, storage policies, and access controls.</p><h3>3. AI is powerful when paired with boundaries.</h3><p>I don’t need an AI agent with unrestricted AWS access to benefit from AI.</p><p>Read-only access plus human approval can provide a powerful balance between automation and safety.</p><h3>4. Verification is part of engineering.</h3><p>Never assume a configuration change worked.</p><p>Check it.</p><h3>5. “It works” is only the beginning.</h3><p>A production system needs more than functionality.</p><p>It needs <strong>reliability, security, maintainability, observability, and controlled change.</strong></p><h3>Final Thought</h3><p>This week reminded me why I decided to keep learning beyond just writing code.</p><p>I’m learning to look at systems differently.</p><p>Not just:</p><blockquote><em>“Does the application work?”</em></blockquote><p>But:</p><blockquote><em>“How is it designed?”</em></blockquote><blockquote><em>“What happens when something fails?”</em></blockquote><blockquote><em>“Who can access what?”</em></blockquote><blockquote><em>“How do the components communicate?”</em></blockquote><blockquote><em>“How do we know when something is wrong?”</em></blockquote><blockquote><em>“And how can we automate safely without removing human judgment?”</em></blockquote><p>I don’t have all the answers yet.</p><p>I’m still learning, breaking things, debugging them, asking questions, and occasionally staring at an error message wondering what I did wrong. 😅</p><p>But that’s the point of the journey.</p><p><strong>I’m not just learning how to deploy applications.</strong></p><p>I’m learning how to think about the systems that keep them running.</p><p>And that’s becoming one of the most exciting parts of my DevOps journey.</p><p><em>This work was completed as part of the DevOps Micro Internship (DMI) Cohort 3 with Agentic AI.</em></p><p>📌 My graded progress: <a href="https://lnkd.in/eyx_RBp5">https://lnkd.in/eyx_RBp5</a><br>📌 Start your DevOps journey: <a href="https://lnkd.in/eVW4aeZh">https://lnkd.in/eVW4aeZh</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9de1bd7cbdb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Week 5 of My DevOps Journey: From Planning and Deployment to AI-Assisted Sprint Health]]></title>
            <link>https://medium.com/@harietogochukwu/week-5-of-my-devops-journey-from-planning-and-deployment-to-ai-assisted-sprint-health-a848ad305098?source=rss-e05192996f59------2</link>
            <guid isPermaLink="false">https://medium.com/p/a848ad305098</guid>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Henrietta Ogochukwu Okechukwu]]></dc:creator>
            <pubDate>Wed, 12 Aug 2026 15:14:05 GMT</pubDate>
            <atom:updated>2026-08-12T15:14:05.076Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wki9ChvNB0M3znFxEVHVFg.png" /></figure><p>Week 5 of my <strong>DevOps Micro Internship (DMI) Cohort 3 — Agentic AI Track</strong> was one of those weeks where I stopped seeing DevOps as a collection of tools and started seeing it as a <strong>complete delivery lifecycle</strong>.</p><p>Across five assignments, I worked through different parts of the lifecycle — from planning and managing work in Jira, to writing code, committing changes with Git, deploying applications to EC2, verifying changes on a live website, reflecting through Scrum ceremonies, and finally using AI through Jira MCP to analyze sprint health.</p><p>What made the week especially interesting was that each assignment built on the previous one.</p><p>I wasn’t just learning commands.</p><p>I was learning how the pieces fit together.</p><h3>DevOps Is More Than Deployment</h3><p>Before this week, it was easy to associate DevOps mainly with things like:</p><ul><li>Git</li><li>Linux</li><li>AWS</li><li>CI/CD</li><li>Docker</li><li>Deployment</li></ul><p>But this week’s assignments reinforced something important for me:</p><blockquote><strong><em>DevOps is a way of continuously delivering value while maintaining visibility, collaboration, feedback, and improvement.</em></strong></blockquote><p>The technical work matters, but so does knowing:</p><ul><li>What are we building?</li><li>Why are we building it?</li><li>How do we track it?</li><li>How do we know it works?</li><li>How do we know what is happening in production?</li><li>How do we improve the process?</li></ul><p>That became the common thread across my five assignments.</p><h3>Assignment 1: Understanding the DevOps Delivery Lifecycle</h3><p>The first part of the week’s work helped establish the foundation for thinking about software delivery as a lifecycle rather than isolated technical activities.</p><p>Instead of looking at development, operations, project management, and deployment as separate responsibilities, I began connecting them as stages of one continuous process.</p><p>The general flow became much clearer:</p><p><strong>Plan → Code → Build → Test → Release → Deploy → Operate → Monitor → Improve</strong></p><p>This was important because later assignments required me to actually put that lifecycle into practice.</p><p>I learned that a good DevOps process is not simply:</p><blockquote><em>Write code → deploy → hope it works.</em></blockquote><p>It is closer to:</p><blockquote><em>Plan the change → implement it → track it → commit it → deploy it → verify it → collect evidence → learn from the result → improve.</em></blockquote><p>That mindset became the foundation for the rest of the week.</p><h3>Assignment 2: Turning Development Work Into a Repeatable Workflow</h3><p>The next stage helped me connect the technical side of development with the workflow required to deliver software reliably.</p><p>Git became more than just a place to store code.</p><p>A change needed to be:</p><ol><li>Clearly defined.</li><li>Implemented.</li><li>Committed with a meaningful message.</li><li>Deployed.</li><li>Verified.</li><li>Documented.</li></ol><p>This distinction was important to me.</p><p>A developer can say:</p><blockquote><em>“I changed the website.”</em></blockquote><p>But a DevOps-oriented workflow asks:</p><blockquote><em>“What changed, where was it committed, where was it deployed, and what evidence proves that the change is actually live?”</em></blockquote><p>That difference became very visible in the assignments that followed.</p><h3>Assignment 3: Running a Five-Day Mini-Sprint in Jira</h3><p>Assignment 3 took the DevOps lifecycle into a Scrum environment.</p><p>The goal was to run a <strong>five-day mini-Sprint in Jira</strong> and ship a real improvement to a portfolio website running on EC2.</p><p>The increment itself was intentionally small:</p><p><strong>A visible footer showing the portfolio version, deployment date, and author.</strong></p><p>The Sprint Goal was:</p><blockquote><em>Ship a visible Pravin Mishra Portfolio footer (version + deploy date + author) to EC2 and document progress daily in Jira.</em></blockquote><p>What made this assignment valuable was that I had to follow the work through the entire delivery cycle.</p><p>I created a Story with:</p><ul><li>A clear description</li><li>Acceptance criteria</li><li>A story point estimate</li><li>A frontend label</li></ul><p>Then I created five daily Sub-tasks:</p><ul><li>Day 1 — Implement footer &amp; deploy</li><li>Day 2 — Make deploy date dynamic</li><li>Day 3 — Polish &amp; accessibility</li><li>Day 4 — Change the Homepage Tagline / Call-to-Action</li><li>Day 5 — Demo + retro + burndown</li></ul><h3>From Jira Ticket to Live Website</h3><p>On Day 1, I implemented the footer and committed it to Git.</p><p>The commit followed a meaningful convention:</p><p>feat(footer): add version, deploy date, and author</p><p>I then transferred the project to EC2, updated the Nginx web root, tested the Nginx configuration, reloaded the service, and verified the result through the public website.</p><p>This gave me a very practical understanding of the relationship between:</p><p><strong>Jira → Git → EC2 → Nginx → Browser</strong></p><p>The ticket wasn’t truly valuable just because Jira showed it as “Done.”</p><p>The real evidence was that the feature was actually visible to a user.</p><h3>Incremental Delivery</h3><p>The assignment continued beyond the initial implementation.</p><p>I improved the deployment date behavior, documented it in the README, polished the footer for readability and accessibility, tested the site at different screen sizes, and changed the homepage tagline to a DevOps Micro Internship call-to-action.</p><p>That reinforced one of the biggest lessons from the assignment:</p><blockquote><strong><em>A feature doesn’t have to be large to demonstrate a complete delivery process.</em></strong></blockquote><p>Small increments can still go through planning, development, deployment, verification, documentation, and review.</p><h3>Assignment 4: Backlog Refinement and Sprint Planning with Gotto Job</h3><p>Assignment 4 moved the focus from running an existing Sprint to <strong>creating and refining a product backlog from scratch</strong>.</p><p>This time, the project was the <strong>Gotto Job</strong> website.</p><p>I worked in <strong>Solo Mode</strong>, which meant I had to perform all four Scrum roles:</p><ul><li>Product Owner</li><li>Scrum Master</li><li>Dev Lead</li><li>DevOps Lead</li></ul><p>This was surprisingly useful because it forced me to think about the same work from different perspectives.</p><h3>As Product Owner</h3><p>I had to decide which improvements provided the most value.</p><h3>As Scrum Master</h3><p>I had to make sure the process was followed and the Sprint remained focused.</p><h3>As Dev Lead</h3><p>I was responsible for implementing the selected UI improvement.</p><h3>As DevOps Lead</h3><p>I was responsible for committing, deploying, and verifying the change.</p><h3>Building a Value-Ordered Backlog</h3><p>I created an Epic:</p><p><strong>Improve Gotto Job UI discoverability &amp; trust</strong></p><p>Under that Epic, I refined Stories such as:</p><ul><li>Hero tagline clarity</li><li>Primary CTA color</li><li>Job card typography</li><li>REMOTE badge</li><li>Posted-on date</li><li>Advanced search labels</li><li>Job detail Apply Now CTA</li><li>Footer trust links</li></ul><p>The Stories were estimated using <strong>1, 2, or 3 story points</strong>.</p><p>The purpose wasn’t to pretend that I could predict the exact number of hours required.</p><p>Instead, the points helped communicate relative complexity.</p><p>For example:</p><p><strong>Hero tagline clarity — 1 point</strong></p><p>A simple text change.</p><p><strong>Job card typography — 2 points</strong></p><p>This required styling changes plus checking the resulting layout.</p><p><strong>REMOTE badge — 2 points</strong></p><p>This involved introducing a UI element and ensuring it appeared appropriately on relevant cards.</p><p>That was my practical introduction to the idea that:</p><blockquote><strong><em>Story points are about relative effort, complexity, and uncertainty — not exact hours.</em></strong></blockquote><h3>Sprint Planning</h3><p>After refining the backlog, I created <strong>Sprint 1</strong>.</p><p>The Sprint Goal was:</p><blockquote><strong><em>Ship 2–3 visible UI improvements to Gotto Job and show them live.</em></strong></blockquote><p>I selected a small number of Stories and broke them into four Sub-tasks:</p><p><strong>Build → Verify → Deploy → Screenshot</strong></p><p>This structure was particularly useful because it made “Done” more meaningful.</p><p>A Story wasn’t just something I coded.</p><p>I had to build it, verify it, deploy it, and capture evidence.</p><h3>Shipping the Gotto Job Increment</h3><p>For the actual increment, I selected the <strong>Hero Tagline</strong> Story.</p><p>The homepage originally had a different headline.</p><p>I changed it to:</p><p><strong>“Find your next role, fast.”</strong></p><p>I initialized the project as a Git repository, committed the change, deployed it to EC2, and verified the updated page through the live URL.</p><p>The workflow was once again:</p><p><strong>UI change → Git commit → EC2 deployment → Nginx → browser verification</strong></p><p>This was becoming a pattern.</p><p>And that was the point.</p><p>I wasn’t simply completing isolated assignments anymore.</p><p>I was repeating a delivery workflow.</p><h3>Burndown Charts and Retrospectives</h3><p>Another important part of Assignment 4 was opening the Jira <strong>Burndown Chart</strong>.</p><p>At first, the chart could be mostly empty because the Sprint had just started.</p><p>That itself taught me something.</p><p>A report doesn’t become useful simply because it exists.</p><p>It becomes useful when real work flows through the system.</p><p>I also completed a retrospective covering:</p><ul><li>What went well</li><li>What could be improved</li><li>A Scrum pillar</li><li>A Scrum value</li></ul><p>One important lesson was that Jira status needs to represent the actual state of the work.</p><p>If a Story says “Done” but its Sub-tasks still show incomplete work, the board is giving an inaccurate picture.</p><p>That led naturally to the next idea:</p><p><strong>Transparency requires accurate data.</strong></p><h3>Assignment 5: Bringing AI Into Sprint Health</h3><p>Assignment 5 was where the <strong>Agentic AI</strong> part of the internship became much more visible.</p><p>The goal was to connect <strong>Claude Code to Jira through an MCP server</strong> and build a read-only /sprint-health skill.</p><p>This was different from simply asking an AI chatbot:</p><blockquote><em>“How is my Sprint going?”</em></blockquote><p>The goal was for the AI to retrieve <strong>real Jira data</strong> through MCP.</p><h3>What Is MCP?</h3><p>MCP, or <strong>Model Context Protocol</strong>, provides a structured way for AI systems to interact with external tools and services.</p><p>In this assignment, Jira became one of those external systems.</p><p>I configured a Jira MCP server and connected it to Claude Code.</p><p>The setup involved:</p><ul><li>Creating a Jira API token</li><li>Configuring .mcp.json</li><li>Storing credentials securely in settings.local.json</li><li>Ensuring sensitive configuration remained outside version control</li><li>Restarting Claude Code</li><li>Verifying the connection through /mcp</li><li>Querying the live Jira Sprint</li></ul><p>One of the most important lessons was that the AI needed <strong>real access to the system</strong>, rather than relying on information I manually pasted into the conversation.</p><h3>Read-Only AI Was the Important Part</h3><p>The most interesting requirement of Assignment 5 was not simply getting AI to read Jira.</p><p>It was making sure the AI <strong>could not change Jira</strong>.</p><p>The /sprint-health skill was restricted to read-only Jira tools plus Read.</p><p>It deliberately excluded tools that could:</p><ul><li>Create issues</li><li>Update issues</li><li>Transition issues</li><li>Add comments</li></ul><p>This created an important boundary:</p><p><strong>AI can analyze.<br>Human remains responsible for changing the board.</strong></p><h3>Building /sprint-health</h3><p>The skill was designed to analyze the current Sprint and report things such as:</p><ul><li>Sprint velocity</li><li>Stories at risk of missing the Sprint</li><li>Items missing estimates</li></ul><p>The interesting part was that the report was based on live Jira state.</p><p>I could manually change something on the Jira board and run the skill again.</p><p>The report would then reflect the new state.</p><p>That demonstrated the distinction between:</p><p><strong>Reading the system</strong> and <strong>controlling the system</strong>.</p><h3>Gather → Analyze → Human Act → Verify</h3><p>This assignment also connected with an earlier DevOps/AI workflow I had been learning:</p><p><strong>Gather → Analyze → Human Act → Verify</strong></p><p>The AI can gather information.</p><p>It can analyze the information.</p><p>But the human remains responsible for the actual decision and action.</p><p>Then the system can be checked again to verify the result.</p><p>That principle is especially important when AI is connected to operational tools.</p><p>The fact that an AI <em>can</em> perform an action doesn’t necessarily mean it <em>should</em> be allowed to perform that action.</p><h3>The Security Lesson</h3><p>Another major lesson from Assignment 5 was credential management.</p><p>The Jira API token should never be placed directly inside .mcp.json.</p><p>Instead, sensitive values belong in local environment configuration such as:</p><p>.claude/settings.local.json</p><p>And that file must be protected through .gitignore.</p><p>This reminded me that automation introduces another responsibility:</p><blockquote><strong><em>The more systems we connect, the more carefully we need to control what the automation is allowed to access and change.</em></strong></blockquote><p>Least privilege isn’t just a security concept.</p><p>It is also an excellent way to design safer AI-assisted workflows.</p><h3>What Five Assignments Taught Me</h3><p>Looking back at Assignments 1–5, the biggest lesson wasn’t a particular Jira feature, Git command, AWS command, or MCP configuration.</p><p>It was the relationship between them.</p><p>I started seeing the DevOps lifecycle as a continuous loop:</p><p><strong>Plan</strong></p><p>↓</p><p><strong>Refine the work</strong></p><p>↓</p><p><strong>Build</strong></p><p>↓</p><p><strong>Commit</strong></p><p>↓</p><p><strong>Deploy</strong></p><p>↓</p><p><strong>Verify</strong></p><p>↓</p><p><strong>Observe</strong></p><p>↓</p><p><strong>Reflect</strong></p><p>↓</p><p><strong>Improve</strong></p><p>And now:</p><p><strong>Use AI to assist with analysis while keeping humans responsible for important actions.</strong></p><h3>Five Lessons I Am Taking Forward</h3><h3>1. Small increments can demonstrate big engineering practices</h3><p>Adding a footer or changing a headline may look insignificant.</p><p>But when that change goes through planning, Git, deployment, verification, documentation, and retrospective review, it becomes a real example of the delivery lifecycle.</p><h3>2. Jira is more useful when the data reflects reality</h3><p>A board is only as valuable as the accuracy of the information inside it.</p><p>Statuses, estimates, Sub-tasks, Sprint Goals, and comments should tell the truth about the state of the work.</p><h3>3. Deployment isn’t the end</h3><p>A successful command does not automatically mean a successful deployment.</p><p>The live application needs to be verified.</p><h3>4. AI needs boundaries</h3><p>Connecting AI to Jira is powerful.</p><p>But giving AI unrestricted permission to modify production work would introduce unnecessary risk.</p><p>Read-only access can provide significant value while keeping important decisions with humans.</p><h3>5. DevOps is continuous improvement</h3><p>The retrospective isn’t just an assignment requirement.</p><p>It represents a real engineering practice:</p><p><strong>What worked?<br>What didn’t?<br>What should we change next time?</strong></p><h3>From Learning Tools to Building a System</h3><p>One thing I appreciate about this week’s assignments is how connected they became.</p><p>Jira helped me plan and track the work.</p><p>Git helped me version the changes.</p><p>EC2 provided the deployment environment.</p><p>Nginx served the application.</p><p>The browser provided real-world verification.</p><p>Scrum provided the framework for planning and reflection.</p><p>Claude Code and MCP introduced AI-assisted analysis.</p><p>None of these tools alone is “DevOps.”</p><p>The value comes from connecting them into a reliable workflow.</p><h3>What’s Next?</h3><p>My goal isn’t to simply collect more tools.</p><p>I want to become better at designing and improving <strong>software delivery systems</strong>.</p><p>The next step for me is to keep moving from manual workflows toward more automation — particularly around CI/CD, testing, deployment, observability, and AI-assisted engineering workflows — while maintaining the human oversight that keeps those systems safe and trustworthy.</p><p>Week 5 reminded me that DevOps isn’t just about making software run.</p><p>It’s about building a process that makes <strong>delivery repeatable, visible, verifiable, and continuously improvable.</strong></p><p>And I’m only getting started. 🚀</p><p><strong>DevOps Micro Internship (DMI) Cohort 3 — Agentic AI Track</strong></p><p>This post is part of my journey in the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 by <a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">Pravin Mishra</a>.</p><p>📌 My graded progress: <a href="https://www.linkedin.com/safety/go/?url=https%3A%2F%2Flnkd%2Ein%2Feyx_RBp5&amp;urlhash=4ERx&amp;mt=oX3-26LJ6dNsHzPzyajRtMjCHBF6yZyfp36zE1NIt2hrDy8nLsec4qz2sdNRXzQ-VkVKF9N3bZ87NwO83gvZbl6NlC_z6b93imfExZxzMou3Rr1cKo1z98z8YA&amp;isSdui=true">https://lnkd.in/eyx_RBp5</a><br>📌 Start your DevOps journey: <a href="https://www.linkedin.com/safety/go/?url=https%3A%2F%2Flnkd%2Ein%2FeVW4aeZh&amp;urlhash=jK0T&amp;mt=HXQiL9bD2fzsbn0_ijs3eAnmlk-E5YZo090xwbknnVkarPDMFX_-KElFaxoesjvltpGYmfC1qEguyVxwZlSTOACUhFuFiaKm4BxoK2hVS7bKJgDQgx81vQnCIw&amp;isSdui=true">https://lnkd.in/eVW4aeZh</a></p><p>And yes… there’s still a lot more to learn. 🙌 😊</p><p><a href="https://www.linkedin.com/search/results/all/?keywords=%23devops&amp;origin=HASH_TAG_FROM_FEED">#DevOps</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23devopsengineering&amp;origin=HASH_TAG_FROM_FEED">#DevOpsEngineering</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23jira&amp;origin=HASH_TAG_FROM_FEED">#Jira</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23scrum&amp;origin=HASH_TAG_FROM_FEED">#Scrum</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23agile&amp;origin=HASH_TAG_FROM_FEED">#Agile</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23git&amp;origin=HASH_TAG_FROM_FEED">#Git</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23aws&amp;origin=HASH_TAG_FROM_FEED">#AWS</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23ec2&amp;origin=HASH_TAG_FROM_FEED">#EC2</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23softwareengineering&amp;origin=HASH_TAG_FROM_FEED">#SoftwareEngineering</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23continuousdelivery&amp;origin=HASH_TAG_FROM_FEED">#ContinuousDelivery</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23learninginpublic&amp;origin=HASH_TAG_FROM_FEED">#LearningInPublic</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23dmi&amp;origin=HASH_TAG_FROM_FEED">#DMI</a> <a href="https://www.linkedin.com/search/results/all/?keywords=%23devopsmicrointernship&amp;origin=HASH_TAG_FROM_FEED">#DevOpsMicroInternship</a> #Jira #Git #AWS #EC2 #MCP #ClaudeCode #AgenticAI #CloudComputing</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a848ad305098" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Code Brings Software to Life. Design Determines Whether It Survives.]]></title>
            <link>https://medium.com/@harietogochukwu/code-brings-software-to-life-design-determines-whether-it-survives-c28fef976e28?source=rss-e05192996f59------2</link>
            <guid isPermaLink="false">https://medium.com/p/c28fef976e28</guid>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[requirements-engineering]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Henrietta Ogochukwu Okechukwu]]></dc:creator>
            <pubDate>Wed, 29 Jul 2026 06:19:14 GMT</pubDate>
            <atom:updated>2026-07-29T06:19:14.508Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3fIhxOVLi6xbprGUJL6crQ.png" /></figure><h3>How twelve weeks of studying Object-Oriented Analysis and Design changed the way I think about building software.</h3><p>When I started this semester, I believed software engineering began the moment a developer opened an IDE and started writing code.</p><p>After all, that’s the part we usually see.</p><p>Someone has an idea.</p><p>They choose a programming language.</p><p>They write code.</p><p>They fix bugs.</p><p>They deploy an application.</p><p>It feels as though software comes to life one line of code at a time.</p><p>Then I studied <strong>Object-Oriented Analysis and Design (OOAD)</strong> as part of my Software Engineering degree at <strong>Miva Open University</strong>.</p><p>Somewhere between requirements analysis, UML diagrams, object relationships, and software architecture, I realized something that completely changed the way I think about software engineering.</p><p><strong>Software doesn’t begin with code.</strong></p><p>It begins with understanding.</p><p>Understanding the people you’re building for.</p><p>Understanding the problem they need solved.</p><p>Understanding how different parts of a system should work together.</p><p>Understanding how today’s decisions will affect tomorrow’s software.</p><p>That realization quietly changed my perspective.</p><p>Before this course, I usually thought about implementation first.</p><p>Now I find myself thinking about design.</p><p>Before asking,</p><p><em>“How do I build this?”</em></p><p>I now ask,</p><p><em>“What problem am I really trying to solve?”</em></p><p>Because if you misunderstand the problem, writing more code rarely fixes it.</p><p>It simply produces more code.</p><p>And that, to me, was the biggest lesson from twelve weeks of studying OOAD.</p><h3>I Thought UML Was Just Documentation</h3><p>When I first heard about <strong>Unified Modeling Language (UML)</strong>, I imagined boxes, arrows, and symbols that existed mainly to satisfy documentation requirements.</p><p>I couldn’t understand why software engineers spent so much time drawing diagrams instead of building software.</p><p>As the weeks went by, that assumption slowly disappeared.</p><p>I realized UML isn’t about creating beautiful diagrams.</p><p>It’s about creating a shared understanding.</p><p>A <strong>Use Case Diagram</strong> asks:</p><p><em>“Who interacts with this system?”</em></p><p>A <strong>Class Diagram</strong> asks:</p><p><em>“How should responsibilities be organized?”</em></p><p>A <strong>Sequence Diagram</strong> asks:</p><p><em>“How do different parts of the system communicate?”</em></p><p>An <strong>Activity Diagram</strong> asks:</p><p><em>“How does work actually flow through the system?”</em></p><p>Each diagram answers a different question.</p><p>Together, they help developers, designers, testers, project managers, and stakeholders see the same system from different perspectives before development begins.</p><p>That changed how I viewed software design.</p><p>The diagrams weren’t the destination.</p><p>They were tools for thinking.</p><h3>The Best Software Engineers Ask Better Questions</h3><p>One exercise during the course stayed with me.</p><p>Imagine someone asks you to build a hospital management system.</p><p>It’s tempting to start thinking about databases, programming languages, authentication, and user interfaces.</p><p>OOAD taught me to slow down.</p><p>Before writing a single line of code, good software engineers ask questions.</p><p>Who will use the system?</p><p>Doctors?</p><p>Patients?</p><p>Nurses?</p><p>Receptionists?</p><p>Administrators?</p><p>What problems are each of them trying to solve?</p><p>What information do they need?</p><p>How do they interact?</p><p>What happens when requirements change?</p><p>Only after those questions are answered does the design begin.</p><p>That simple shift completely changed how I approach software projects.</p><p>Software engineering isn’t just about finding solutions.</p><p>It’s about understanding problems deeply enough to design the right solution.</p><h3>Every Relationship Tells a Story</h3><p>One of the concepts I found most interesting was learning how objects relate to one another.</p><p>At first, terms like <strong>association</strong>, <strong>aggregation</strong>, <strong>composition</strong>, <strong>inheritance</strong>, and <strong>dependency</strong> felt like complicated definitions I simply had to memorize.</p><p>Over time, they became much more meaningful.</p><p>Every relationship tells part of the story of a system.</p><p>Some objects simply know about each other.</p><p>Others cannot exist without one another.</p><p>Some inherit behaviour.</p><p>Others collaborate while remaining independent.</p><p>Understanding these relationships isn’t just about passing an exam.</p><p>It’s about designing software that’s easier to understand, maintain, and extend as it grows.</p><h3>Building Software Is an Iterative Process</h3><p>Another lesson that stayed with me was that good software is rarely designed perfectly on the first attempt.</p><p>Instead, good software evolves.</p><p>Design.</p><p>Build.</p><p>Test.</p><p>Improve.</p><p>Repeat.</p><p>We explored concepts like <strong>iterative development</strong>, <strong>traceability</strong>, and <strong>refactoring</strong>.</p><p>Before this course, I thought refactoring simply meant rewriting code.</p><p>Now I understand that it’s about improving the internal structure of software without changing what users experience.</p><p>It’s a reminder that software engineering isn’t just about adding new features.</p><p>Sometimes the most valuable work is making existing systems cleaner, simpler, and easier to maintain.</p><h3>Features Alone Don’t Make Software Successful</h3><p>One of the biggest mindset shifts came when we studied <strong>Non-Functional Requirements (NFRs).</strong></p><p>Before this course, I naturally focused on features.</p><p>Can users log in?</p><p>Can they make payments?</p><p>Can they search for products?</p><p>Can they complete a transaction?</p><p>But a system can include every requested feature and still fail.</p><p>If it’s slow, users become frustrated.</p><p>If it’s insecure, users lose trust.</p><p>If it can’t scale, it struggles as demand grows.</p><p>If it’s difficult to maintain, every future update becomes more expensive.</p><p>This course reminded me that software isn’t judged only by what it does.</p><p>It’s also judged by how well it does it.</p><p>Performance.</p><p>Security.</p><p>Reliability.</p><p>Scalability.</p><p>Maintainability.</p><p>Accessibility.</p><p>These aren’t extras.</p><p>They’re part of the design.</p><h3>When Software Grows, Design Matters Even More</h3><p>One part of the course I particularly enjoyed was studying how companies like <strong>Netflix</strong> and <strong>Spotify</strong> evolved their software over time.</p><p>Before this course, I assumed they simply wrote more code as their platforms expanded.</p><p>I now understand that growth required something much deeper.</p><p>They redesigned their architecture.</p><p>They embraced modular systems.</p><p>They adopted microservices.</p><p>They continuously refactored.</p><p>They built cloud-native platforms capable of evolving alongside millions of users.</p><p>The technologies themselves are impressive.</p><p>But the real lesson wasn’t about Netflix or Spotify.</p><p>It was realizing that successful software isn’t built by continuously adding more code.</p><p>It’s built by continuously improving the way that code is organized.</p><h3>My Biggest Takeaway</h3><p>When this course began, I thought software engineering was mostly about programming.</p><p>Today, I see programming as only one part of the process.</p><p>Long before developers write code, they identify problems.</p><p>Gather requirements.</p><p>Model systems.</p><p>Explore trade-offs.</p><p>Design relationships.</p><p>Think about scalability.</p><p>Plan for maintenance.</p><p>Only then does implementation begin.</p><p>Perhaps that’s why experienced software engineers spend so much time thinking before they start typing.</p><p>They’re not delaying development.</p><p>They’re reducing future problems.</p><p>And that’s a lesson I hope to carry into every project I build.</p><p>I still enjoy writing code.</p><p>But now I appreciate something I hadn’t fully understood before.</p><p><strong>Code brings software to life.</strong></p><p><strong>Design determines whether it survives.</strong></p><h3>Looking Ahead</h3><p>This course has given me more than an understanding of UML or object-oriented design principles.</p><p>It has given me a different way of thinking.</p><p>As I continue studying Software Engineering, I know there are still many topics ahead — operating systems, distributed computing, cybersecurity, artificial intelligence, and much more.</p><p>But I have a feeling the lessons from OOAD will continue to influence how I approach each of them.</p><p>Because technologies will change.</p><p>Frameworks will evolve.</p><p>Programming languages will come and go.</p><p>But thoughtful design will always matter.</p><p>And perhaps that’s the greatest lesson this course gave me.</p><p>Not how to draw better diagrams.</p><p>But how to think more carefully before building anything.</p><h3>Thank you for reading.</h3><p>If you’re studying Software Engineering — or transitioning into tech — I hope this reflection encourages you to look beyond the code and appreciate the thinking that shapes it.</p><p>I’d love to hear from you:</p><p><strong>What’s one lesson or concept that has completely changed the way you think about building software?</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c28fef976e28" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Traditional Networks to AI-Powered Infrastructure: My Journey Learning Software-Defined…]]></title>
            <link>https://medium.com/@harietogochukwu/from-traditional-networks-to-ai-powered-infrastructure-my-journey-learning-software-defined-c0061f908caf?source=rss-e05192996f59------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0061f908caf</guid>
            <category><![CDATA[router]]></category>
            <category><![CDATA[dns]]></category>
            <category><![CDATA[control-plane]]></category>
            <category><![CDATA[cable]]></category>
            <category><![CDATA[data-plane]]></category>
            <dc:creator><![CDATA[Henrietta Ogochukwu Okechukwu]]></dc:creator>
            <pubDate>Sun, 26 Jul 2026 07:53:10 GMT</pubDate>
            <atom:updated>2026-07-26T07:53:10.770Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PZgz4Y0O4b1QK4cwyD5isA.png" /></figure><h3>From Traditional Networks to AI-Powered Infrastructure: My Journey Learning Software-Defined Networking (SDN)</h3><p><em>“The future of networking isn’t just about connecting devices anymore — it’s about making networks intelligent, programmable, and capable of making decisions on their own.”</em></p><p>Over the past few weeks, I’ve been studying <strong>Software-Defined Networking (SDN)</strong> as part of my Software Engineering degree at <strong>Miva Open University</strong>.</p><p>Before taking this course, I viewed networking as the process of connecting computers, configuring routers, assigning IP addresses, and ensuring data reached its destination.</p><p>While those fundamentals are still important, this course completely changed how I think about modern networks.</p><p>I discovered that today’s networks are gradually becoming software systems — programmable, automated, intelligent, and increasingly driven by Artificial Intelligence.</p><p>Here’s what I learned.</p><h3>It All Started with a Simple Question</h3><p>How do companies like Google, Microsoft, Amazon, Netflix, and Meta manage millions — even billions — of network connections every day?</p><p>Surely engineers aren’t manually configuring every router and switch.</p><p>The answer lies in <strong>Software-Defined Networking (SDN).</strong></p><p>Instead of configuring every network device individually, SDN introduces a centralized controller that manages the entire network from one place.</p><p>One of the simplest ways to understand SDN is to think of a human body.</p><ul><li>The <strong>brain</strong> makes decisions.</li><li>The <strong>nervous system</strong> carries those decisions throughout the body.</li></ul><p>Similarly,</p><ul><li>the <strong>Control Plane</strong> acts as the brain, deciding where traffic should go.</li><li>the <strong>Data Plane</strong> simply forwards packets according to those instructions.</li></ul><p>Separating these two functions is one of the biggest innovations in modern networking.</p><h3>Why Traditional Networks Needed to Change</h3><p>Traditional networking worked well for many years.</p><p>However, as organizations grew, several problems became obvious:</p><ul><li>Every router had to be configured individually.</li><li>Expanding the network became slow.</li><li>Managing thousands of devices became difficult.</li><li>Troubleshooting required significant manual effort.</li><li>Hardware vendors often locked organizations into proprietary solutions.</li></ul><p>Imagine managing traffic lights in an entire country by visiting every intersection whenever traffic patterns changed.</p><p>That’s essentially how traditional networks operated.</p><p>SDN replaces that approach with centralized intelligence.</p><p>One controller can update the entire network almost instantly.</p><h3>OpenFlow: The Language Between the Brain and the Network</h3><p>One concept I particularly enjoyed learning was <strong>OpenFlow</strong>.</p><p>If the SDN controller is the brain, OpenFlow acts like the language the brain uses to communicate with switches.</p><p>Instead of logging into every switch separately, the controller sends forwarding instructions through OpenFlow.</p><p>This allows:</p><ul><li>centralized management,</li><li>dynamic routing,</li><li>faster configuration,</li><li>and greater flexibility.</li></ul><p>It also explains why SDN is often described as <strong>programmable networking</strong>.</p><h3>Network Functions No Longer Need Dedicated Hardware</h3><p>Another interesting concept was <strong>Network Function Virtualization (NFV).</strong></p><p>Traditionally, organizations purchased separate hardware appliances for services like:</p><ul><li>firewalls,</li><li>load balancers,</li><li>VPN gateways,</li><li>intrusion detection systems,</li><li>and proxies.</li></ul><p>NFV changes this completely.</p><p>These services can now run as software on standard servers.</p><p>This reduces hardware costs, simplifies deployment, and makes scaling much easier.</p><p>Instead of buying another appliance, organizations simply deploy another virtual network function.</p><h3>Centralized Control Comes with Trade-offs</h3><p>One lesson that stood out was that every technological advantage introduces new challenges.</p><p>Centralizing network control makes management much easier.</p><p>However, it also creates a potential <strong>single point of failure.</strong></p><p>If attackers compromise the SDN controller, they could potentially affect the entire network.</p><p>That makes security even more important.</p><p>The course introduced several methods for protecting SDN environments, including:</p><ul><li>Role-Based Access Control (RBAC)</li><li>Multi-Factor Authentication (MFA)</li><li>Transport Layer Security (TLS)</li><li>IPSec</li><li>encryption</li><li>anomaly detection</li><li>intrusion detection systems</li><li>continuous monitoring</li><li>regular security audits</li></ul><p>I realized that security is no longer something added after deployment.</p><p>It must be designed into the network from the beginning.</p><h3>Automation Is Transforming Network Management</h3><p>Perhaps my favorite section of the course focused on automation.</p><p>Managing thousands of devices manually is no longer realistic.</p><p>Modern organizations increasingly rely on automation tools such as:</p><ul><li>Ansible</li><li>Terraform</li><li>OpenDaylight</li><li>ONOS</li><li>Kubernetes</li></ul><p>These tools can automatically:</p><ul><li>deploy configurations,</li><li>enforce security policies,</li><li>provision new services,</li><li>monitor network health,</li><li>and recover from failures.</li></ul><p>Instead of engineers spending hours performing repetitive tasks, automation allows them to focus on solving more complex problems.</p><p>It reminded me of an aircraft’s autopilot.</p><p>The pilot remains in control, but automation handles routine operations, improving both efficiency and safety.</p><h3>Artificial Intelligence Is Changing Networking</h3><p>The final weeks of the course explored where networking is heading.</p><p>Artificial Intelligence and Machine Learning are making SDN far more intelligent than traditional networks.</p><p>Rather than waiting for engineers to notice problems, AI can:</p><ul><li>predict traffic congestion,</li><li>identify abnormal behavior,</li><li>detect cyberattacks,</li><li>optimize routing decisions,</li><li>allocate resources automatically,</li><li>and even support self-healing networks.</li></ul><p>One concept that fascinated me was <strong>predictive networking</strong>.</p><p>Instead of reacting after failures occur, networks can anticipate issues and prevent them before users are even aware of them.</p><p>That represents a major shift in how modern infrastructure operates.</p><h3>SDN Is Powering Tomorrow’s Technologies</h3><p>Another important realization was that SDN doesn’t exist in isolation.</p><p>It serves as the foundation for many technologies we hear about every day.</p><p>These include:</p><ul><li>Artificial Intelligence</li><li>Machine Learning</li><li>Edge Computing</li><li>Internet of Things (IoT)</li><li>5G Networks</li><li>Multi-Cloud Environments</li><li>AIOps</li><li>Smart Cities</li><li>Quantum Networking</li></ul><p>As billions of connected devices continue generating enormous amounts of data, intelligent network management becomes essential.</p><p>SDN provides the flexibility needed to support this rapidly evolving digital ecosystem.</p><h3>What This Course Taught Me Beyond Networking</h3><p>This course wasn’t only about routers, switches, or protocols.</p><p>It demonstrated how software is transforming nearly every area of technology.</p><p>Networks are no longer static infrastructure.</p><p>They are becoming programmable platforms capable of adapting in real time.</p><p>As someone studying Software Engineering while also building skills in Project Management and DevOps, I found this especially valuable.</p><p>It reinforced something I’ve been seeing across many areas of technology:</p><p><strong>Infrastructure is becoming software.</strong></p><p>And software is becoming increasingly intelligent.</p><h3>Final Thoughts</h3><p>One of the biggest lessons I take away from this course is that modern networking is no longer simply about moving packets from one location to another.</p><p>It’s about building systems that can:</p><ul><li>think,</li><li>learn,</li><li>adapt,</li><li>automate,</li><li>secure themselves,</li><li>and scale to meet constantly changing demands.</li></ul><p>Software-Defined Networking is more than a networking concept.</p><p>It’s one of the technologies enabling cloud computing, AI, automation, and the next generation of digital transformation.</p><p>I’m excited to continue learning how these technologies intersect because the future of software engineering isn’t limited to writing applications.</p><p>It’s also about understanding the intelligent infrastructure that powers them.</p><p>Every course reminds me that learning is cumulative.</p><p>Each concept becomes another building block toward becoming a better software engineer.</p><p>And this is only the beginning.</p><p><em>Thank you for reading.</em></p><p>If you’re currently learning Software-Defined Networking or exploring modern networking technologies, I’d love to hear what concepts fascinated you the most.</p><p>Let’s learn together.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0061f908caf" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>