<?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 Sarahamadi on Medium]]></title>
        <description><![CDATA[Stories by Sarahamadi on Medium]]></description>
        <link>https://medium.com/@sarahamadi97?source=rss-db65f5f81408------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*0MF_33pl60fIJ1oX</url>
            <title>Stories by Sarahamadi on Medium</title>
            <link>https://medium.com/@sarahamadi97?source=rss-db65f5f81408------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 12:28:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sarahamadi97/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[Building Resilient Applications on Kubernetes: From Pods to AI-Assisted Incident Triage]]></title>
            <link>https://medium.com/@sarahamadi97/building-resilient-applications-on-kubernetes-from-pods-to-ai-assisted-incident-triage-48315ca63e76?source=rss-db65f5f81408------2</link>
            <guid isPermaLink="false">https://medium.com/p/48315ca63e76</guid>
            <category><![CDATA[women-in-tech]]></category>
            <category><![CDATA[azure-kubernetes-service]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Sarahamadi]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 10:19:50 GMT</pubDate>
            <atom:updated>2026-11-19T10:19:50.501Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oy3BQSF8nM703sZWqKaslg.png" /><figcaption>Kubernetes</figcaption></figure><p><em>My journey through 11 Kubernetes projects in the DMI DevOps</em></p><p>There is something satisfying about seeing a system work as intended. Not just because the application opens in a browser, but because you understand what is happening behind the scenes: how its components communicate, how it responds when something goes wrong, and what keeps it available.</p><p>That is what made my Kubernetes projects in the DevOps Micro Internship (DMI) particularly interesting.</p><p>Kubernetes can initially feel like a room full of unfamiliar controls. Pods, Deployments, ReplicaSets, Services, ConfigMaps, Secrets, probes and autoscalers all have their own responsibilities. But as I worked through the projects, I began to see how these pieces fit together.</p><p>I also found useful parallels with everyday life. Think about coordinating a household: people have different responsibilities, supplies need to be available, communication matters, and a backup plan is essential when something does not go as expected. A well-managed Kubernetes environment follows a similar principle. Each component has a role, and the system needs a way to coordinate them.</p><p>Here are some of the key things I worked through across the 11 Kubernetes projects.</p><h3>1. Starting with Pods: Understanding the smallest building block</h3><p>My first project focused on creating and inspecting an NGINX Pod.</p><p>I used both imperative commands and declarative YAML to create the Pod. I then inspected its status, explored its configuration, viewed its logs and accessed the container using kubectl exec.</p><p>One useful distinction became clear: creating a Pod is not the same as managing an application for long-term reliability.</p><p>A Pod is the smallest deployable unit in Kubernetes. It runs one or more containers, but a standalone Pod does not automatically provide the full self-healing and scaling capabilities we expect from a production application.</p><p>It is a little like assigning someone a task without establishing who will take over if they become unavailable. The work may get done, but continuity is not guaranteed.</p><p>That led naturally to the next project.</p><h3>2. ReplicaSets: Keeping the required number of Pods available</h3><p>In the second project, I worked with ReplicaSets.</p><p>I created a ReplicaSet named nginx-replicaset, initially configured to maintain three NGINX replicas. I then increased the desired number to five and tested what happened when a Pod was deleted.</p><p>Kubernetes created a replacement automatically.</p><p>This is one of the ideas that makes orchestration powerful: instead of relying on someone to notice that a component has disappeared and manually recreate it, Kubernetes continuously compares the actual state with the desired state.</p><p>Imagine planning for five people to cover five responsibilities. If one person becomes unavailable, the plan needs to account for that gap. A ReplicaSet does something similar for Pods, maintaining the requested number of replicas.</p><p>It is important to understand that ReplicaSets are generally managed through Deployments rather than created directly for most application workloads. That distinction became clearer in the next project.</p><h3>3. Deployments: Updating applications without losing control</h3><p>Deployments introduced another important capability: controlled application updates.</p><p>I created an NGINX Deployment with two replicas using image version nginx:1.21.1. I then updated it to nginx:1.23.1, observed the rollout and practised rolling back to the earlier version.</p><p>I also scaled the Deployment from two replicas to five, then returned it to two.</p><p>The project demonstrated why Deployments are so useful. They manage ReplicaSets, support rolling updates and provide a way to return to a previous revision when an update does not go as expected.</p><p>I also worked with RollingUpdate settings, including:</p><ul><li>maxSurge: 1, which controls how many additional Pods may be created during an update.</li><li>maxUnavailable: 0, which aims to keep the existing desired capacity available during the rollout.</li></ul><p>This reminded me of making changes to an established process. You do not necessarily need to replace everything at once. You can introduce the change gradually, observe the result and retain a way to reverse it.</p><h3>4. Configuration and application settings</h3><p>An application needs more than a container image. It also needs configuration: environment-specific settings, connection details and other values that influence how it behaves.</p><p>Kubernetes provides ConfigMaps and Secrets for separating configuration from application images.</p><p>A ConfigMap is intended for non-sensitive configuration. A Secret is intended for sensitive values such as credentials.</p><p>The distinction matters. Imagine keeping household instructions in one place and confidential documents somewhere more secure. Both are necessary, but they should not be handled in exactly the same way.</p><p>The important engineering principle is to avoid embedding credentials directly in container images or committing actual sensitive values to source control. Secrets also require appropriate access controls and careful handling; simply creating a Kubernetes Secret does not automatically make its contents secure in every environment.</p><h3>5. Readiness probes: Knowing when an application is ready</h3><p>A container can be running without being ready to receive traffic.</p><p>That distinction was at the centre of my readiness-probe work.</p><p>I configured an NGINX readiness probe to check the application at / on port 80. I then deliberately changed the path to /does-not-exist to observe the effect of a failed readiness check.</p><p>The rollout stalled because the Pod was not considered ready. After correcting the path, the application could pass the readiness check.</p><p>This is an important distinction in Kubernetes:</p><p><strong>Running does not necessarily mean ready.</strong></p><p>Think about preparing for guests. The fact that someone has arrived at the house does not mean everything is ready for them. The room may still need arranging, or the meal may not be ready to serve.</p><p>A readiness probe helps Kubernetes decide whether a container should receive traffic. If it fails, the Pod can remain running while being removed from the Service’s ready endpoints.</p><h3>6. Liveness probes: Detecting when an application needs restarting</h3><p>Readiness and liveness probes serve different purposes.</p><p>While readiness determines whether a container should receive traffic, a liveness probe helps Kubernetes determine whether a container is unhealthy and should be restarted.</p><p>I tested this by configuring an invalid NGINX health-check path. The endpoint returned HTTP 404 responses, the liveness checks failed repeatedly, and Kubernetes restarted the affected containers. I observed the restart counts and CrashLoopBackOff state.</p><p>The experience reinforced why health checks must be designed carefully.</p><p>A badly configured liveness probe can make a situation worse by repeatedly restarting an application that might otherwise have continued running. A good probe should test a meaningful indicator of application health, not simply introduce another source of failure.</p><h3>7. ClusterIP Services: Connecting components inside the cluster</h3><p>Pods are temporary. They can be replaced, recreated or moved. Their IP addresses should therefore not be treated as permanent application addresses.</p><p>Kubernetes Services solve this problem by providing a stable way to reach a group of Pods.</p><p>I worked with a ClusterIP Service named nginx-svc, explored how its selector matched Pods and tested service discovery through Kubernetes DNS.</p><p>I also deliberately changed the selector to break the match. The Service then had no endpoints.</p><p>That was a useful demonstration: a Service can exist and still have nowhere to send traffic.</p><p>This is similar to having a contact saved in a shared directory, but the contact details no longer point to the intended person. The directory entry exists, but the connection is not useful.</p><p>I also observed how readiness affects Service endpoints. An unhealthy or unready Pod should not receive normal application traffic through the Service.</p><h3>8. NodePort Services: Exploring access from outside the cluster</h3><p>The next stage involved NodePort Services.</p><p>Unlike ClusterIP, which is intended for internal cluster communication, NodePort exposes a Service through a port on each Kubernetes node.</p><p>This provides another way to access an application from outside the cluster, although it is not automatically the preferred production exposure method.</p><p>I worked with an NGINX Deployment and a NodePort Service, focusing on the relationship between the Service selector, the Pods it targets and the port used for access.</p><p>The important lesson is that exposing an application is not simply a matter of opening a port. The Service must select the correct Pods, those Pods must be ready, and the network path must allow the request to reach the application.</p><h3>9. LoadBalancer Services: Making an application externally accessible</h3><p>The LoadBalancer project brought the networking concepts together.</p><p>I deployed NGINX on Azure Kubernetes Service (AKS), scaled the Deployment from two replicas to four and exposed it using a LoadBalancer Service.</p><p>The results provided useful evidence:</p><ul><li>All four Pods reached 1/1 Running.</li><li>The LoadBalancer received the public IP address 4.152.64.123.</li><li>A request using curl returned HTTP/1.1 200 OK.</li><li>The EndpointSlice showed four backends.</li></ul><p>This was a particularly useful milestone because it connected the Kubernetes resources to an externally accessible application.</p><p>A LoadBalancer Service provides an external entry point, while Kubernetes distributes traffic to the Service’s eligible backends.</p><p>The distinction between internal and external networking is important. Not every component needs to be publicly accessible. A frontend may need an external entry point, while a backend or database should generally remain internal unless there is a specific, secured reason to expose it.</p><h3>10. Deploying the Book Review application: Bringing the pieces together</h3><p>Individual Kubernetes concepts become much more meaningful when they are used together in an application.</p><p>The Book Review application project brought the focus to a three-tier architecture:</p><ol><li><strong>Frontend:</strong> The user-facing application, built with Next.js and served behind NGINX.</li><li><strong>Backend:</strong> A Node.js and Express application responsible for application logic and API requests.</li><li><strong>Database:</strong> MySQL, responsible for storing application data.</li></ol><p>The Kubernetes architecture used the book-review namespace to keep the application&#39;s resources organised.</p><p>The design also required careful separation of responsibilities:</p><ul><li>ConfigMaps and Secrets for configuration and credentials.</li><li>Persistent storage for MySQL data.</li><li>An internal ClusterIP Service for backend communication.</li><li>NGINX reverse proxying to route API requests to the backend.</li><li>External access through the frontend, without making the backend and database publicly accessible.</li></ul><p>One of the most useful parts was validating the application as a complete system rather than looking at each Pod in isolation.</p><p>The recorded AKS workload status showed:</p><ul><li>Backend: 1/1 Running.</li><li>Frontend: 2/2 Running.</li><li>MySQL: 1/1 Running.</li><li>Frontend LoadBalancer: 20.22.39.50:80.</li><li>Backend and MySQL: internal ClusterIP Services.</li><li>MySQL StatefulSet: 1/1.</li></ul><p>This helped demonstrate the importance of application architecture in Kubernetes. A frontend can be healthy while the backend is unavailable. A backend can be running while database connectivity is broken. Each layer must work, and the communication between them must be configured correctly.</p><h3>11. AI-assisted Kubernetes incident triage: Keeping humans in control</h3><p>The final project introduced another dimension: using AI to support Kubernetes troubleshooting.</p><p>The task focused on building a read-only Bash triage script for the Book Review application and connecting it to Claude Code through a /k8s-triage skill.</p><p>The workflow was built around four stages:</p><p><strong>Gather → Analyze → Human Act → Verify</strong></p><p>The Bash script was designed to collect evidence from the cluster, including:</p><ul><li>Pod status and readiness.</li><li>Container restart counts.</li><li>Kubernetes events.</li><li>Service backends.</li></ul><p>The workflow also included capturing a healthy baseline before simulating a controlled incident.</p><p>Claude Code’s role was to analyse the collected evidence, explain what it indicated and suggest a possible recovery action. It was not given responsibility for executing recovery commands.</p><p>That boundary was deliberate.</p><p>After a controlled failure, the evidence could be reviewed, the likely cause assessed and a recovery action carried out manually. A second triage report could then be used to verify whether the workload had returned to a healthy state.</p><p>This is where the project connected Kubernetes operations with agentic AI.</p><p>AI can help organise information, identify patterns and explain possible causes. But a production system needs more than a plausible explanation. It needs evidence, appropriate permissions and accountable decisions.</p><p>I found the distinction between an AI assistant that recommends an action and an agent that is permitted to execute it especially important.</p><p>Automation should not remove human judgement from decisions that can affect availability, data or security.</p><h3>What these 11 projects brought together</h3><p>Looking across the projects, I can see a progression from managing individual containers to thinking about an entire application and its operational behaviour.</p><p>Some of the most important concepts I worked with were:</p><p>Kubernetes conceptWhy it mattersPodsRun application containersReplicaSetsMaintain the desired number of Pod replicasDeploymentsManage application updates, rollbacks and scalingConfigMaps and SecretsSeparate configuration and sensitive values from application imagesReadiness probesDetermine whether a Pod should receive trafficLiveness probesDetect when a container needs restartingClusterIPEnable internal communicationNodePortProvide access through a node portLoadBalancerExpose a Service externallyPersistent storagePreserve data beyond the lifecycle of an individual PodIncident triageCollect and interpret operational evidenceAI-assisted analysisSupport troubleshooting while retaining human control</p><p>The bigger lesson is that Kubernetes is not simply a tool for starting containers. It is a system for managing desired state, availability, networking, configuration, storage and recovery.</p><p>And these responsibilities are connected. A Deployment may create healthy Pods, but a Service still needs to select them. A Pod may be running, but a readiness probe may prevent it from receiving traffic. A database may be available, but without persistent storage, important data may not survive the lifecycle of its workload.</p><p>Understanding those relationships is what makes the difference between knowing individual commands and understanding how an application operates.</p><h3>A final thought</h3><p>One analogy stayed with me throughout these projects: a well-coordinated system does not depend on one person remembering every task or fixing every problem manually.</p><p>It has defined responsibilities, clear communication, checks that reveal when something is wrong and a plan for responding.</p><p>That is true of a household, a team and a Kubernetes environment.</p><p>The 11 projects gave me practical exposure to how these ideas translate into infrastructure. More importantly, they encouraged me to think beyond whether a command worked and ask better questions:</p><p>What state should the system be in? How do I know it has reached that state? What happens when a component fails? And how can I prove that recovery was successful?</p><p>Those are the questions I want to keep bringing into the engineering work ahead.</p><p><em>This article covers the Kubernetes projects completed or explored as part of the DMI DevOps Micro Internship, Agentic AI track.</em></p><p><strong>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by [Pravin Mishra](</strong>https://www.linkedin.com/in/pravin-mishra-aws-trainer/<strong>). My graded progress is public: </strong><a href="https://dmi.pravinmishra.com/s/sarah254-tech.html"><strong>https://dmi.pravinmishra.com/s/sarah254-tech.html</strong></a><strong> · Start your DevOps journey: </strong><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3"><strong>https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=48315ca63e76" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Docker, Drama and the Art of Keeping Things Running: From My First Container to Production-Ready…]]></title>
            <link>https://medium.com/@sarahamadi97/docker-drama-and-the-art-of-keeping-things-running-from-my-first-container-to-production-ready-c90943ecf52f?source=rss-db65f5f81408------2</link>
            <guid isPermaLink="false">https://medium.com/p/c90943ecf52f</guid>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Sarahamadi]]></dc:creator>
            <pubDate>Wed, 21 Oct 2026 10:20:26 GMT</pubDate>
            <atom:updated>2026-10-24T04:36:39.196Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ppI24dZoPPLp4lnGyI4TCw.png" /></figure><h3>Docker, Drama and the Art of Keeping Things Running: From My First Container to Production-Ready Applications</h3><p><em>What containerization taught me about technology, troubleshooting, and the beautiful mess of building something that actually works.</em></p><p>There is a particular kind of confidence that comes from doing something for the first time.</p><p>It is not the loud confidence of someone who knows all the answers. It is the quieter confidence of a woman who has stared at an error message for an hour, questioned several life choices, resisted the temptation to close the terminal, and finally discovered what was wrong.</p><p>If you have ever assembled furniture with instructions that seemed to have been written by someone who had never seen furniture, you understand the feeling.</p><p>Now imagine that the furniture is an application, the screws are dependencies, the instructions are documentation, and one missing piece can bring the entire structure down.</p><p>Welcome to Docker.</p><p>My journey through Docker projects has taken me from deploying a simple static website on an Azure virtual machine to optimizing application images, isolating container networks, persisting database data, orchestrating multiple services, and hardening a production-oriented application.</p><p>The projects looked different, but they kept teaching the same lesson:</p><p><strong>Getting an application to run is only the beginning. The real work is making it reliable, secure, reproducible, and maintainable.</strong></p><p>Let’s unpack the journey.</p><h3>1. My first Docker deployment: Giving an application a home</h3><p>The journey began with a relatively straightforward task: deploying a static website on an Azure Linux virtual machine using Docker and Nginx.</p><p>The goal was to provision the VM, automate Docker installation using cloud-init, package a static website into a container, and make it accessible through the VM’s public IP address.</p><p>Cloud-init handled the initial setup, Docker provided the container runtime, and Nginx served the website.</p><p>Conceptually, the process was simple:</p><ul><li>Provision the virtual machine.</li><li>Install Docker.</li><li>Build or obtain the container image.</li><li>Start the container.</li><li>Publish the required port.</li><li>Verify access from a browser.</li></ul><p>But this exercise established an important distinction: <strong>a running container and an accessible application are not the same thing.</strong></p><p>Docker can report that a container is running while a browser fails to connect because of port mappings, firewall rules, application configuration, or cloud network security rules.</p><p>Think of it like opening a shop. You can unlock the front door, arrange the products, and turn on the lights. But if the road leading to the shop is blocked, customers still cannot get in.</p><p>Deployment requires the application, the container runtime, the host, and the network to work together.</p><p>That was the first piece of the puzzle.</p><h3>2. Multi-stage builds: Why your application does not need to carry its entire wardrobe</h3><p>The next challenge was containerizing a React application and comparing a traditional single-stage Docker build with an optimized multi-stage build.</p><p>The original image was approximately <strong>883 MB</strong>. The optimized image was approximately <strong>95 MB</strong>.</p><p>That is a reduction of about <strong>89.2%</strong>, or roughly 788 MB.</p><p>Why does this matter?</p><p>Imagine packing for a weekend trip and taking your entire wardrobe, sewing machine, washing machine, winter coats, and the wardrobe itself.</p><p>Technically, you have everything you need. Practically, you have made the journey unnecessarily expensive.</p><p>A poorly optimized container image can make a similar mistake.</p><p>A React application needs Node.js and build tools to compile its source code. However, once the application has been built into static files, those development tools are often unnecessary for serving the finished website.</p><p>A multi-stage Docker build separates these responsibilities:</p><ol><li><strong>Build stage:</strong> Install dependencies and compile the application.</li><li><strong>Runtime stage:</strong> Copy only the required production artifacts into a smaller image, such as Nginx.</li></ol><p>A simplified example looks like this:</p><pre>FROM node:alpine AS build<br>WORKDIR /app<br>COPY package*.json ./<br>RUN npm ci<br>COPY . .<br>RUN npm run build</pre><pre>FROM nginx:alpine<br>COPY --from=build /app/dist /usr/share/nginx/html<br>EXPOSE 80</pre><p>The exact output directory depends on the application and build configuration. The principle remains the same: build with the tools you need, then deploy only what the runtime needs.</p><p>Docker layer caching provides another optimization. Copying dependency manifests before application source files allows Docker to reuse the dependency-installation layer when the dependencies have not changed.</p><p>And .dockerignore matters too. Excluding items such as node_modules, local build output, and environment files prevents unnecessary files from entering the build context.</p><p><strong>The lesson: smaller images are not merely tidier. They can reduce transfer time, storage requirements, and the amount of unnecessary software shipped with an application.</strong></p><h3>3. Docker networking: Not every container needs to be invited to every conversation</h3><p>Once containers were running, the next question was how they should communicate.</p><p>I explored default bridge networking, custom bridge networks, container-name communication, network isolation, and host networking.</p><p>This is where Docker became less like packing boxes and more like managing relationships.</p><p>Everyone may live in the same building, but that does not mean everyone should have access to every room.</p><h3>Default and custom bridge networks</h3><p>Docker’s default bridge network allows containers to communicate through that network, commonly using IP addresses. For application stacks, user-defined bridge networks are generally more convenient because they support communication by container name and provide better isolation boundaries.</p><p>In the networking exercises, separate networks were created for frontend and backend components.</p><p>The intended architecture allowed the frontend to communicate with the backend, and the backend to communicate with the database, while preventing the frontend from directly reaching the database.</p><p>Why is this important?</p><p>Because a database is not a public reception desk.</p><p>The frontend needs to request information. The backend should handle the application logic and communicate with the database. Giving the frontend direct database access would create an unnecessary path into a sensitive component.</p><p>The principle is <strong>least privilege applied to network connectivity</strong>: give each service the access it requires, not every connection Docker can technically provide.</p><h3>Host networking: Convenience comes with trade-offs</h3><p>Another exercise involved running Nginx using Docker’s host network mode.</p><p>With bridge networking, a container normally has its own network namespace and can publish a container port through a host port mapping.</p><p>With host networking on Linux, the container shares the host’s network namespace. Port publishing is not used in the same way, because the application binds directly to the host’s network interfaces.</p><p>This can be useful for certain workloads, but it changes the isolation and port-management model.</p><p>A container listening on port 80 may compete with another host process already using that port.</p><p>In other words, two tenants cannot both claim the same front door without an arrangement that makes it possible.</p><p><strong>The takeaway: networking mode is an architectural decision, not just another Docker command.</strong></p><h3>4. Volumes and bind mounts: Because containers should not take your data with them when they leave</h3><p>Containers are designed to be replaceable. Their writable container layers are not the right place to keep data that must survive container removal.</p><p>This became particularly important during exercises involving Docker volumes and bind mounts.</p><p>A <strong>Docker volume</strong> is managed by Docker and can preserve data independently of a container’s lifecycle.</p><p>A <strong>bind mount</strong> connects a specific host path to a path inside a container.</p><p>I used these mechanisms to preserve Nginx logs after a container was removed and to share persistent data between containers.</p><p>Consider the difference:</p><ul><li>A container is the temporary apartment.</li><li>A volume is the storage unit you continue paying for even after moving out.</li><li>A bind mount is the cupboard you bring from your actual house.</li></ul><p>Removing the apartment should not mean losing the documents in your storage unit.</p><p>This distinction becomes critical for databases.</p><p>In the Book Review application and the EpicBook stack, persistent MySQL storage was part of the architecture. Named volumes allowed database data to remain available independently of the database container.</p><p>Docker Compose also makes teardown behavior important:</p><ul><li>docker compose down removes containers and the Compose network but preserves named volumes by default.</li><li>docker compose down -v also removes Compose-managed named volumes, potentially deleting stored data.</li></ul><p>The second command is not inherently wrong. It is simply destructive when persistence is the objective.</p><p><strong>Always identify what must survive before deciding what to remove.</strong></p><h3>5. Docker Compose: Managing a family of services without shouting across the house</h3><p>A single-container deployment is useful for understanding the fundamentals. Real applications, however, rarely live alone.</p><p>The Book Review application introduced a multi-service workflow involving a frontend, backend, and MySQL database. The EpicBook capstone extended this into a more production-oriented architecture with a reverse proxy, frontend, backend, and database.</p><p>Docker Compose brought the components together in a declarative configuration.</p><p>Instead of remembering separate commands for every service, the configuration described:</p><ul><li>Which images to build or use.</li><li>Which ports to publish.</li><li>Which networks to attach.</li><li>Which volumes to mount.</li><li>Which health checks to run.</li><li>Which dependencies must become healthy before another service starts.</li></ul><p>The architecture looked roughly like this:</p><p>Public user → Nginx reverse proxy → Application services → MySQL database</p><p>The reverse proxy acted as the public entry point. The backend and database communicated over internal Docker networks, and the database was not intended to be publicly exposed.</p><p>This arrangement reduces unnecessary public exposure and gives each component a clear responsibility.</p><h3>Health checks: Running is not the same as being ready</h3><p>One of the most important distinctions in a multi-container application is the difference between a process running and a service being ready.</p><p>A database process may have started but still be initializing. A backend process may be alive but unable to connect to its database.</p><p>Docker health checks provide a way to test whether a service is responding as expected. Compose can use conditions such as service_healthy to manage startup dependencies.</p><p>That does not replace application-level retry logic or guarantee that a service will never fail later. It does, however, make startup behavior more deliberate.</p><p>Think of a family preparing to leave the house. Everyone standing by the door does not necessarily mean everyone is ready. Someone is still looking for their keys.</p><p>A startup sequence should account for readiness, not simply presence.</p><h3>6. The production-hardening lesson: Security is in the details</h3><p>The EpicBook work brought together several concepts that are easy to treat as separate exercises but become much more powerful when combined:</p><ul><li>Optimized production images.</li><li>Non-root execution.</li><li>Isolated frontend and backend networks.</li><li>Health checks and startup dependencies.</li><li>A single public reverse proxy.</li><li>Persistent database storage.</li><li>Logs that support troubleshooting without exposing secrets.</li><li>Backup, restore, and reliability testing.</li></ul><p>A reverse proxy can route application pages, API requests, static assets, and health requests while keeping backend services off the public interface.</p><p>A named database volume protects against data loss caused by routine container replacement, but it does not replace backups.</p><p>Logs help explain what happened, but they must not expose passwords, tokens, or database connection strings.</p><p>And an image that builds successfully still needs to be tested in the environment where it will run.</p><p>These are not decorative production features. They are the difference between a demonstration that works once and an application that can be operated responsibly.</p><h3>7. Agentic AI and Docker troubleshooting: The assistant is not the engineer</h3><p>As the projects became more complex, I began incorporating Claude Code into the troubleshooting workflow.</p><p>In the Docker hardening exercise, I created a read-only Bash script to inspect common container security gaps, including root execution, missing health checks, mutable image tags, privileged mode, and published ports.</p><p>I connected the script to Claude Code as a reusable /docker-audit skill.</p><p>The division of responsibility was deliberate:</p><ol><li>Gather evidence from the running environment.</li><li>Let the AI analyze the findings and explain the risks.</li><li>Review the recommendation.</li><li>Apply the configuration change manually.</li><li>Rebuild or recreate the affected service.</li><li>Verify the result using fresh evidence.</li></ol><p>The process became especially useful when hardening the EpicBook Nginx reverse proxy.</p><p>The original configuration used the standard Nginx image and ran as root by default. I switched to nginxinc/nginx-unprivileged:alpine, configured Nginx to listen on port 8080, updated the host port mapping, and corrected the health-check URL.</p><p>The first attempt did not work perfectly.</p><p>File permissions prevented the unprivileged process from reading its configuration and accessing the existing log directory. After addressing the permissions and moving logs to a dedicated directory, the container stayed running.</p><p>But the health check still failed.</p><p>Why?</p><p>The check was probing port 80 inside the container even though Nginx was listening on port 8080.</p><p>A manual request to port 8080 returned HTTP 200, while Docker’s scheduled health check continued to fail. Inspecting the configured health-check command exposed the mismatch.</p><p>Once the URL was corrected to use port 8080, the reverse proxy reached healthy status. The subsequent audit also identified it as running under UID 101.</p><p>This is precisely why troubleshooting should follow evidence rather than intuition.</p><p>A process can be running while a health check fails. A configuration can be syntactically valid while its behavior is incorrect. And a recommendation can sound reasonable while still requiring validation in the actual environment.</p><p><strong>AI can accelerate investigation, but it cannot remove the engineer’s responsibility to verify the outcome.</strong></p><h3>8. What all these Docker projects have in common</h3><p>Looking back across these exercises, the progression is clear.</p><p>The first question was: <em>Can I get this application running?</em></p><p>Then the questions became more demanding:</p><ul><li>Can I make the image smaller?</li><li>Can I control which services communicate?</li><li>Can I preserve data when containers are replaced?</li><li>Can I coordinate service startup?</li><li>Can I expose only the required entry point?</li><li>Can I detect when a service stops responding?</li><li>Can I recover from failure?</li><li>Can I prove that the change worked?</li></ul><p>That progression is what makes practical engineering valuable.</p><p>Docker is not just a way to package an application. It provides tools for defining runtime environments, managing dependencies, controlling network access, preserving data, and making deployments more repeatable.</p><p>But those benefits do not arrive automatically because a Dockerfile exists.</p><p>They come from deliberate design, careful configuration, testing, and verification.</p><h3>A final thought for the woman building a new career</h3><p>Career transitions have a funny way of making you feel as though everyone else received a manual you somehow missed.</p><p>You see people speaking confidently about images, networks, volumes, registries, and orchestration. Meanwhile, you are trying to remember whether the problem is the port mapping, the firewall, the application, or a permission you did not know existed.</p><p>It can feel like being the new person in a house where everybody else already knows which switch controls the lights.</p><p>But technical confidence is not the ability to avoid every error.</p><p>It is the ability to investigate an error without panicking, isolate the problem, test a hypothesis, make a controlled change, and verify the result.</p><p>That process is transferable. It applies to Docker, cloud infrastructure, software testing, automation, and many other engineering disciplines.</p><p>And it applies outside technology, too.</p><p>Sometimes the system needs redesigning. Sometimes one small setting is wrong. Sometimes the problem is a dependency that has not become ready. And sometimes the solution is simply to stop guessing and inspect the evidence.</p><p>The terminal may not care how many responsibilities you carry outside it. It will still return the error.</p><p>But you can learn to read that error, understand the system behind it, and work toward a solution one step at a time.</p><p>That is the real work of building reliable systems.</p><p>And perhaps, in its own technical way, it is also the work of building a new version of yourself.</p><p><em>One container at a time. One problem at a time. One verified improvement at a time.</em></p><p><strong>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by [Pravin Mishra](</strong>https://www.linkedin.com/in/pravin-mishra-aws-trainer/<strong>). My graded progress is public: </strong><a href="https://dmi.pravinmishra.com/s/sarah254-tech.html"><strong>https://dmi.pravinmishra.com/s/sarah254-tech.html</strong></a><strong> · Start your DevOps journey: </strong><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3"><strong>https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c90943ecf52f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Day Troubleshooting Stopped Feeling Like Failure]]></title>
            <link>https://medium.com/@sarahamadi97/the-day-troubleshooting-stopped-feeling-like-failure-5ac4a98b023c?source=rss-db65f5f81408------2</link>
            <guid isPermaLink="false">https://medium.com/p/5ac4a98b023c</guid>
            <category><![CDATA[agentic-ai-architecture]]></category>
            <category><![CDATA[ansible-playbook]]></category>
            <category><![CDATA[terraform-cloud]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[women-in-tech]]></category>
            <dc:creator><![CDATA[Sarahamadi]]></dc:creator>
            <pubDate>Wed, 23 Sep 2026 10:24:31 GMT</pubDate>
            <atom:updated>2026-09-23T10:24:31.539Z</atom:updated>
            <content:encoded><![CDATA[<p>There is a strange thing that happens when you transition into tech.</p><p>At the beginning, every error feels like a personal attack.</p><p>You run a command.</p><p>It fails.</p><p>You run it again, slightly differently.</p><p>It fails with more confidence.</p><p>And suddenly you are staring at your terminal wondering:</p><p><strong>“Did I really leave a perfectly good career to be bullied by a computer?”</strong> 😂</p><p>Week 10 of my DevOps journey reminded me that troubleshooting is not a sign that I don’t know what I’m doing.</p><p><strong>Troubleshooting is the work.</strong></p><p>And the more complex the system becomes, the more important it is to know <em>how</em> to troubleshoot rather than simply knowing how to deploy.</p><h3>From “Deploy It” to “What Changed?”</h3><p>Earlier in my journey, my focus was largely:</p><p><strong>Can I provision the infrastructure?</strong></p><p>Then:</p><p><strong>Can I configure the server?</strong></p><p>Then:</p><p><strong>Can I deploy the application?</strong></p><p>With Terraform and Ansible, I was already moving toward repeatable infrastructure and configuration.</p><p>But Week 10 pushed the question further:</p><p><strong>Before I allow automation to change my system, can I understand what it is about to do?</strong></p><p>That question became particularly important as I worked with the EpicBook 2-tier application.</p><p>I wasn’t dealing with a simple static website anymore.</p><p>There were moving parts:</p><p><strong>Nginx → Node.js/Express → MySQL</strong></p><p>And when one piece doesn’t behave, the temptation is to start changing everything.</p><p>Which, if you’ve ever tried to fix something at home while three children are asking you different questions at the same time, you already know is a terrible strategy. 😂</p><p>You don’t fix five things at once.</p><p>You find the thing actually causing the problem.</p><h3>Troubleshooting Is Basically Motherhood With Logs</h3><p>Think about a normal day.</p><p>The Wi-Fi stops working.</p><p>The children say the internet is broken.</p><p>Someone’s tablet isn’t connecting.</p><p>Your husband says the router probably needs restarting.</p><p>Someone else has already switched the router off.</p><p>Now nobody knows what happened.</p><p>😂</p><p>That’s troubleshooting.</p><p>You don’t immediately replace the entire internet.</p><p>You start narrowing things down.</p><p><strong>Is the router on?</strong></p><p><strong>Is the device connected?</strong></p><p><strong>Is the network available?</strong></p><p><strong>Is the problem with one device or everything?</strong></p><p>DevOps troubleshooting follows exactly the same logic.</p><p>You gather evidence.</p><p>You isolate the problem.</p><p>You test your assumptions.</p><p>You make one controlled change.</p><p>Then you verify.</p><p>That became one of the biggest lessons from this assignment.</p><h3>The 2-Tier Application Gave Me Plenty to Investigate</h3><p>With EpicBook, the infrastructure could be healthy while the application was not.</p><p>The database could be reachable while authentication was wrong.</p><p>Node.js could be running while Nginx couldn’t communicate with it.</p><p>PM2 could be restarting the application while the underlying configuration was incorrect.</p><p>And Nginx could happily return:</p><p><strong>502 Bad Gateway</strong></p><p>which is basically the server’s polite way of saying:</p><p><em>“I tried. Please go ask somebody else.”</em> 😂</p><p>Instead of treating the error as one giant mystery, I started tracing the request.</p><p><strong>Does Nginx work?</strong></p><p>↓</p><p><strong>Can Nginx reach Node.js?</strong></p><p>↓</p><p><strong>Is Node.js running correctly?</strong></p><p>↓</p><p><strong>Can the application authenticate with MySQL?</strong></p><p>↓</p><p><strong>Is the configuration being supplied correctly?</strong></p><p>That is when troubleshooting started becoming less emotional and more methodical.</p><h3>Then Ansible Added Another Layer</h3><p>Ansible was already helping me automate server configuration and application deployment.</p><p>But automation introduces another question:</p><p><strong>What exactly is my automation changing?</strong></p><p>That’s where the dry run became important.</p><p>I used:</p><pre>ansible-playbook --check --diff</pre><p>Instead of immediately saying:</p><p><em>“Okay Ansible, go ahead and rearrange my server.”</em></p><p>I could first ask:</p><p><strong>“Show me what you’re planning to do.”</strong></p><p>That small change in mindset was significant.</p><p>I wasn’t just executing automation.</p><p>I was <strong>reviewing automation</strong>.</p><h3>And Then I Let AI Join the Troubleshooting Team</h3><p>This was where the assignment became particularly interesting.</p><p>I created an AI-assisted workflow around the Ansible dry-run results.</p><p>The workflow was:</p><p><strong>Gather → Analyze → Human Act → Verify</strong></p><p>The script gathered the Ansible output.</p><p>The review process analysed the proposed changes.</p><p>Potential risks could be identified around things like:</p><ul><li>Packages and dependencies</li><li>Services</li><li>Configuration files</li><li>Permissions</li><li>Application changes</li><li>Infrastructure changes</li></ul><p>Then came the important part.</p><p><strong>I still made the decision.</strong></p><p>AI wasn’t given the keys to the house and told:</p><p><em>“Do whatever you think is best.”</em> 😂</p><p>It was more like having another pair of eyes looking at the work before I approved it.</p><p>And honestly, that feels much closer to how I want AI to work in engineering.</p><h3>Then My Own Automation Betrayed Me</h3><p>This might have been my favourite lesson.</p><p>My first review script reported:</p><p><strong>HEALTHY</strong></p><p>But Ansible was reporting:</p><pre>changed=3</pre><p>Excuse me?</p><p>😂</p><p>This is one of those moments where technology reminds you that automation does not magically become correct just because you automated it.</p><p>The problem was in my parser.</p><p>It was expecting a different output format, so it missed the changes.</p><p>Claude Code helped me identify the issue.</p><p>I corrected the parser.</p><p>Ran the workflow again.</p><p>And this time, the changes were detected properly.</p><p>That experience gave me a lesson I think is bigger than Ansible:</p><p><strong>Never trust an automated result simply because it is automated.</strong></p><p>Automation itself needs testing.</p><h3>I Even Created a Little Trouble on Purpose</h3><p>Because apparently debugging real problems wasn’t enough. 😂</p><p>I deliberately introduced a controlled change:</p><p><strong>Install cowsay package for controlled risk review.</strong></p><p>The idea wasn’t to break the application.</p><p>It was to test whether the review workflow could actually recognise a change and classify it appropriately.</p><p>And it did.</p><p>The change was identified as a <strong>package/dependency risk</strong> and flagged for human review.</p><p>That was satisfying because the system wasn’t simply telling me:</p><p><strong>“Everything is fine.”</strong></p><p>It was actually examining what was changing.</p><p>And that distinction matters.</p><h3>The Most Important Word Was “Human”</h3><p>There is a lot of conversation around AI replacing engineers.</p><p>My Week 10 experience made me think about something slightly different.</p><p>Maybe the interesting question isn’t:</p><p><strong>“What can AI do without me?”</strong></p><p>Maybe it’s:</p><p><strong>“What can AI help me see that I might otherwise miss?”</strong></p><p>Because there is a difference between <strong>automation</strong> and <strong>authority</strong>.</p><p>AI can gather.</p><p>AI can analyse.</p><p>AI can identify patterns.</p><p>AI can raise a flag.</p><p>But someone still needs to understand the context and decide what should happen next.</p><p>For my workflow:</p><p><strong>AI gathers evidence.</strong></p><p><strong>AI analyses potential risk.</strong></p><p><strong>I review and decide.</strong></p><p><strong>Ansible executes.</strong></p><p><strong>I verify the result.</strong></p><p>That separation makes the automation much more useful to me.</p><h3>And This Is Where Troubleshooting Changed for Me</h3><p>I used to think troubleshooting meant:</p><p><strong>Something broke. Fix it.</strong></p><p>I’m beginning to see it differently.</p><p>Troubleshooting is really:</p><p><strong>Something isn’t behaving as expected. Let’s understand why.</strong></p><p>That sounds simple, but it changes everything.</p><p>Instead of panicking at the error message, I can ask:</p><p><strong>What do I know?</strong></p><p><strong>What don’t I know?</strong></p><p><strong>What evidence can I collect?</strong></p><p><strong>Which layer could be responsible?</strong></p><p><strong>What can I test without making things worse?</strong></p><p><strong>What changed?</strong></p><p><strong>Did my fix actually work?</strong></p><p>This is not just a technical skill.</p><p>It’s a way of thinking.</p><h3>A Lesson for Women Starting Over</h3><p>I think this is particularly relevant to women transitioning into technology, or honestly, into any unfamiliar space.</p><p>We often feel like we need to arrive already knowing everything.</p><p>We want to look competent.</p><p>We want to avoid asking the “stupid” question.</p><p>We want to understand the tool before admitting we don’t understand the tool.</p><p>But troubleshooting has taught me something very different.</p><p><strong>You don’t need to know everything to investigate well.</strong></p><p>You need curiosity.</p><p>You need patience.</p><p>You need the courage to say:</p><p><strong>“I don’t know yet. Let me find out.”</strong></p><p>That sentence has become surprisingly powerful for me.</p><p>Because being a beginner doesn’t mean being incapable.</p><p>It means you’re collecting evidence.</p><h3>The Boeing Is Still Flying ✈️</h3><p>I started this DevOps journey imagining a fully loaded Boeing 777 trying to get off the runway.</p><p>At first, there was a lot of manual work.</p><p>Terraform helped automate infrastructure.</p><p>Ansible helped automate configuration and deployment.</p><p>And now AI is helping me review changes and investigate risk.</p><p>But troubleshooting has taught me something important:</p><p><strong>Automation doesn’t eliminate problems.</strong></p><p>It changes the kind of problems you solve.</p><p>And perhaps that’s what progress actually looks like.</p><p>Not fewer errors.</p><p>Not a completely smooth journey.</p><p>But becoming the woman who sees an error message and doesn’t immediately think:</p><p><strong>“Oh no.”</strong></p><p>Instead, I think:</p><p><strong>“Okay. Which layer are we investigating first?”</strong> 😂</p><p>The Boeing is still moving.</p><p>The runway is getting shorter.</p><p>And I’m slowly learning that sometimes the turbulence isn’t a sign that the plane is going down.</p><p>Sometimes…</p><p><strong>it’s just part of learning how to fly.</strong> ✈️</p><p><strong>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by [Pravin Mishra](</strong>https://www.linkedin.com/in/pravin-mishra-aws-trainer/<strong>). My graded progress is public: </strong><a href="https://dmi.pravinmishra.com/s/sarah254-tech.html"><strong>https://dmi.pravinmishra.com/s/sarah254-tech.html</strong></a><strong> · Start your DevOps journey: </strong><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3"><strong>https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5ac4a98b023c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When the Architecture Changed, My Ansible Lessons Changed Too]]></title>
            <link>https://medium.com/@sarahamadi97/when-the-architecture-changed-my-ansible-lessons-changed-too-1af9f7a70c87?source=rss-db65f5f81408------2</link>
            <guid isPermaLink="false">https://medium.com/p/1af9f7a70c87</guid>
            <category><![CDATA[dmibypravinmishra]]></category>
            <category><![CDATA[azure-devops]]></category>
            <category><![CDATA[ansible-playbook]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Sarahamadi]]></dc:creator>
            <pubDate>Wed, 16 Sep 2026 14:21:58 GMT</pubDate>
            <atom:updated>2026-09-16T14:21:58.656Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yW8jBaYuCYg0pgB9hRj7lw.png" /><figcaption>Ansible in action</figcaption></figure><p>There is something interesting about learning DevOps.</p><p>At first, you celebrate when you get <strong>the application running</strong>.</p><p>Then, somewhere along the way, you start asking a different question:</p><p><strong>“What happens when something goes wrong?”</strong></p><p>That shift happened for me when I moved from deploying a static website to deploying a 2-tier application with Ansible.</p><p>And then it went one step further.</p><p>I started teaching AI to review infrastructure changes <strong>before they happened</strong>.</p><p>That was when I realised I was no longer just learning tools.</p><p>I was learning how to think about systems.</p><h3>The Static Website Was My Starting Point</h3><p>My first deployment involved <strong>Mini Finance</strong>, a static web application.</p><p>The architecture was relatively simple.</p><p>Terraform provisioned the Azure infrastructure.</p><p>Ansible then took over to configure the Ubuntu server, install Nginx, deploy the website and verify that it was accessible.</p><p>The workflow was beautifully straightforward:</p><p><strong>Terraform → Provision</strong></p><p><strong>Ansible → Configure &amp; Deploy</strong></p><p><strong>Verification → Validate</strong></p><p>At this stage, Ansible felt like having an extremely organised assistant.</p><p>Tell it what the server should look like, and it goes about making it happen.</p><p>No clicking around the server trying to remember what I changed last Tuesday.</p><p>I liked that.</p><p>Then came EpicBook.</p><p>And suddenly, my “simple assistant” had much more work to do.</p><h3>Then the Application Got a Little More Complicated</h3><p>EpicBook introduced a <strong>2-tier architecture</strong>.</p><p>Now I had:</p><p><strong>Application Tier → Node.js + Express + Nginx + PM2</strong></p><p><strong>Database Tier → Managed MySQL</strong></p><p>The application was no longer simply serving files.</p><p>There were dependencies.</p><p>The application needed to communicate with the database.</p><p>Nginx needed to communicate with Node.js.</p><p>PM2 needed to keep the application running.</p><p>Credentials needed to be handled correctly.</p><p>Suddenly, when something failed, I couldn’t just stare at the browser and say:</p><p><em>“Why are you like this?”</em> 😂</p><p>I had to trace the request through the architecture.</p><p><strong>Nginx → Node.js → MySQL</strong></p><p>And that led me to one of those beautiful DevOps moments:</p><p><strong>502 Bad Gateway.</strong></p><h3>The 502 That Sent Me Investigating</h3><p>The infrastructure was running.</p><p>The database was reachable.</p><p>PM2 was restarting.</p><p>But the application still wasn’t behaving properly.</p><p>Instead of treating the 502 as one giant problem, I started looking at the system layer by layer.</p><p>Where does the request go?</p><p>What is working?</p><p>What isn’t?</p><p>What dependency could be failing?</p><p>That investigation eventually led back to the database authentication and configuration flow.</p><p>Once the credential handling was corrected through Ansible, the application was redeployed, the database was seeded and the application returned:</p><p><strong>HTTP 200.</strong></p><p>That little 200 felt much more satisfying than it probably should have. 😂</p><p>Because the real lesson wasn’t the status code.</p><p>It was learning to <strong>follow the system instead of guessing at the symptom</strong>.</p><h3>Then I Asked a Bigger Question</h3><p>By this point, Ansible wasn’t just installing packages and deploying applications.</p><p>It was making changes to servers.</p><p>And that made me wonder:</p><p><strong>What if I could review those changes before allowing them to happen?</strong></p><p>That question led to my <strong>AI-assisted Ansible Change Risk Review workflow</strong>.</p><p>The idea was simple:</p><p><strong>Gather → Analyze → Human Act → Verify</strong></p><p>First, I used:</p><pre>ansible-playbook --check --diff</pre><p>A dry run.</p><p>Instead of immediately changing the server, Ansible could show me what it <em>expected</em> to change.</p><p>I then built ansible-check-review.sh to capture the output, identify changed tasks, classify potential risks and produce a structured report.</p><p>Then I connected the workflow to a reusable Claude Code skill:</p><pre>/ansible-risk-review</pre><p>Now AI could help analyse changes involving:</p><ul><li>Packages and dependencies</li><li>Services and processes</li><li>Files and configuration</li><li>Permissions</li><li>Application and infrastructure changes</li></ul><p>I thought I was building a reviewer.</p><p>Then the reviewer reviewed <strong>me</strong>. 😂</p><h3>When My Automation Lied to Me</h3><p>My first script reported:</p><p><strong>HEALTHY</strong></p><p>But Ansible was clearly telling me:</p><pre>changed=3</pre><p>Something wasn’t right.</p><p>My parser was expecting a different output format, so it missed the changes.</p><p>Claude Code helped me identify the false negative.</p><p>I corrected the parser.</p><p>Ran the review again.</p><p>This time, the changes were detected correctly.</p><p>And that gave me another important lesson:</p><p><strong>Automation needs to be tested too.</strong></p><p>Just because a script runs successfully doesn’t mean the logic inside it is correct.</p><p>A green result isn’t automatically a trustworthy result.</p><p>That distinction is becoming increasingly important as AI becomes part of our engineering workflows.</p><h3>So I Created a Controlled Risk</h3><p>I deliberately introduced a harmless change:</p><pre>Install cowsay package for controlled risk review</pre><p>The dry run detected it.</p><p>The reviewer classified it as a <strong>package or dependency risk</strong>.</p><p>Claude Code flagged it for human review.</p><p>And importantly, nothing was automatically applied.</p><p>I reviewed the finding.</p><p><strong>I made the decision.</strong></p><p>Then Ansible executed the change.</p><p>Afterward, I verified the system:</p><pre>unreachable=0<br>failed=0</pre><p>And checked connectivity:</p><pre>ping: pong</pre><p>The system wasn’t just changed.</p><p>It was <strong>changed, reviewed and verified</strong>.</p><h3>The Part About AI That I’m Learning Slowly</h3><p>There is a temptation to think that adding AI to DevOps means giving AI more control.</p><p>I’m beginning to see it differently.</p><p>The more powerful the automation becomes, the more important <strong>boundaries</strong> become.</p><p>AI can gather evidence.</p><p>AI can analyse.</p><p>AI can identify patterns.</p><p>AI can point out potential risks.</p><p>But there is still value in having a human look at the evidence and ask:</p><p><strong>“Does this change actually make sense?”</strong></p><p>That is why I liked this workflow:</p><p><strong>AI gathers.</strong></p><p><strong>AI analyses.</strong></p><p><strong>Human decides.</strong></p><p><strong>Ansible executes.</strong></p><p><strong>Verification confirms.</strong></p><p>The intelligence can be automated.</p><p>The authority doesn’t have to be.</p><h3>From Static Files to Systems Thinking</h3><p>Looking back, the progression has been surprisingly natural.</p><p><strong>Static application</strong></p><p>↓</p><p><strong>2-tier application</strong></p><p>↓</p><p><strong>More dependencies</strong></p><p>↓</p><p><strong>More failure points</strong></p><p>↓</p><p><strong>More automation</strong></p><p>↓</p><p><strong>AI-assisted change analysis</strong></p><p>Each stage forced me to think a little beyond the tool itself.</p><p>Terraform taught me to think about infrastructure as code.</p><p>Ansible taught me to think about configuration and repeatability.</p><p>Debugging taught me to trace dependencies.</p><p>AI-assisted review is teaching me to think about <strong>change and risk before execution</strong>.</p><p>And perhaps that is the real transition happening in my DevOps journey.</p><p>I’m moving from asking:</p><p><strong>“How do I make this work?”</strong></p><p>to asking:</p><p><strong>“How do I make this work repeatedly, safely, and predictably?”</strong></p><h3>And the Boeing Is Still Moving ✈️</h3><p>I keep thinking about my DevOps journey as a fully loaded Boeing 777.</p><p>The early stages were a long runway.</p><p>Lots of manual work.</p><p>Lots of unfamiliar controls.</p><p>Lots of moments where I wondered whether I was actually ready to fly this thing. 😂</p><p>But gradually, Terraform took some of the manual infrastructure work away.</p><p>Ansible started handling server configuration and application deployment.</p><p>And now AI is helping me examine changes before they reach the system.</p><p>The aircraft hasn’t reached cruising altitude yet.</p><p>I’m still learning the controls.</p><p>Still troubleshooting.</p><p>Still occasionally looking at an error message like it personally offended me.</p><p>But the wheels are off the ground.</p><p>And perhaps the most exciting part is that the architecture keeps getting more complex while the way I approach it becomes more deliberate.</p><p><strong>Static → 2-tier → 3-tier.</strong></p><p><strong>Manual → Automated → AI-assisted.</strong></p><p>One architecture.</p><p>One failure.</p><p>One lesson.</p><p>One takeoff at a time. ✈️</p><p><strong>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by [Pravin Mishra](</strong>https://www.linkedin.com/in/pravin-mishra-aws-trainer/<strong>). My graded progress is public: </strong><a href="https://dmi.pravinmishra.com/s/sarah254-tech.html"><strong>https://dmi.pravinmishra.com/s/sarah254-tech.html</strong></a><strong> · Start your DevOps journey: </strong><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3"><strong>https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1af9f7a70c87" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Terraform Took My DevOps Takeoff From a Runway Sprint to a Cruise]]></title>
            <link>https://medium.com/@sarahamadi97/terraform-took-my-devops-takeoff-from-a-runway-sprint-to-a-cruise-4ac1f8728047?source=rss-db65f5f81408------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ac1f8728047</guid>
            <category><![CDATA[women-in-tech]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[tech4dev]]></category>
            <dc:creator><![CDATA[Sarahamadi]]></dc:creator>
            <pubDate>Sat, 05 Sep 2026 11:45:21 GMT</pubDate>
            <atom:updated>2026-09-05T11:45:21.128Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cn5P9q_XB4vuJusreSk3fQ.png" /><figcaption>DevOps with wings</figcaption></figure><p><em>How infrastructure as code changed the way I think about building cloud systems, one Boeing 777 analogy at a time.</em></p><p>There is a particular moment during takeoff when a fully loaded Boeing 777 starts accelerating down the runway.</p><p>It is not graceful.</p><p>It is powerful.</p><p>There is noise. Movement. Coordination. A lot of machinery doing a lot of things at once.</p><p>And then, almost suddenly, the aircraft leaves the ground.</p><p>That is increasingly how I think about my DevOps journey.</p><p>In the beginning, everything felt like that runway.</p><p>Long.</p><p>Heavy.</p><p>Manual.</p><p>Every component needed attention.</p><p>Every configuration needed to be typed.</p><p>Every network rule needed to be created.</p><p>Every server needed to be configured.</p><p>Every mistake meant going back and figuring out where I had missed something.</p><p>I wasn’t flying yet.</p><p>I was still trying to get the aircraft off the ground.</p><p>Then Terraform entered the cockpit.</p><p>And suddenly, things started getting interesting.</p><h3>My First Weeks in the Cloud Were Very Manual</h3><p>When I started building infrastructure in AWS, I was doing a lot of things manually.</p><p>I would open the AWS Console.</p><p>Create a VPC.</p><p>Create subnets.</p><p>Configure route tables.</p><p>Set up security groups.</p><p>Launch EC2 instances.</p><p>Configure application servers.</p><p>Connect databases.</p><p>Test connectivity.</p><p>Break something.</p><p>Go back.</p><p>Change something.</p><p>Test again.</p><p>And if I needed to build another environment?</p><p>Well…</p><p>Hello, AWS Console.</p><p>We meet again.</p><p>It reminded me of preparing a Boeing 777 for takeoff with a checklist that had to be completed by manually walking around the aircraft and checking every single component yourself.</p><p>Necessary?</p><p>Absolutely.</p><p>Efficient?</p><p>Not particularly.</p><p>And after doing it several times, I started asking the question every tired engineer eventually asks:</p><p><strong>“Surely there is a better way to do this?”</strong></p><p>There was.</p><p>Actually, there were several.</p><h3>Enter Terraform</h3><p>Terraform introduced me to <strong>Infrastructure as Code (IaC)</strong>.</p><p>In simple terms, instead of clicking around the AWS Console to tell AWS what infrastructure I want, I describe the infrastructure in code.</p><p>Terraform then reads that configuration and creates the resources for me.</p><p>Instead of saying:</p><p><em>“Let me manually create this VPC again…”</em></p><p>I can say:</p><p><em>“Terraform, this is the infrastructure I want. Make it happen.”</em></p><p>That was a major mindset shift.</p><p>The infrastructure stopped being something I manually assembled and became something I could <strong>define, version, review, reproduce and modify</strong>.</p><p>And that distinction is huge.</p><p>Because infrastructure is code too.</p><p>It deserves the same discipline we give application code.</p><p>Git.</p><p>Version control.</p><p>Reviews.</p><p>Change tracking.</p><p>Testing.</p><p>And, occasionally, staring at an error message wondering why Terraform has decided today is the day it tests your character.</p><h3>From the Book Review App to Infrastructure as Code</h3><p>One of the most practical places I applied this was the <strong>Book Review application</strong> we had been building.</p><p>The application wasn’t just a website.</p><p>It was an opportunity to think about how the infrastructure supporting that application should actually be designed.</p><p>We worked through the architecture in stages.</p><p>First came the <strong>two-tier architecture</strong>.</p><p>Then we expanded the thinking into the <strong>three-tier architecture</strong>.</p><p>And eventually, we started expressing that infrastructure through Terraform.</p><p>That meant moving away from:</p><p><strong>Console → Click → Configure → Repeat</strong></p><p>towards:</p><p><strong>Write → Plan → Apply → Verify</strong></p><p>That little sequence felt wonderfully peaceful.</p><p>At least until Terraform returned an error.</p><p>Then it became:</p><p><strong>Write → Plan → Error → Google → Claude → Modify → Plan again → Error differently → Question life → Apply</strong></p><p>Progress.</p><h3>The Two-Tier Architecture</h3><p>Our two-tier design separated the application workload from the database.</p><p>Think of it as a two-story house.</p><p>The first floor is where people interact with the application.</p><p>The second floor is where the important data lives.</p><p>You don’t want everybody wandering into the second floor and rearranging your database.</p><p>So we created separation between the application and data layers.</p><p>We also considered availability across multiple Availability Zones.</p><p>The principle was simple:</p><p><strong>Don’t put everything in one place and hope nothing goes wrong.</strong></p><p>That principle seems obvious now.</p><p>But when you’re building infrastructure manually for the first time, there are a lot of moving pieces.</p><p>Terraform gave me a way to describe those pieces systematically.</p><p>VPC.</p><p>Subnets.</p><p>Route tables.</p><p>Internet connectivity.</p><p>Security groups.</p><p>EC2.</p><p>RDS.</p><p>Dependencies between resources.</p><p>Suddenly, the architecture wasn’t just something I could draw.</p><p>It was something I could <strong>declare</strong>.</p><h3>Then We Made It Three-Tier</h3><p>Because apparently two floors weren’t enough.</p><p>We moved into the <strong>three-tier architecture</strong>.</p><p>This separated the system into:</p><p><strong>Web/Presentation Tier → Application Tier → Database Tier</strong></p><p>Now we had a much clearer separation of responsibilities.</p><p>The web tier handles incoming user requests.</p><p>The application tier handles the business logic.</p><p>The database tier stores the application’s data.</p><p>Think of a restaurant.</p><p>The customer doesn’t walk into the kitchen and start cooking.</p><p>The waiter takes the order.</p><p>The kitchen prepares it.</p><p>The pantry and refrigerator hold the ingredients.</p><p>Different responsibilities.</p><p>Different access.</p><p>One coordinated system.</p><p>That’s essentially what the architecture is trying to accomplish.</p><p>And, as someone who has managed a household, I appreciate any system where everyone has a clearly defined responsibility.</p><p>Although I’m still waiting for AWS to create a service called <strong>aws-family-cleanup</strong>.</p><p>I would deploy that immediately.</p><h3>The Terraform Template Became Its Own Debugging Story</h3><p>But here’s the part people don’t always show when they talk about Infrastructure as Code.</p><p>Writing Terraform wasn’t:</p><p><strong>“I typed the code and everything worked.”</strong></p><p>Oh no.</p><p>There was back and forth.</p><p>A lot of back and forth.</p><p>We created Terraform configurations.</p><p>Ran terraform init.</p><p>Checked the configuration.</p><p>Ran terraform validate.</p><p>Then:</p><p><strong>Error.</strong></p><p>Modified the configuration.</p><p>Ran terraform plan.</p><p>Another error.</p><p>Adjusted resource references.</p><p>Checked variables.</p><p>Looked at dependencies.</p><p>Changed security group rules.</p><p>Revisited subnet configuration.</p><p>Ran the plan again.</p><p>And again.</p><p>And again.</p><p>This was actually one of the most valuable parts of the exercise.</p><p>Because Terraform forced me to think about infrastructure as a <strong>system of relationships</strong>.</p><p>An EC2 instance doesn’t exist in isolation.</p><p>It belongs somewhere.</p><p>A subnet belongs to a VPC.</p><p>A route table controls traffic.</p><p>A security group controls access.</p><p>A database needs networking.</p><p>The application needs to know how to reach the database.</p><p>Everything is connected.</p><p>Terraform made those relationships explicit.</p><p>And when one relationship was wrong…</p><p>Terraform politely introduced me to the consequences.</p><h3>The Boeing 777 Is Finally Leaving the Runway</h3><p>This is where my aviation analogy comes back.</p><p>At the beginning of my DevOps journey, I was manually pushing the aircraft down the runway.</p><p>Every task required effort.</p><p>Every environment required configuration.</p><p>Every change required careful manual execution.</p><p>Now I’m starting to build the systems that help the aircraft take off more efficiently.</p><p>Terraform handles infrastructure provisioning.</p><p>Bash handles repetitive server-management tasks.</p><p>Agentic AI helps me reason through problems, review configurations and automate parts of my workflow.</p><p>And next week?</p><p><strong>Ansible is coming.</strong></p><p>Apparently, my DevOps aircraft has decided it needs another crew member.</p><p>Ansible is a configuration management and automation tool that can help manage servers consistently.</p><p>Which means I can hopefully spend less time SSH-ing into individual machines and manually configuring them one by one.</p><p>My terminal and I are going to miss each other.</p><p>Probably.</p><h3>And This Is Where Women Should Pay Attention</h3><p>There is something about this transition that I think is especially relevant to women considering technology.</p><p>We often look at experienced engineers and see the finished product.</p><p>The person confidently typing commands.</p><p>The person who knows exactly which AWS service to use.</p><p>The person who looks at a Terraform error and doesn’t blink.</p><p>What we don’t see is the runway.</p><p>The hours of confusion.</p><p>The documentation.</p><p>The failed configurations.</p><p>The embarrassing beginner questions.</p><p>The countless:</p><p><strong>“Why is this not working?”</strong></p><p>And the even more humbling:</p><p><strong>“Oh. I forgot a bracket.”</strong></p><p>Technology can make you feel like everyone else received the manual except you.</p><p>They didn’t.</p><p>They’re just further along the runway.</p><p>And here’s the beautiful thing about automation.</p><p>You don’t need to remain the person manually pushing the aircraft forever.</p><p>You learn the manual process first.</p><p>Then you understand what can be automated.</p><p>Then you automate it.</p><p>Then you improve the automation.</p><p>Then you start thinking about the architecture itself.</p><p>That is growth.</p><h3>I Am Not Flying Yet. But I’m Getting Off the Ground.</h3><p>Looking back, I realize Terraform isn’t simply another DevOps tool I’ve added to my list.</p><p>It represents a change in how I think.</p><p>I am moving from <strong>doing infrastructure</strong> to <strong>describing infrastructure</strong>.</p><p>From manually configuring resources to defining desired states.</p><p>From repeating tasks to creating reusable configurations.</p><p>From clicking through consoles to managing infrastructure through code.</p><p>And perhaps most importantly, from asking:</p><p><strong>“How do I build this?”</strong></p><p>to asking:</p><p><strong>“How do I build this so I don’t have to rebuild it manually next time?”</strong></p><p>That question feels like progress.</p><p>The Boeing 777 analogy still holds.</p><p>I’m not cruising at 35,000 feet yet.</p><p>I’m still watching the instruments.</p><p>Still learning what all those buttons do.</p><p>Still occasionally wondering whether I’ve pressed the right one.</p><p>But the aircraft is moving.</p><p>The runway is getting shorter.</p><p>And the nose is beginning to lift.</p><p>Next week, Ansible joins the crew.</p><p>Let’s see what happens when we start automating the servers too.</p><p><strong>For now, I’m just grateful to be in the cockpit.</strong> ✈️☁️</p><h3>One more thing…</h3><p>I’ve been documenting this journey through my projects, architectures, cloud deployments, automation experiments and the occasional battle with a stubborn terminal.</p><p>If you’d like to see the <strong>Book Review application, EpicBook architecture, AWS deployments, Terraform work and the rest of my DevOps journey</strong>, I’ve put them together in my portfolio.</p><p><strong>Come take a look.</strong></p><p>The aircraft is still taking off. 🚀</p><p><strong>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by [Pravin Mishra](</strong>https://www.linkedin.com/in/pravin-mishra-aws-trainer/<strong>). My graded progress is public: </strong><a href="https://dmi.pravinmishra.com/s/sarah254-tech.html"><strong>https://dmi.pravinmishra.com/s/sarah254-tech.html</strong></a><strong> · Start your DevOps journey: </strong><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3"><strong>https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ac1f8728047" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Same Infrastructure, Different Clouds]]></title>
            <link>https://medium.com/@sarahamadi97/same-infrastructure-different-clouds-92248fd36fd7?source=rss-db65f5f81408------2</link>
            <guid isPermaLink="false">https://medium.com/p/92248fd36fd7</guid>
            <category><![CDATA[tech4dev]]></category>
            <category><![CDATA[women-in-tech]]></category>
            <dc:creator><![CDATA[Sarahamadi]]></dc:creator>
            <pubDate>Fri, 21 Aug 2026 06:46:19 GMT</pubDate>
            <atom:updated>2026-08-21T06:46:19.852Z</atom:updated>
            <content:encoded><![CDATA[<p><em>What moving from AWS to Azure taught me about competence, discomfort, and the woman behind the terminal.</em></p><p>This week, something interesting happened.</p><p>I built almost the same things I had just built on AWS.</p><p>Two-tier architecture.</p><p>Three-tier architecture.</p><p>High availability.</p><p>Multiple Availability Zones, or in Azure’s language, <strong>Availability Zones</strong>.</p><p>Virtual machines.</p><p>Networking.</p><p>Application deployment.</p><p>Health checks.</p><p>Different cloud.</p><p>Same engineering problem.</p><p>And yet…</p><p>It felt like learning to drive again.</p><p>Except the car was the same, the road was different, the steering wheel had moved slightly, and someone had decided that the indicator should now live somewhere completely different.</p><p>Welcome to Azure.</p><h3>Same Problem. Different Cloud.</h3><p>After spending time getting comfortable navigating AWS, moving into Azure gave me an interesting reality check.</p><p>I knew what I wanted to build.</p><p>I understood the architecture.</p><p>I knew why I needed a virtual machine, networking, security rules, application tiers and redundancy.</p><p>But knowing <strong>what</strong> I wanted didn’t always mean knowing <strong>where Azure had hidden it</strong>.</p><p>And that distinction taught me something important about learning technology.</p><p>Competence isn’t the same as familiarity.</p><p>You can understand the concept and still feel like a beginner when you enter a new environment.</p><p>That was humbling.</p><p>And strangely exciting.</p><p>I wasn’t starting from zero.</p><p>I was transferring knowledge.</p><h3>Then I Remembered a Book</h3><p>Recently, I found myself thinking about <em>The Road Less Traveled</em> by <strong>M. Scott Peck</strong>.</p><p>One of the ideas that stayed with me is his argument that growth requires us to confront difficulty rather than constantly trying to avoid it.</p><p>Peck writes:</p><blockquote><em>“Problems are the cutting edge that distinguishes between success and failure.”</em></blockquote><p>That line kept coming back to me this week.</p><p>Because Azure wasn’t necessarily difficult because the concepts were new.</p><p>It was difficult because I had to become uncomfortable again.</p><p>I had to click around.</p><p>Search.</p><p>Read.</p><p>Break things.</p><p>Ask questions.</p><p>Try again.</p><p>And sometimes stare at the screen thinking:</p><p><strong>“AWS, you would never treat me like this.”</strong></p><p>But that’s the point.</p><p>If I had stayed only with what I already knew, I would have remained comfortable.</p><p>Comfortable is lovely.</p><p>But it doesn’t always make you better.</p><h3>Resilience Isn’t Enough</h3><p>I’ve been talking a lot about resilience in my previous reflections.</p><p>And I still believe resilience matters.</p><p>But this week made me realize something.</p><p><strong>Resilience gets you back up. Discipline keeps you walking.</strong></p><p>Mastering a new skill requires more than surviving the frustrating days.</p><p>It requires showing up on the days when you don’t feel particularly clever.</p><p>It means being willing to be a beginner again.</p><p>It means accepting that the fact that you successfully built something yesterday doesn’t guarantee you’ll understand today’s interface.</p><p>And that is particularly relevant when you’re changing careers.</p><p>Especially as a woman.</p><p>Because there is already so much pressure to appear competent.</p><p>At work.</p><p>At home.</p><p>As a mother.</p><p>As a professional.</p><p>As the person who somehow knows where everyone’s missing socks are.</p><p>We can become so afraid of looking inexperienced that we avoid situations where we might actually learn.</p><p>But technology has been teaching me the opposite.</p><p>Sometimes you have to be willing to look like you don’t know what you’re doing long enough to actually learn what you’re doing.</p><h3>Learning Azure While Being a Woman Is a Different Kind of Multi-Cloud</h3><p>There is another thing I’ve been thinking about.</p><p>Cloud architecture talks constantly about <strong>scalability</strong>.</p><p>Women know scalability.</p><p>We have been scaling responsibilities since forever.</p><p>Career.</p><p>Motherhood.</p><p>Household.</p><p>Relationships.</p><p>Learning.</p><p>And somehow remembering that someone needs to take their lunchbox to school tomorrow.</p><p>My calendar doesn’t have an Availability Zone.</p><p>It has:</p><p><strong>Zone 1:</strong> Work.</p><p><strong>Zone 2:</strong> Children.</p><p><strong>Zone 3:</strong> Household.</p><p><strong>Zone 4:</strong> “Why is the internet not working?”</p><p>And occasionally:</p><p><strong>Zone 5:</strong> Sit quietly and stare at the wall.</p><p>High availability has nothing on motherhood.</p><p>But this week, I realized that the same principle applies to learning.</p><p>You can’t build your entire identity around one skill, one role, or one version of yourself.</p><p>You need room to evolve.</p><h3>From AWS to Azure: The Architecture Was Familiar, the Thinking Wasn’t</h3><p>Building the two-tier architecture in Azure was a reminder that architectural principles travel.</p><p>The names and interfaces may change.</p><p>The underlying problems remain.</p><p>How do I connect my application to its dependencies?</p><p>How do I secure communication?</p><p>How do I distribute workloads?</p><p>How do I design for failure?</p><p>How do I make my application available?</p><p>Then came the three-tier architecture.</p><p>The presentation layer.</p><p>The application layer.</p><p>The database layer.</p><p>Three different responsibilities.</p><p>Three different places where things can go wrong.</p><p>And, ideally, three opportunities to design things better.</p><p>It reminded me of a household again.</p><p>One person asks:</p><p><strong>“What’s for dinner?”</strong></p><p>Another person says:</p><p><strong>“I’m making dinner.”</strong></p><p>And somewhere in the background, the refrigerator is silently holding all the evidence.</p><p>Three tiers.</p><p>Clear responsibilities.</p><p>Minimal unnecessary interference.</p><p>If only family meetings worked this way.</p><h3>The Humbling Part of Learning</h3><p>One of the hardest things about becoming competent is accepting that competence often feels like incompetence while you’re building it.</p><p>When you know nothing, you expect to struggle.</p><p>But when you’ve already learned something, struggling in a new environment can feel strangely embarrassing.</p><p>You think:</p><p><em>“But I already know DevOps. Why does this feel so hard?”</em></p><p>Because knowing DevOps isn’t the same as knowing every cloud platform.</p><p>And knowing AWS doesn’t mean Azure should feel identical.</p><p>That realization has been good for me.</p><p>It has reminded me to stay curious.</p><p>To ask questions.</p><p>To read documentation.</p><p>To experiment.</p><p>To let myself be wrong.</p><p>And then try again.</p><h3>The Road Less Traveled</h3><p>Peck’s broader argument is that growth comes through disciplined engagement with life’s difficulties. He describes discipline through ideas such as delaying gratification, accepting responsibility, dedication to truth, and balancing competing demands.</p><p>I see those ideas differently now.</p><p>Delaying gratification looks like studying when scrolling would be easier.</p><p>Accepting responsibility looks like admitting, “I don’t understand this yet.”</p><p>Dedication to truth looks like being honest about the gaps in my knowledge.</p><p>And balancing?</p><p>That one feels particularly familiar.</p><p>Because sometimes the Azure lab has to wait because somebody needs dinner.</p><p>Sometimes the children need me.</p><p>Sometimes the house needs attention.</p><p>And sometimes I need to close the laptop and breathe.</p><p>Balance doesn’t mean giving everything equal time.</p><p>It means understanding what needs you now.</p><h3>Same Me. New Cloud.</h3><p>Perhaps the most important thing I learned this week wasn’t about Azure at all.</p><p>It was about mastery.</p><p>Mastery isn’t knowing everything.</p><p>It is becoming increasingly comfortable with not knowing something yet.</p><p>It is having enough confidence to enter a new environment and say:</p><p><strong>“Okay. I don’t know where this button is. But I’ll figure it out.”</strong></p><p>And perhaps that’s what this career transition has been teaching me all along.</p><p>I didn’t leave healthcare and magically become a technology professional.</p><p>I am building.</p><p>Layer by layer.</p><p>Skill by skill.</p><p>Failure by failure.</p><p>Cloud by cloud.</p><p>AWS taught me one way of thinking about infrastructure.</p><p>Azure is teaching me to transfer that thinking.</p><p>And somewhere between the two, I am learning something even more valuable:</p><p><strong>The real skill isn’t mastering one cloud. It’s becoming the kind of person who can learn the next one.</strong></p><p>That feels bigger than DevOps.</p><p>It feels like a lesson for anyone rebuilding a career, raising children, navigating womanhood, or simply trying to become a newer version of herself.</p><p>Sometimes the road less travelled isn’t a completely different road.</p><p>Sometimes it’s the same destination…</p><p>but you have to learn how to navigate a different landscape.</p><p>And perhaps that is where the real growth happens.</p><p>One cloud at a time. ☁️</p><p><strong>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by [Pravin Mishra](</strong>https://www.linkedin.com/in/pravin-mishra-aws-trainer/<strong>). My graded progress is public: </strong><a href="https://dmi.pravinmishra.com/s/sarah254-tech.html"><strong>https://dmi.pravinmishra.com/s/sarah254-tech.html</strong></a><strong> · Start your DevOps journey: </strong><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3"><strong>https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92248fd36fd7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[This Week, AWS Became My New Family Meeting]]></title>
            <link>https://medium.com/@sarahamadi97/this-week-aws-became-my-new-family-meeting-4e5279b54242?source=rss-db65f5f81408------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e5279b54242</guid>
            <category><![CDATA[women-in-tech]]></category>
            <category><![CDATA[tech4dev]]></category>
            <category><![CDATA[aws-architecture]]></category>
            <dc:creator><![CDATA[Sarahamadi]]></dc:creator>
            <pubDate>Sun, 16 Aug 2026 06:47:41 GMT</pubDate>
            <atom:updated>2026-08-17T01:29:44.923Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yveBvTwTniIFLY5Nn-UJVg.png" /><figcaption>Three Tier Architecture</figcaption></figure><p><em>Two-tier. Three-tier. Multi-AZ. Claude. Health checks. And somehow, I still managed to keep the children alive.</em></p><p>There are weeks when you learn a few new technical concepts.</p><p>And then there are weeks when AWS looks at you and says:</p><p><strong>“You thought you understood cloud architecture? Cute. Let’s talk.”</strong></p><p>This week was one of a kind.</p><p>I built and deployed architectures.</p><p>I deliberately broke things.</p><p>I recovered them.</p><p>I tested high availability.</p><p>I worked with multiple Availability Zones.</p><p>I built a two-tier architecture.</p><p>Then I graduated to a three-tier architecture.</p><p>I used Claude to help with AWS health checks.</p><p>And somewhere between all of that, I was still being a mother, answering household questions, running errands, and trying to remember whether I had already had my morning coffee.</p><p>At this point, I’m beginning to suspect DevOps and motherhood have the same job description:</p><p><strong>Keep everything running, expect something to break, and have a backup plan.</strong></p><h3>Two-Tier Architecture: The Marriage</h3><p>My first major architectural lesson this week was the <strong>two-tier architecture</strong>.</p><p>Think of it as a marriage.</p><p>You have two major layers that need to communicate and depend on each other.</p><p>One handles the application or web workload.</p><p>The other handles the database.</p><p>Simple enough.</p><p>Until you remember that the whole point of cloud architecture is not simply to make things work.</p><p>It’s to make them <strong>reliable</strong>.</p><p>So we introduced multiple Availability Zones.</p><p>An <strong>Availability Zone (AZ)</strong> is essentially a physically separate location within an AWS Region, designed so that a failure in one location doesn’t necessarily take everything down with it.</p><p>In other words:</p><p><strong>Don’t put all your eggs in one data centre.</strong></p><p>As a woman, this principle feels strangely familiar.</p><p>Never depend on one person for everything.</p><p>Have a backup.</p><p>Actually, have a backup for the backup.</p><p>And if you have children?</p><p>You already understand disaster recovery.</p><p>Someone spills juice on the floor five minutes before visitors arrive.</p><p>You don’t stare at the juice philosophically.</p><p>You recover.</p><p>You clean.</p><p>You continue.</p><p>That is high availability with snacks.</p><h3>Then Came the Three-Tier Architecture</h3><p>Just when I thought I had the family meeting under control, AWS introduced another child.</p><p>The <strong>three-tier architecture</strong>.</p><p>This time, instead of two layers, we separate the application into:</p><p><strong>Presentation layer → Application layer → Database layer</strong></p><p>The presentation layer is what the user interacts with.</p><p>The application layer contains the business logic.</p><p>The database layer stores the data.</p><p>And suddenly, the system isn’t just working.</p><p>It’s organized.</p><p>Each layer has a responsibility.</p><p>Each layer can scale independently.</p><p>Each layer can be secured independently.</p><p>And, importantly, one layer doesn’t need to know everything about the others.</p><p>Honestly, this architecture reminded me of running a household.</p><p>There is the person asking for food.</p><p>There is the person actually preparing the food.</p><p>And there is the refrigerator where the food is stored.</p><p>Everyone has a job.</p><p>Nobody needs to be standing inside the refrigerator trying to cook.</p><p>That would be poor architecture.</p><p>And probably poor parenting.</p><h3>Multi-AZ: Because One Location Is Never Enough</h3><p>Then we made the architecture more resilient by distributing resources across multiple Availability Zones.</p><p>This was one of the concepts that really started to click for me.</p><p><strong>High availability isn’t about assuming nothing will fail.</strong></p><p>It’s about designing with the assumption that something eventually will.</p><p>That mindset is very different.</p><p>Instead of asking:</p><p><em>“How do I stop this system from failing?”</em></p><p>you begin asking:</p><p><em>“What happens when this component fails?”</em></p><p>That is a very DevOps question.</p><p>And strangely, a very motherhood question too.</p><p>What happens if the child refuses to eat?</p><p>What happens if the school calls?</p><p>What happens if the electricity goes out?</p><p>What happens if visitors arrive unexpectedly?</p><p>What happens if your carefully planned day completely collapses at 10:17 a.m.?</p><p>You adapt.</p><p>You reroute.</p><p>You keep going.</p><p>Apparently, I’ve been practicing resilience engineering for years.</p><p>I just didn’t know it was called <strong>DevOps</strong>.</p><h3>Then I Let Claude Into the Infrastructure</h3><p>As if AWS wasn’t already giving me enough homework, I brought <strong>Claude</strong> into the conversation.</p><p>This week I worked with an AI-assisted AWS health-check workflow.</p><p>The idea was simple:</p><p>Instead of manually checking everything and trying to remember what might be wrong, I could use automation and AI to gather evidence, analyze the system state, identify potential issues, and help guide the investigation.</p><p>But here’s the part I found most important.</p><p>Claude wasn’t the person in charge.</p><p>I was.</p><p>The AI could analyze.</p><p>It could suggest.</p><p>It could help me understand what the system was saying.</p><p>But I still had to decide what action to take.</p><p>That distinction is becoming increasingly important in my DevOps journey.</p><p>AI can be your incredibly knowledgeable colleague.</p><p>It can even be the colleague who never sleeps.</p><p>But you still need someone in the room who understands the system well enough to say:</p><p><strong>“Interesting suggestion. But absolutely not in production.”</strong></p><h3>The Architecture Wasn’t the Only Thing Being Built</h3><p>Looking back at this week, I realize I wasn’t just building AWS infrastructure.</p><p>I was building a different way of thinking.</p><p>Earlier in my career, I was trained to focus deeply on my professional discipline.</p><p>Now I’m learning to think in systems.</p><p>How do the components connect?</p><p>Where can failure occur?</p><p>What happens when something goes down?</p><p>How quickly can we recover?</p><p>Can we automate the repetitive work?</p><p>Can we monitor the system?</p><p>Can we make the architecture more secure?</p><p>Can we design it so that one failure doesn’t bring everything down?</p><p>These questions have changed the way I see technology.</p><p>And perhaps more importantly, they have changed how I see myself in technology.</p><h3>The Woman Behind the Architecture</h3><p>There is something almost amusing about learning cloud architecture while navigating the complexity of womanhood.</p><p>Because technology loves to talk about <strong>scalability</strong>.</p><p>Women have been scaling responsibilities since forever.</p><p>One minute you’re learning Terraform.</p><p>The next you’re answering a household question.</p><p>Then you’re debugging an AWS deployment.</p><p>Then someone needs lunch.</p><p>Then your phone rings.</p><p>Then you’re back to your terminal wondering why your target group is unhealthy. (this actually happened this week!)</p><p>There is no clean separation.</p><p>No neat little diagram showing:</p><p><strong>9:00–11:00 AM: Motherhood</strong></p><p><strong>11:00 AM–1:00 PM: DevOps</strong></p><p><strong>1:00–2:00 PM: Existential crisis</strong></p><p>Life doesn’t work like that.</p><p>And perhaps that is why I am becoming more comfortable with complexity.</p><p>I’m learning that being distracted by life doesn’t mean I can’t build technically complex things.</p><p>Being a mother doesn’t make me less technical.</p><p>Changing careers doesn’t erase everything I learned before.</p><p>Starting at 40 doesn’t mean starting from zero.</p><p>It means starting with a very large amount of context.</p><h3>What This Week Gave Me</h3><p>This week gave me more than AWS experience.</p><p>It gave me another layer of confidence.</p><p>I can look at a three-tier architecture now and understand why the layers exist.</p><p>I can think about Availability Zones and understand why redundancy matters.</p><p>I can deliberately introduce failure and investigate what happens.</p><p>I can build health checks.</p><p>I can use Bash and AI to automate operational work.</p><p>I can look at a broken system and not immediately panic.</p><p>Well…</p><p>I might panic for approximately 30 seconds.</p><p>Then I open the terminal.</p><p>Because somewhere along this journey, debugging became my strange little happy place.</p><p>And that might be the most unexpected thing about this career change.</p><p>I came into DevOps thinking I was learning technology.</p><p>I’m beginning to realize I’m also learning resilience.</p><h3>And So, We Keep Building</h3><p>There was a time when the idea of building cloud infrastructure would have sounded completely foreign to me.</p><p>Today, I can spend a morning discussing Availability Zones and application layers, an afternoon troubleshooting infrastructure, and an evening wondering whether the children actually ate the food I prepared.</p><p>Life is still messy.</p><p>The systems are still complicated.</p><p>Things still break.</p><p>But now I know something I didn’t know before.</p><p><strong>Complexity doesn’t have to scare me.</strong></p><p>Sometimes, complexity is simply a collection of smaller problems waiting to be understood.</p><p>And maybe that’s what this entire career transition has been.</p><p>Not starting over.</p><p>Not abandoning the woman I was.</p><p>But taking everything I’ve learned from healthcare, from motherhood, from years of solving real-world problems, and bringing it into a completely different kind of infrastructure.</p><p>This week, I built systems designed to survive failure.</p><p>And somewhere in between the AWS console, terminal windows, architecture diagrams, and AI-assisted health checks, I realized something quietly beautiful:</p><p><strong>Perhaps I am doing the same thing with my own life.</strong></p><p>Building something more resilient.</p><p>One layer at a time.</p><p>One failure at a time.</p><p>One recovery at a time.</p><p>And when I look back at where I started, I can’t help but feel a little nostalgic.</p><p>The woman who once wondered whether she belonged in tech would probably be surprised to see me now.</p><p>She might not understand half the architecture.</p><p>But I think she’d recognize the determination.</p><p>And I’d probably tell her:</p><p><em>“Keep going. You’ll eventually find your way around the cloud.”</em></p><p>☁️</p><p><strong>I documented this journey and the projects I’m building in my portfolio. If you’d like to see the architecture, deployments, and the work behind these reflections, come take a look.</strong></p><p><a href="http://sarah-w-amadi-personal-portfolio.s3-website-us-east-1.amazonaws.com/">http://sarah-w-amadi-personal-portfolio.s3-website-us-east-1.amazonaws.com/</a></p><p><strong>The journey is still very much in progress.</strong></p><p><strong>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by [Pravin Mishra](</strong>https://www.linkedin.com/in/pravin-mishra-aws-trainer/<strong>). My graded progress is public: </strong><a href="https://dmi.pravinmishra.com/s/sarah254-tech.html"><strong>https://dmi.pravinmishra.com/s/sarah254-tech.html</strong></a><strong> · Start your DevOps journey: </strong><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3"><strong>https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e5279b54242" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Software Development Life Cycle Taught Me Something About Starting Over]]></title>
            <link>https://medium.com/@sarahamadi97/the-software-development-life-cycle-taught-me-something-about-starting-over-d28a449c09f9?source=rss-db65f5f81408------2</link>
            <guid isPermaLink="false">https://medium.com/p/d28a449c09f9</guid>
            <category><![CDATA[womens-health]]></category>
            <category><![CDATA[dmibypravinmishra]]></category>
            <category><![CDATA[women-in-tech]]></category>
            <category><![CDATA[tech4dev]]></category>
            <dc:creator><![CDATA[Sarahamadi]]></dc:creator>
            <pubDate>Wed, 29 Jul 2026 04:26:14 GMT</pubDate>
            <atom:updated>2026-07-29T14:42:28.675Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9ULcEZR-zulFQpG6DIJBeg.png" /><figcaption>SDLC loop with AI</figcaption></figure><p><em>A software product doesn’t become successful in one step. Neither does a career.</em></p><p>One diagram stayed with me this week.</p><p>Not because it was particularly colorful or complicated.</p><p>In fact, it looked deceptively simple.</p><p>A circle with a handful of stages.</p><p><strong>Analysis. Design. Development. Testing. Deployment. Maintenance.</strong></p><p>The Software Development Life Cycle, or SDLC.</p><p>At first glance, it looks like an engineering process.</p><p>But the longer I stared at it, the less it looked like software.</p><p>It started looking like life.</p><p>Especially mine.</p><h3>We Think Careers Should Be Like Waterfall</h3><p>For years, software teams followed something called the <strong>Waterfall model</strong>.</p><p>The idea was simple.</p><p>Finish one stage before moving to the next.</p><p>No going back.</p><p>No changing your mind.</p><p>No revisiting old decisions.</p><p>If life worked like Waterfall, it would sound something like this:</p><p>Go to school.</p><p>Choose a career.</p><p>Work in that profession for forty years.</p><p>Retire.</p><p>The End.</p><p>That sounds wonderfully organized.</p><p>It also sounds nothing like real life.</p><p>Because life has a habit of introducing unexpected plot twists.</p><p>Mine certainly did.</p><p>After spending years in health sciences, I found myself learning Linux commands, deploying cloud infrastructure, writing Bash scripts, and collaborating with AI agents.</p><p>If someone had shown my younger self a terminal full of logs instead of a pharmacy shelf, she would probably have assumed they had the wrong person.</p><p>But maybe they didn’t.</p><p>Maybe I was entering another stage of the same story.</p><h3>Then I Met Agile</h3><p>Modern software teams rarely build products the Waterfall way anymore.</p><p>Instead, they use <strong>Agile</strong>.</p><p>Agile accepts something incredibly human.</p><p>You won’t get everything right the first time.</p><p>So instead of waiting until everything is perfect, teams build something small, gather feedback, improve it, and repeat.</p><p>It’s less about perfection.</p><p>More about progress.</p><p>And honestly…</p><p>Isn’t that a better way to build a career too?</p><p>As women, we’re often taught that we need to have everything figured out before making a move.</p><p>Every qualification.</p><p>Every certification.</p><p>Every answer.</p><p>Every confidence boost.</p><p>Only then are we “ready.”</p><p>Technology has taught me something different.</p><p>Sometimes you become ready by building.</p><p>Then learning.</p><p>Then improving.</p><p>Then building again.</p><p>Iteration isn’t failure.</p><p>It’s growth.</p><h3>It Takes More Than One Engineer to Build Great Software</h3><p>One lesson from this week’s internship surprised me.</p><p>The strongest software isn’t created by one brilliant developer working alone.</p><p>It begins long before anyone writes code.</p><p>Business analysts ask questions.</p><p>Designers think about users.</p><p>Developers build.</p><p>Testers look for hidden problems.</p><p>DevOps engineers prepare reliable deployments.</p><p>Security engineers think like attackers.</p><p>Operations teams keep everything running.</p><p>Every perspective matters.</p><p>Reading that made me smile.</p><p>Because it reminded me of women.</p><p>How often do we wear multiple hats without realizing the value each role brings?</p><p>We are planners.</p><p>Problem-solvers.</p><p>Caregivers.</p><p>Negotiators.</p><p>Organizers.</p><p>Listeners.</p><p>Decision-makers.</p><p>Those aren’t distractions from engineering.</p><p>They’re strengths.</p><p>Technology doesn’t just need people who can write code.</p><p>It needs people who understand people.</p><h3>Then AI Entered the Room</h3><p>Just as I was beginning to understand the SDLC, another player quietly joined the team.</p><p>Artificial Intelligence.</p><p>Tools like Claude Code, GitHub Copilot, and Amazon Q Developer are changing how software gets built.</p><p>They can help generate code.</p><p>Review changes.</p><p>Suggest improvements.</p><p>Write documentation.</p><p>Even automate repetitive tasks.</p><p>The obvious question is whether AI will replace engineers.</p><p>But after spending the past few weeks working alongside AI, I think that’s the wrong question.</p><p>The better question is this:</p><p><strong>What becomes more valuable when AI handles the repetitive work?</strong></p><p>My answer keeps coming back to the same things.</p><p>Judgment.</p><p>Creativity.</p><p>Communication.</p><p>Empathy.</p><p>Ethics.</p><p>Systems thinking.</p><p>Curiosity.</p><p>Interestingly…</p><p>Those are qualities that many women have spent years developing in every area of life.</p><p>Maybe that’s why I’m not afraid of AI.</p><p>I’m curious about what it allows us to become.</p><h3>Is the SDLC Becoming a Circle That Thinks?</h3><p>One thought has been sitting with me ever since this week’s lesson.</p><p>The Software Development Life Cycle has always been described as a loop.</p><p>Ideas become products.</p><p>Products improve.</p><p>The cycle begins again.</p><p>But now AI is starting to participate in almost every stage.</p><p>It can help analyze requirements.</p><p>Generate code.</p><p>Write tests.</p><p>Review pull requests.</p><p>Monitor systems.</p><p>Summarize incidents.</p><p>Generate documentation.</p><p>The loop is becoming faster.</p><p>Smarter.</p><p>More connected.</p><p>Sometimes I wonder whether we’re witnessing the birth of an SDLC that can almost complete itself.</p><p>Not because humans disappear.</p><p>But because humans move higher.</p><p>Away from repetitive tasks.</p><p>Closer to strategy.</p><p>Closer to innovation.</p><p>Closer to the decisions that require wisdom instead of computation.</p><h3>My Biggest Reflection This Week</h3><p>I used to think software engineering was mostly about writing code.</p><p>Now I realize it’s really about building systems that solve problems.</p><p>The code is simply one of the tools.</p><p>The same realization changed how I see my own career.</p><p>I’m not leaving healthcare behind.</p><p>I’m helping build the infrastructure that modern healthcare increasingly depends on.</p><p>Different tools.</p><p>Same purpose.</p><p>And maybe that’s what the SDLC has been trying to teach me all along.</p><p>Nothing meaningful is ever built in one perfect attempt.</p><p>Not software.</p><p>Not careers.</p><p>Not confidence.</p><p>Not ourselves.</p><p>Everything worth building goes through analysis, testing, failure, improvement, and another iteration.</p><p>So if you’re a woman wondering whether it’s “too late” to start a career in technology, let me leave you with this.</p><p>The best software engineers don’t wait until they know everything before they build.</p><p>They build.</p><p>They learn.</p><p>They improve.</p><p>Then they build again.</p><p>Maybe our careers were never meant to follow Waterfall.</p><p>Maybe they were always meant to be Agile.</p><p><em>To my mentors, </em><strong><em>Pravin Mishra</em></strong><em>, </em><strong><em>Anjana Muthunayake</em></strong><em>, and </em><strong><em>Joy Ukpabi</em></strong><em>, thank you for continually reminding us that engineering isn’t just about mastering tools: it’s about learning how to think.</em></p><p><strong>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by [Pravin Mishra](</strong>https://www.linkedin.com/in/pravin-mishra-aws-trainer/<strong>). My graded progress is public: </strong><a href="https://dmi.pravinmishra.com/s/sarah254-tech.html"><strong>https://dmi.pravinmishra.com/s/sarah254-tech.html</strong></a><strong> · Start your DevOps journey: </strong><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3**"><strong>https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d28a449c09f9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Finally Understood Why DevOps Engineers Are So Paranoid]]></title>
            <link>https://medium.com/@sarahamadi97/i-finally-understood-why-devops-engineers-are-so-paranoid-fe2611cd3961?source=rss-db65f5f81408------2</link>
            <guid isPermaLink="false">https://medium.com/p/fe2611cd3961</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[dmibypravinmishra]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Sarahamadi]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 09:26:15 GMT</pubDate>
            <atom:updated>2026-07-29T14:45:18.535Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Or why engineers trust Bash scripts more than they trust themselves.</em></p><p>When I first started learning DevOps, I thought engineers were just… dramatic.</p><p>Why all the reviews?</p><p>Why all the approvals?</p><p>Why all the automated checks?</p><p>Why does everyone seem personally offended by the phrase, “I’ll just push this small change quickly”?</p><p>Now I know.</p><p>Because somewhere, sometime, someone <em>did</em> push that “small change.”</p><p>And production still talks about it.</p><p>This week of my internship felt less like learning Git and more like attending group therapy for engineers who have seen things.</p><p>Apparently, DevOps engineers don’t wake up wondering,</p><p><em>“How can I deploy faster today?”</em></p><p>They wake up wondering,</p><p><em>“How can I stop Future Me from doing something incredibly stupid?”</em></p><p>That realization made me laugh.</p><p>Then it made perfect sense.</p><h3>Meet My New Babysitter</h3><p>This week I wrote my first <strong>Git pre-commit hook</strong>.</p><p>For anyone outside tech, imagine trying to leave the house wearing slippers, mismatched earrings, and forgetting your phone.</p><p>Your mother stops you at the door.</p><p>“No.”</p><p>Not because she enjoys ruining your morning.</p><p>Because she’s saving you from embarrassing yourself in public.</p><p>A Git pre-commit hook does exactly that.</p><p>Except instead of checking your outfit, it checks your code.</p><p>Mine had one job.</p><p>Look through every staged change before Git accepted my commit.</p><p>If it found something suspicious like a hardcoded AWS access key…</p><p>“No.”</p><p>A massive file that had absolutely no business being inside a repository?</p><p>“No.”</p><p>Try again.</p><p>No negotiations.</p><p>No emotional support.</p><p>Just rejection.</p><p>Cold.</p><p>Efficient.</p><p>Beautiful.</p><h3>Then Claude Entered the Conversation…</h3><p>Just when I thought my Bash script had become the strict parent of the project, along came <strong>Claude Code</strong> with a personality completely different from Bash.</p><p>If Bash is your African mother saying,</p><p><em>“You’re not leaving this house dressed like that.”</em></p><p>Claude is your thoughtful friend saying,</p><p><em>“You can wear that… but are you sure?”</em></p><p>I built a Claude Code Skill called <strong>/pr-ready</strong>.</p><p>Instead of enforcing rules, it reviewed my staged changes.</p><p>It spotted a fake AWS access key.</p><p>Found a forgotten debug statement.</p><p>Suggested a cleaner Pull Request title.</p><p>Even drafted the Pull Request description.</p><p>Basically, Claude became that colleague who quietly reviews your work before your manager sees it.</p><p>Helpful.</p><p>Observant.</p><p>Slightly annoying because it notices everything.</p><p>But here’s the interesting part.</p><p>Claude never edited my files.</p><p>Never committed my code.</p><p>Never pushed my branch.</p><p>Never opened the Pull Request.</p><p>It politely stopped at advice.</p><p>The decisions stayed with me.</p><p>And I think that’s exactly how AI should work.</p><h3>The Difference Between Automation and Intelligence</h3><p>Before this week, I subconsciously lumped automation and AI into one big category.</p><p>“Machines doing things.”</p><p>Now I see they’re solving completely different problems.</p><p>Bash doesn’t think.</p><p>It obeys.</p><p>If you tell it,</p><blockquote><em>“Reject every commit containing AWS keys,”</em></blockquote><blockquote>it will reject every single one.</blockquote><p>No exceptions.</p><p>No creativity.</p><p>No opinions.</p><p>AI is different.</p><p>It reasons.</p><p>It notices patterns.</p><p>It reads context.</p><p>It can tell you,</p><p><em>“This code looks fine… but this debug statement probably shouldn’t be here.”</em></p><p>That’s not a rule.</p><p>That’s judgment.</p><p>One enforces.</p><p>The other advises.</p><p>One is a security guard.</p><p>The other is a reviewer.</p><p>And together?</p><p>They’re surprisingly good teammates.</p><h3>The Human Still Owns Production</h3><p>One thing became obvious while building this workflow.</p><p>AI can recommend.</p><p>Automation can enforce.</p><p>Neither should own the final decision.</p><p>That responsibility still belongs to the engineer.</p><p>Because when production goes down, nobody calls Bash.</p><p>Nobody schedules a meeting with Claude.</p><p>Humans still answer the uncomfortable questions.</p><p>Humans still own the consequences.</p><p>Which means humans should continue making the final decisions.</p><p>That balance feels less like “AI replacing engineers” and more like “AI making engineers more thoughtful.”</p><p>I like that future.</p><h3>My Biggest Lesson This Week</h3><p>I used to think great engineers built faster.</p><p>Now I think great engineers build systems that assume humans will eventually make mistakes.</p><p>Including themselves.</p><p>Especially themselves.</p><p>Maybe that’s why DevOps has so many guardrails.</p><p>Not because engineers don’t trust technology.</p><p>Because they’ve learned not to trust Tuesday afternoon versions of themselves after four meetings, three coffees, and one “quick fix.”</p><p>Honestly…</p><p>That’s probably the wisest thing I’ve learned all week.</p><h3>Final Thought</h3><p>Week after week, this internship keeps changing how I think about engineering.</p><p>A few weeks ago, debugging became my version of mindfulness.</p><p>This week, I discovered that safety isn’t what slows engineers down.</p><p>It’s what allows them to move fast without breaking everything.</p><p>Or, to put it another way…</p><p><strong>Every experienced DevOps engineer has two personalities.</strong></p><p>The optimistic one says:</p><blockquote><em>“This tiny change will be fine.”</em></blockquote><p>The experienced one quietly writes another safety check… just in case.</p><p>And after this week?</p><p>I’m starting to understand why.</p><p><strong>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by [Pravin Mishra](</strong>https://www.linkedin.com/in/pravin-mishra-aws-trainer/<strong>). My graded progress is public: </strong><a href="https://dmi.pravinmishra.com/s/sarah254-tech.html"><strong>https://dmi.pravinmishra.com/s/sarah254-tech.html</strong></a><strong> · Start your DevOps journey: </strong><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3**"><strong>https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe2611cd3961" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Starting Over at 40 Was Never the Plan. Building the Future Was]]></title>
            <link>https://medium.com/@sarahamadi97/starting-over-at-40-was-never-the-plan-building-the-future-was-aad7a8df843f?source=rss-db65f5f81408------2</link>
            <guid isPermaLink="false">https://medium.com/p/aad7a8df843f</guid>
            <category><![CDATA[publiclearn]]></category>
            <category><![CDATA[dmibypravinmishra]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Sarahamadi]]></dc:creator>
            <pubDate>Sun, 19 Jul 2026 19:13:01 GMT</pubDate>
            <atom:updated>2026-07-29T14:43:59.621Z</atom:updated>
            <content:encoded><![CDATA[<p>At 40, people often assume you’ve already figured out your career.</p><p>That you’ve chosen your lane, climbed the ladder, and settled into what you’ll do for the rest of your working life.</p><p>I thought so too.</p><p>For over a decade, I worked in health sciences, serving communities, improving patient care, and contributing to healthcare systems. It was meaningful work. It shaped who I am.</p><p>Then life happened.</p><p>I found myself learning Linux commands instead of clinical guidelines, deploying applications instead of dispensing medicines, and debugging servers instead of healthcare workflows.</p><p>From the outside, it looked like I had left healthcare for DevOps.</p><p>But the more I learn, the more I realize I never really left.</p><p>I’m simply changing the tools I use to solve the same problem.</p><p>Healthcare today isn’t built on hospitals alone. It’s built on digital infrastructure.</p><p>Electronic health records.</p><p>Cloud platforms.</p><p>Secure patient data.</p><p>Reliable systems that doctors, nurses, pharmacists, and patients depend on every single day.</p><p>Someone has to build and maintain that infrastructure.</p><p>Why shouldn’t that be someone who understands healthcare from the inside?</p><p>That realization changed everything for me.</p><p>I stopped seeing myself as someone “starting over.”</p><p>Instead, I began seeing myself as someone adding another language to an existing story.</p><p>Health sciences taught me empathy, precision, ethics, and accountability.</p><p>DevOps is teaching me automation, resilience, scalability, and systems thinking.</p><p>Together, they create something far more powerful than either discipline alone.</p><p>Starting again at 40 isn’t about abandoning your past.</p><p>It’s about allowing your past to become your advantage.</p><p>Every career teaches you something the next one will need.</p><p>Sometimes the dots only connect when you’re brave enough to draw a new line between them.</p><p>So no, I’m not moving away from healthcare.</p><p>I’m helping build the digital infrastructure that modern healthcare will stand on.</p><p>And somehow, that feels less like starting over…</p><p>…and more like finally seeing the bigger picture.</p><p><strong>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by [Pravin Mishra](</strong>https://www.linkedin.com/in/pravin-mishra-aws-trainer/<strong>). My graded progress is public: </strong><a href="https://dmi.pravinmishra.com/s/sarah254-tech.html"><strong>https://dmi.pravinmishra.com/s/sarah254-tech.html</strong></a><strong> · Start your DevOps journey: </strong><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3**"><strong>https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aad7a8df843f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>