<?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 Jacquelina Stanley on Medium]]></title>
        <description><![CDATA[Stories by Jacquelina Stanley on Medium]]></description>
        <link>https://medium.com/@jacquelinastanley?source=rss-2168a1c046ce------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*1CY4R0vzxYd7rNCBX_5cXw.png</url>
            <title>Stories by Jacquelina Stanley on Medium</title>
            <link>https://medium.com/@jacquelinastanley?source=rss-2168a1c046ce------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:28:44 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jacquelinastanley/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 a Highly Available Two-Tier Application on AWS: What Worked, What Broke, and What I…]]></title>
            <link>https://medium.com/@jacquelinastanley/building-a-highly-available-two-tier-application-on-aws-what-worked-what-broke-and-what-i-5d5b40f9700c?source=rss-2168a1c046ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/5d5b40f9700c</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Jacquelina Stanley]]></dc:creator>
            <pubDate>Mon, 24 Aug 2026 15:54:57 GMT</pubDate>
            <atom:updated>2026-08-24T15:54:57.474Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building a Highly Available Two-Tier Application on AWS: What Worked, What Broke, and What I Learned</h3><p>I took on one of the more challenging AWS assignments so far: deploying a <strong>highly available two-tier application</strong> using a VPC, Application Load Balancer, Auto Scaling Group, EC2, and Multi-AZ Amazon RDS.</p><p>This assignment went beyond simply getting an application online.</p><p>The real goal was to design an environment where the application could <strong>survive the failure of an EC2 instance or an Availability Zone and continue serving users</strong>.</p><p>And while the final architecture looked clean, getting there involved quite a bit of troubleshooting.</p><h3>🏗️ What I Built</h3><p>The architecture consisted of:</p><ul><li>A custom VPC using 10.0.0.0/16</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ALBYV0XVcLLgbkv6egJYQg.png" /></figure><ul><li>Two Availability Zones</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kQA9MuMxydLFUr3pwZx0Uw.png" /></figure><ul><li>Two public subnets and Two private subnets</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3zOFDDKMRcxWtysrCDsdQQ.png" /></figure><ul><li>An Internet Gateway</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*11pVvfWkuOHPgPNCUS8qxw.png" /></figure><ul><li>A NAT Gateway</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LMockD1rgFqLTjmIikJ85g.png" /></figure><ul><li>Public and private route tables</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xJ-QpvbYAjiuIIGtvxia-A.png" /></figure><ul><li>Three security groups following least-privilege principles</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HhDhkfYedbQwlay5oGO3NQ.png" /></figure><ul><li>A private Multi-AZ MySQL RDS database ( however due to AWS free-tier limitations this was only deployed in one AZ)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*okn9fHYAe1MnreCXOpK7zQ.png" /></figure><ul><li>Ubuntu EC2 instances running Apache, PHP, and WordPress</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5sqHqeOHZoli2r9-1vK1lw.png" /></figure><ul><li>An EC2 Launch Template with automated User Data</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UFEZBLMPuKZcbDxmHMPYvA.png" /></figure><ul><li>An Application Load Balancer</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KpL7zNh030bcAr1vMlvfqg.png" /></figure><ul><li>An Auto Scaling Group maintaining two EC2 instances</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iEdWsPYqqLM2Z4Usrg2ZpA.png" /></figure><ul><li>An ALB Target Group with health checks</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OAnXPT1CPlQqSjJz5mBF_g.png" /></figure><ul><li>Real failure testing to prove high availability</li></ul><p>The architecture separates the public web tier from the private database tier while distributing the application across two Availability Zones. This follows the structure required by the assignment.</p><h3>🌐 Step 1 — Building the Highly Available Network</h3><p>I started by creating a custom VPC:</p><pre>10.0.0.0/16</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w5exzeNetvxpO2MsS-9YFg.png" /></figure><p>I then divided the network across two Availability Zones.</p><pre>Public Subnet A   → 10.0.1.0/24<br>Public Subnet B   → 10.0.2.0/24</pre><pre>Private Subnet A  → 10.0.11.0/24<br>Private Subnet B  → 10.0.12.0/24</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yXF1m76fcA5Va-f8Yhdx8g.png" /></figure><p>The public subnets were associated with a route table containing:</p><pre>0.0.0.0/0 → Internet Gateway</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-L-uhoFW-JRr47V7w6FCFA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4vHNRzO9q0qNJYaYYZ7uYQ.png" /></figure><p>The private subnets used:</p><pre>0.0.0.0/0 → NAT Gateway</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Pluu7MGXuTxNXI081ggmPw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bBUXbaT8dcPkq8afaukXhQ.png" /></figure><p>This meant internet-facing components could operate in the public tier while the database remained isolated in the private tier.</p><h3>🔐 Step 2 — Designing Security Around the Traffic Flow</h3><p>Instead of allowing every component to communicate freely, I created three separate Security Groups:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/93/1*EJgjI_cI_uVkRsps8-UDkg.png" /></figure><blockquote>ha-alb-sg accepts HTTP traffic from the internet.</blockquote><blockquote>ha-web-sg accepts HTTP traffic from <strong>only the ALB Security Group</strong>, rather than allowing every IP address on the internet.</blockquote><blockquote>ha-db-sg accepts MySQL traffic on port 3306 from <strong>only </strong><strong>ha-web-sg</strong>.</blockquote><p>This was one of the most useful lessons from the assignment.</p><p>Security Groups don’t always need to reference IP addresses. Referencing another Security Group creates a much more scalable architecture because EC2 instances can be replaced without needing to update database firewall rules.</p><h3>🗄️ Step 3 — Deploying the Private Multi-AZ Database</h3><p>For the database tier, I created a MySQL Amazon RDS instance.</p><p>The important part was that the database was:</p><pre>Multi-AZ: Yes<br>Publicly Accessible: No</pre><p>I created a DB Subnet Group using the two private subnets and attached ha-db-sg.</p><p>This kept the database inaccessible directly from the internet while allowing the EC2 application tier to communicate with it.</p><p>My application database was:</p><pre>appdb</pre><p>while the RDS instance itself was named separately.</p><p>That distinction became very important later.</p><h3>⚙️ Step 4 — Automating EC2 Deployment with User Data</h3><p>Next, I created an EC2 Launch Template.</p><p>Instead of manually configuring every EC2 instance, I used <strong>User Data</strong> to bootstrap each server automatically.</p><p>Currently on my github I have a few user data scripts for you to check out : <a href="https://github.com/jacquelinastanley/UserDataScript">https://github.com/jacquelinastanley/UserDataScript</a></p><p>It then downloaded WordPress, deployed it to Apache’s web root, configured permissions, generated the WordPress configuration and connected WordPress to RDS.</p><p>This was essential because an Auto Scaling Group needs to be able to create a completely new EC2 instance without me manually logging into it.</p><h3>🐛 Problem #1 — My EC2 Public IP Timed Out</h3><p>When I launched a temporary EC2 instance from the Launch Template and entered its public IP into my browser, I expected WordPress to appear.</p><p>Instead:</p><pre>ERR_CONNECTION_TIMED_OUT</pre><p>At first, this looked like the deployment had completely failed.</p><p>I checked the networking and eventually realised the problem was actually caused by my least-privilege Security Group design.</p><p>ha-web-sg contained:</p><pre>HTTP 80 → ha-alb-sg</pre><p>That was correct for the final architecture, but I was trying to access the EC2 instance <strong>directly from my browser</strong>, bypassing the ALB.</p><p>My computer was therefore not an allowed HTTP source.</p><h3>🔧 The Fix</h3><p>For testing only, I temporarily added:</p><pre>HTTP<br>Port 80<br>Source 0.0.0.0/0</pre><p>to ha-web-sg.</p><p>The EC2 server immediately became reachable.</p><p>After completing the direct-instance test, I removed the temporary rule so the final architecture returned to:</p><pre>Internet → ALB → EC2</pre><p>rather than:</p><pre>Internet → EC2</pre><p>The assignment solution specifically uses this temporary HTTP rule for the direct EC2 validation before removing it again.</p><p>But fixing that exposed my next problem.</p><h3>🐛 Problem #2 — “Error Establishing a Database Connection”</h3><p>The EC2 server was finally reachable.</p><p>But instead of seeing the WordPress installation screen, I saw:</p><pre>Error establishing a database connection</pre><p>This was useful because it told me something important:</p><p><strong>Apache and WordPress were working.</strong></p><p>The problem was now between:</p><pre>WordPress → RDS</pre><p>I needed to determine whether this was:</p><ul><li>a Security Group problem,</li><li>an RDS networking problem,</li><li>an incorrect endpoint,</li><li>incorrect credentials,</li><li>or an incorrect database name.</li></ul><h3>🛠️ Troubleshooting Through SSH</h3><p>I SSH’d into the Ubuntu EC2 instance to investigate.</p><p>I checked WordPress’s database configuration:</p><pre>sudo grep -E &quot;DB_NAME|DB_USER|DB_HOST&quot; /var/www/html/wp-config.php</pre><p>This showed that WordPress was configured with:</p><pre>DB_NAME = ha-db-new<br>DB_USER = admin</pre><p>I then tested the actual RDS connection.</p><p>After installing the MySQL client, I connected directly from EC2 to RDS:</p><pre>mysql -h &lt;RDS-ENDPOINT&gt; -u admin -p</pre><p>The connection succeeded.</p><p>That proved several things simultaneously:</p><pre>EC2 → RDS network path     ✓<br>Port 3306                  ✓<br>ha-db-sg                   ✓<br>RDS endpoint               ✓<br>Username/password          ✓</pre><p>I then ran:</p><pre>SHOW DATABASES;</pre><p>And found:</p><pre>appdb<br>information_schema<br>mysql<br>performance_schema<br>sys</pre><p>That exposed my mistake.</p><h3>🐛 Problem #3 — I Confused the RDS Instance Name with the Database Name</h3><p>My WordPress configuration contained:</p><pre>DB_NAME = ha-db-new</pre><p>But the actual MySQL database was:</p><pre>appdb</pre><p>I had confused two different concepts:</p><pre>RDS instance identifier<br>≠<br>MySQL database/schema</pre><p>The RDS instance could be called:</p><pre>ha-db-new</pre><p>while WordPress still needed:</p><pre>DB_NAME = appdb</pre><p>I corrected wp-config.php:</p><pre>DB_NAME = appdb</pre><p>After restarting Apache and refreshing the browser, WordPress could communicate with RDS correctly.</p><p>This was probably my biggest technical lesson from the deployment: <strong>resource names at the AWS infrastructure layer are not necessarily the same as application-level database names.</strong></p><h3>⚠️ Fixing the Instance Wasn’t Enough</h3><p>There was another important lesson here.</p><p>I had manually corrected:</p><pre>DB_NAME = appdb</pre><p>on my test instance.</p><p>That fixed <strong>that particular EC2 instance</strong>.</p><p>But this was an Auto Scaling architecture.</p><p>If an instance failed, the Auto Scaling Group would create another instance from the Launch Template.</p><p>That new server would run the original User Data and recreate the same mistake.</p><p>So I needed to correct the <strong>Launch Template itself</strong>, not just the running server.</p><p>I created a corrected Launch Template version so future EC2 instances automatically used:</p><pre>DB_NAME = appdb</pre><p>This is where the difference between simply “fixing a server” and managing infrastructure designed for automatic recovery became much clearer to me.</p><h3>⚖️ Step 5 — Adding the Application Load Balancer</h3><p>I then created an internet-facing Application Load Balancer across both public subnets.</p><p>The ALB listened on:</p><pre>HTTP :80</pre><p>and forwarded requests to:</p><pre>ha-web-tg</pre><p>The ALB was associated with ha-alb-sg, while the EC2 instances accepted HTTP traffic from that Security Group.</p><h3>📈 Step 6 — Creating the Auto Scaling Group</h3><p>Next, I created an Auto Scaling Group using the Launch Template.</p><p>I configured:</p><pre>Minimum capacity: 2<br>Desired capacity: 2<br>Maximum capacity: 4</pre><p>The ASG was configured across both public subnets and registered with the ALB Target Group.</p><p>This resulted in two EC2 instances distributed across separate Availability Zones.</p><h3>🐛 Problem #4 — Both ALB Targets Became Unhealthy</h3><p>Creating the ASG didn’t immediately mean everything was healthy.</p><p>When I opened:</p><pre>Target Groups → ha-web-tg → Targets</pre><p>both instances showed:</p><pre>Unhealthy</pre><p>AWS reported:</p><pre>Health checks failed with these codes: [500]</pre><p>This was another useful troubleshooting clue.</p><p>A timeout would suggest that the ALB couldn’t reach the EC2 instance.</p><p>But HTTP 500 meant:</p><pre>ALB → EC2 connectivity ✓<br>Application response   ✗</pre><p>The problem was inside the application.</p><p>The ASG instances had been created using the Launch Template configuration that still contained the incorrect database setting.</p><p>I therefore corrected the Launch Template rather than manually modifying every ASG-managed server.</p><p>That matters because manually repairing an Auto Scaling instance defeats one of the main benefits of Auto Scaling.</p><p>The server should be <strong>disposable and reproducible</strong>.</p><h3>🐛 Problem #5 — Health Check Changed from 500 to 302</h3><p>After correcting the application configuration and replacing an unhealthy instance, something interesting happened.</p><p>The target changed from:</p><pre>500</pre><p>to:</p><pre>302</pre><p>That was progress.</p><p>HTTP 302 means the application is responding but redirecting the request.</p><p>WordPress can redirect / during setup or as part of its normal URL behaviour.</p><p>My Target Group was expecting only:</p><pre>200</pre><p>as a successful response.</p><p>I updated the Target Group health-check success codes to:</p><pre>200-399</pre><p>This allowed valid HTTP redirects to count as successful health-check responses.</p><p>This troubleshooting process helped me understand that an <strong>Unhealthy</strong> target does not automatically mean the EC2 instance is unreachable.</p><p>The status code matters:</p><pre>Timeout → investigate network/security/server</pre><pre>500 → ALB reached server, application failed</pre><pre>302 → application responded with a redirect</pre><pre>200 → successful response</pre><p>That distinction made troubleshooting much faster.</p><h3>📝 Step 7 — Proving RDS Read and Write Operations</h3><p>Once the infrastructure was healthy, I accessed WordPress through the <strong>ALB DNS name</strong> rather than an individual EC2 IP address.</p><p>I completed the WordPress installation and created a test post.</p><p>Publishing the post created data in the private RDS database.</p><p>Reloading the application retrieved that data again.</p><p>That demonstrated both:</p><pre>Application → RDS WRITE ✓</pre><pre>RDS → Application READ ✓</pre><p>More importantly, users interacted with the application through the ALB rather than knowing which EC2 instance handled their request.</p><h3>💥 Step 8 — Actually Testing High Availability</h3><p>Creating multiple instances doesn’t automatically prove high availability.</p><p>I needed to deliberately break things.</p><h3>Test A — Terminating an EC2 Instance</h3><p>With two healthy instances running, I deliberately terminated one ASG-managed EC2 instance.</p><p>Because the Auto Scaling Group had:</p><pre>Desired capacity = 2</pre><p>it detected that only one instance remained and automatically launched another.</p><p>While this happened, the Application Load Balancer could continue directing requests to the remaining healthy instance.</p><p>Eventually the replacement:</p><ol><li>launched,</li><li>executed the Launch Template User Data,</li><li>configured WordPress,</li><li>connected to RDS,</li><li>registered with the Target Group,</li><li>passed its health checks.</li></ol><p>This was where fixing the Launch Template earlier became essential.</p><p>If I had only manually fixed the original EC2 servers, the replacement would have launched with the old broken configuration.</p><h3>🌍 Test B — Simulating an Availability Zone Impact</h3><p>For the second test, I temporarily removed one web instance from active service.</p><p>This simulated losing application capacity from one Availability Zone.</p><p>The important result wasn’t that an instance disappeared.</p><p>It was that the user-facing application remained available.</p><p>Traffic continued through:</p><pre>Internet<br>    ↓<br>ALB<br>    ↓<br>Healthy EC2 instance in the other AZ<br>    ↓<br>RDS</pre><p>I refreshed the application using the ALB DNS endpoint and confirmed that it continued responding.</p><h3>💡 What I Learned from the Mistakes</h3><p>This assignment taught me more through the failures than it would have if everything worked on the first attempt.</p><h3>1. A timeout and HTTP 500 are completely different problems</h3><p>When the browser timed out, I investigated networking and Security Groups.</p><p>When the ALB received HTTP 500, I investigated the application.</p><p>When it received 302, I investigated health-check behaviour.</p><p>Understanding <strong>where the request failed</strong> prevented me from randomly changing AWS settings.</p><h3>2. AWS resource names and application configuration are different layers</h3><p>My RDS instance identifier and MySQL database name were not interchangeable.</p><pre>RDS instance: ha-db-new</pre><pre>Database:<br>appdb</pre><p>WordPress needed the database name, not the RDS instance identifier.</p><h3>3. Auto Scaling changes how problems should be fixed</h3><p>Manually SSHing into a server and fixing it may solve an immediate problem.</p><p>But in an Auto Scaling environment, that fix disappears when the instance disappears.</p><p>The correct question became:</p><blockquote><em>If AWS destroys this instance right now, will the replacement configure itself correctly?</em></blockquote><p>That meant correcting the <strong>Launch Template/User Data</strong> instead of relying on manual server changes.</p><h3>4. Security Group references are more scalable than IP-based rules</h3><p>Allowing:</p><pre>ha-db-sg ← ha-web-sg</pre><p>means replacement EC2 instances automatically inherit database access through their Security Group.</p><p>I don’t need to know their private IP addresses.</p><h3>5. Health checks provide troubleshooting information</h3><p>I initially saw “Unhealthy” as simply meaning something was broken.</p><p>Now I look at the actual response:</p><pre>500 → application problem<br>302 → redirect<br>Timeout → connectivity/server problem</pre><p>The health check isn’t just a green/red indicator. It’s part of the diagnostic process.</p><h3>6. High availability has to be tested</h3><p>Having two instances on a diagram doesn’t prove high availability.</p><p>Terminating an instance and watching the system recover does.</p><p>Taking one instance out of service and confirming the application remains available does.</p><p>That was the point where the architecture stopped being theoretical.</p><h3>🏁 Final Architecture</h3><p>By the end of the assignment, the environment provided multiple layers of availability:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/946/1*L6liDN1lcsbD45xlYmcqwg.png" /></figure><ul><li>The ALB provided a single entry point.</li><li>The Auto Scaling Group maintained web-tier capacity.</li><li>Multiple Availability Zones reduced dependence on a single location.</li><li>Multi-AZ RDS provided database-tier resilience.</li></ul><p>Security Group references enforced controlled communication between each layer.</p><p>And most importantly, the failure tests demonstrated that the application could continue operating when part of the infrastructure was deliberately disrupted.</p><h3>🚀 Final Takeaway</h3><p>This assignment wasn’t simply about launching AWS resources.</p><p>It was about understanding how the resources depend on each other and learning how to diagnose what happens when one part doesn’t behave as expected.</p><p>I went from:</p><pre>ERR_CONNECTION_TIMED_OUT</pre><p>to:</p><pre>Error establishing a database connection</pre><p>to:</p><pre>Target unhealthy — HTTP 500</pre><p>to:</p><pre>Target healthy — HTTP 302</pre><p>and finally to a functioning highly available architecture.</p><p>Each error narrowed the problem down to a different layer.</p><p>That troubleshooting journey gave me a much better understanding of <strong>networking, Security Groups, application configuration, health checks, immutable infrastructure, load balancing, Auto Scaling and high availability on AWS</strong>.</p><p>The biggest lesson I took away was this:</p><blockquote><strong><em>High availability isn’t proven when everything is running. It’s proven when something fails and the application keeps running.</em></strong></blockquote><p>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by Pravin Mishra. My graded progress is public: <a href="https://dmi.pravinmishra.com/s/jacquelinastanley.html">https://dmi.pravinmishra.com/s/jacquelinastanley.html</a>· <br>Start your DevOps journey: <a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3">https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d5b40f9700c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Backlog to Deployment: What I Learned Working in a 5-Person Scrum Team for 3 Days]]></title>
            <link>https://medium.com/@jacquelinastanley/from-backlog-to-deployment-what-i-learned-working-in-a-5-person-scrum-team-for-3-days-9e066b64361d?source=rss-2168a1c046ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e066b64361d</guid>
            <category><![CDATA[jira]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[teamwork]]></category>
            <dc:creator><![CDATA[Jacquelina Stanley]]></dc:creator>
            <pubDate>Sat, 08 Aug 2026 07:43:53 GMT</pubDate>
            <atom:updated>2026-08-08T07:43:53.371Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*RJ_bJ6PtTkUNuhqr4P_Bnw.jpeg" /></figure><p>Over the past three days, I worked with a team of five on a hands-on Scrum and Jira assignment built around the Gotto Job website.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eV5W4xoUPirGMnkzA_gbZw.png" /></figure><p>The goal sounded simple at first: refine a product backlog, estimate the work, plan a sprint, make a small UI improvement, deploy it, and provide evidence that the work was completed.</p><p>What made the experience valuable was not just completing the technical tasks. It was learning how much communication, coordination, and shared decision-making goes into completing even a small sprint as a team.</p><h3>Day 1: Turning Requirements Into a Backlog</h3><p>We started by reviewing the assignment requirements and understanding what we were actually expected to deliver.</p><p>Instead of jumping straight into coding, we first focused on the product backlog.</p><p>We created an Epic around improving the Gotto Job user interface and then broke that larger goal into smaller user stories.</p><p>These included improvements such as:</p><ul><li>Clarifying the homepage hero message</li><li>Improving CTA visibility</li><li>Updating job-card typography</li><li>Adding a REMOTE badge</li><li>Improving advanced search labels</li><li>Adding an Apply Now CTA</li><li>Adding About and Contact links to the footer</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vIS1sR9b0sB1uNFW.png" /></figure><p>One of the first things we realised was that creating a ticket is easy.</p><p>Creating a clear ticket is different.</p><p>Each story needed to explain what the user needed, why the change mattered, and what conditions had to be satisfied before we could consider the work complete.</p><p>That pushed us to think beyond simply saying:</p><p>“Change this button.”</p><p>Instead, we had to define acceptance criteria that another team member could actually verify.</p><h3>Estimating the Work Together</h3><p>Once the backlog was created, we moved into estimation.</p><p>This is where Planning Poker came in and we used <a href="https://planningpokeronline.com/">https://planningpokeronline.com/</a> to perform this and make it fun and interactive.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zcySOe6k6EcPmDl8.png" /></figure><p>We used Fibonacci-style story points of 1, 2, and 3.</p><p>This became one of the more interesting parts of working as a group.</p><p>A change that looked like a 1-point story to one person could look like a 2-point story to somebody else.</p><p>For example, changing a small piece of text was relatively straightforward.</p><p>But a change affecting several job cards, responsive behaviour, styling, and verification carried more effort and risk.</p><p>Instead of just choosing a number, we discussed why we believed a story deserved a particular estimate.</p><p>That was an important lesson for me.</p><p>Story points are not simply about how many minutes something will take.</p><p>They help a team develop a shared understanding of effort, complexity, uncertainty, and risk.</p><h3>Day 2: Sprint Planning and Shared Ownership</h3><p>On the second day, we moved from backlog refinement into Sprint Planning.</p><p>We had to decide what could realistically fit into Sprint 1.</p><p>That meant we could not simply move every story into the sprint.</p><p>We had to prioritise.</p><p>Our Sprint Goal focused on delivering a small number of visible UI improvements that could actually be shown on the live Gotto Job website.</p><p>We selected a manageable number of stories and broke each one into smaller subtasks:</p><ul><li>Build</li><li>Verify</li><li>Deploy</li><li>Screenshot</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7vIwV8i_71WAdttS.png" /></figure><p>I liked this part of the workflow because it made the work much more transparent.</p><p>A story was no longer just “in progress.”</p><p>We could see whether development had started, whether the change had been verified, whether it had been deployed, and whether the required evidence had been captured.</p><p>Working as a team also meant that no single person owned the entire sprint in isolation.</p><p>Different people could contribute to planning, implementation, testing, deployment, documentation, and verification.</p><p>That shared ownership was probably the biggest difference compared with doing a similar assignment alone.</p><h3>Communication Became Part of the Work</h3><p>One thing that stood out during the three days was how often we had to communicate.</p><p>We discussed priorities.</p><p>We checked whether stories met the assignment requirements.</p><p>We compared estimates.</p><p>We reviewed what still needed to be completed.</p><p>We made sure screenshots were being captured at the correct stages.</p><p>We checked whether Jira reflected what was actually happening.</p><p>At times, someone would notice something another person had missed.</p><p>That could be a missing acceptance criterion, a story that had not been assigned correctly, a subtask that still needed updating, or a piece of evidence that had not yet been captured.</p><p>That is where the value of working as a group became very clear.</p><p>The work became stronger because it was being inspected by more than one person.</p><h3>Day 3: From Jira Ticket to a Live Increment</h3><p>The final stage was where the Scrum workflow connected with the DevOps workflow.</p><p>One small UI-only change had to move beyond the Jira board and become a real deployed increment.</p><p>The process followed a simple lifecycle:</p><p>Backlog → Sprint → In Progress → Build → Verify → Commit → Deploy → Done</p><p>The change was made in the source code and then checked locally.</p><p>After verification, it was committed using Git with a meaningful commit message.</p><p>From there, the updated site was deployed to the live environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sxAGb-dyBBq9wy6a.png" /></figure><p>We then opened the live URL and confirmed that the change was actually visible.</p><p>This step mattered to me because it highlighted an important difference between saying work is finished and proving that it is finished.</p><p>A Jira ticket being moved to Done does not automatically mean the customer has received value.</p><p>The code has to work.</p><p>The deployment has to succeed.</p><p>The live result has to be verified.</p><p>Only then does the completed ticket really represent a shipped increment.</p><h3>Jira Was Our Shared Source of Truth</h3><p>Throughout the exercise, Jira helped us keep the work visible.</p><p>We used it for:</p><ul><li>The Epic</li><li>The product backlog</li><li>User stories</li><li>Acceptance criteria</li><li>Story-point estimates</li><li>Sprint Planning</li><li>Subtasks</li><li>Status updates</li><li>The Sprint board</li><li>The Burndown Chart</li><li>Retrospective notes</li></ul><p>The Burndown Chart was particularly useful because it connected the work on the board to sprint transparency.</p><p>Even during a short exercise, it helped reinforce the idea that Scrum teams should be able to see how much work remains and whether the sprint is moving towards its goal.</p><h3>What Working as Five People Taught Me</h3><p>The biggest lesson from these three days was that teamwork is not simply dividing five tickets between five people.</p><p>It is maintaining a shared understanding of what the team is trying to achieve.</p><p>That required us to communicate, review each other’s work, discuss estimates, stay aware of blockers, and make sure the final delivery satisfied the same goal.</p><p>There were moments when our views differed.</p><p>That was actually useful.</p><p>Instead of treating disagreement as a problem, we had to explain our reasoning and reach a decision together.</p><p>That process made our backlog and sprint stronger.</p><p>It also gave me a better understanding of why Scrum places so much importance on transparency, inspection, adaptation, commitment, focus, openness, courage, and respect.</p><p>Those concepts make far more sense when you experience them through actual teamwork.</p><h3>What I Would Improve Next Time</h3><p>If I repeated the exercise, I would prepare some of the technical environment earlier.</p><p>For example, I would make sure the repository, local source code, deployment environment, and access permissions were completely ready before Sprint Planning.</p><p>That would allow more of the sprint time to be spent on delivery instead of setup.</p><p>I would also make team ownership even clearer at the beginning.</p><p>Instead of only discussing which story each person is helping with, I would explicitly identify who is responsible for development, verification, Jira updates, deployment, and final evidence for each item.</p><p>That would reduce duplication and make handoffs easier.</p><h3>My Main Takeaway</h3><p>Before this assignment, it would have been easy to describe Scrum as a backlog, a sprint, a Jira board, and a few meetings.</p><p>After working through the process with four other people for three days, I see it differently.</p><p>The tools help organise the work, but the team creates the delivery.</p><p>The backlog gave us direction.</p><p>Sprint Planning gave us focus.</p><p>Jira gave us transparency.</p><p>Git gave us traceability.</p><p>Deployment gave us a real increment.</p><p>But communication was what connected all of those pieces together.</p><p>That is the part of this assignment I will remember most.</p><p>A small UI change may look simple when you only see the final website.</p><p>Behind that change was a team discussing, estimating, building, verifying, deploying, documenting, and making sure we reached the same Sprint Goal together.</p><p>And that is what made the three days feel like much more than just another assignment.</p><p>P.S. This post is part of the DevOps Micro Internship (DMI) with Agentic AI — Cohort 3 — by <a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">Pravin Mishra</a>. My graded progress is public: <a href="https://dmi.pravinmishra.com/s/jacquelinastanley.html">https://dmi.pravinmishra.com/s/jacquelinastanley.html</a>·</p><p>Start your DevOps journey: <a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3">https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e066b64361d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning Git Without Breaking Everything]]></title>
            <link>https://medium.com/@jacquelinastanley/learning-git-without-breaking-everything-24197d361c19?source=rss-2168a1c046ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/24197d361c19</guid>
            <dc:creator><![CDATA[Jacquelina Stanley]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 18:34:53 GMT</pubDate>
            <atom:updated>2026-07-21T18:34:53.298Z</atom:updated>
            <content:encoded><![CDATA[<p>When I first started learning Git and GitHub, I thought it would just be a tool to upload code.</p><p>This week completely changed that perspective.</p><p>I learned that Git isn’t just about storing code. It’s about protecting your work, collaborating safely, and making sure mistakes can always be recovered.</p><h3>Building Better Git Habits</h3><p>One of the biggest lessons this week was understanding that every command has a purpose.</p><p>I worked through creating repositories, cloning projects, creating feature branches, committing changes, and pushing updates to GitHub.</p><p>Over time I realized they all fit together into one workflow.</p><p>Instead of editing code directly on the main branch, I learned how feature branches allow you to experiment without affecting production.</p><p>That simple concept makes collaboration much safer.</p><h3>Understanding Branch Isolation</h3><p>One exercise that really stood out was proving branch isolation.</p><p>I switched between my feature branch and the main branch to verify that my changes only existed where they were supposed to.</p><p>Seeing files disappear and reappear depending on the branch made Git “click” for me.</p><p>It wasn’t magic.</p><p>It was version control working exactly as designed.</p><h3>My First Pull Request</h3><p>Another milestone was creating my first Pull Request.</p><p>It felt like a small achievement, but it represented something much bigger.</p><p>Instead of simply pushing code, I was following the same workflow used by software teams around the world.</p><p>A Pull Request isn’t just about merging code.</p><p>It’s an opportunity to review changes, discuss improvements, and make collaboration easier.</p><h3>Learning Through Mistakes</h3><p>Not everything went perfectly.</p><p>During one of the live sessions I accidentally exposed my SSH key and Personal Access Token while screen sharing.</p><p>Thankfully, I learned how to revoke credentials, remove SSH agents, regenerate secure keys, and understand why secrets should never be shared publicly.</p><p>It was an uncomfortable mistake, but probably one of the most valuable security lessons I’ve learned.</p><p>Sometimes the best lessons come from fixing your own mistakes.</p><h3>Understanding Git Recovery</h3><p>One thing I really appreciated was learning that Git has safety nets built into almost everything.</p><p>Throughout the week I found myself asking questions like:</p><ul><li>How do I undo a checkout?</li><li>Can I recover from deleting something?</li><li>What happens if I create the wrong branch?</li><li>How do I safely remove files?</li></ul><p>Every answer reinforced the same idea.</p><p>Git expects developers to make mistakes.</p><p>It provides ways to recover from them.</p><p>Knowing that made me much more confident experimenting with new commands.</p><h3>More Than Just Commands</h3><p>This week wasn’t really about Git commands.</p><p>It was about understanding why professional development teams work the way they do.</p><p>Branches protect production.</p><p>Commits document progress.</p><p>Pull Requests encourage collaboration.</p><p>GitHub provides transparency.</p><p>Together they create a workflow that allows hundreds or even thousands of developers to work on the same project without constantly overwriting each other’s work.</p><h3>Looking Back</h3><p>Compared to a few weeks ago, I feel much more comfortable working with Git.</p><p>I’m still learning every day, but I’ve gone from simply following commands to actually understanding what each step is accomplishing.</p><p>That confidence is something I didn’t expect to gain so quickly.</p><p>There is still a long way to go on my DevOps journey, but every week adds another layer of understanding.</p><p>And that’s exactly what makes this internship so rewarding.</p><p><strong>P.S.</strong></p><p>This post is part of the <strong>DevOps Micro Internship (DMI) with Agentic AI — Cohort 3</strong> by <strong>Pravin Mishra</strong>.</p><p>My graded progress is public:<br><a href="https://dmi.pravinmishra.com/s/jacquelinastanley.html">https://dmi.pravinmishra.com/s/jacquelinastanley.html</a></p><p>Start your DevOps journey:<br><a href="https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3">https://dmi.pravinmishra.com/?utm_source=student&amp;utm_medium=ps-blog&amp;utm_campaign=cohort3</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=24197d361c19" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building AI Workflows That Assists DevOps Engineers.]]></title>
            <link>https://medium.com/@jacquelinastanley/building-ai-workflows-that-assists-devops-engineers-58c92224c017?source=rss-2168a1c046ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/58c92224c017</guid>
            <dc:creator><![CDATA[Jacquelina Stanley]]></dc:creator>
            <pubDate>Fri, 17 Jul 2026 08:21:40 GMT</pubDate>
            <atom:updated>2026-07-17T08:21:40.595Z</atom:updated>
            <content:encoded><![CDATA[<p>**P.S. This post is part of the DevOps Micro Internship with Agentic AI Cohort 3 by Pravin Mishra (<a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">https://www.linkedin.com/in/pravin-mishra-aws-trainer/</a>). You can begin your DevOps journey by joining the DMI waiting list (<a href="https://forms.gle/3hvrWJBDzsDeJoPs6">https://forms.gle/3hvrWJBDzsDeJoPs6</a>).</p><p>This week changed how I think about AI in DevOps.</p><p>At first, I assumed the goal was to build an AI that could solve incidents automatically. By the end of the week, I realized the real goal is to build an AI that helps humans make better decisions.</p><p>One of my projects was creating a Bash-based Linux incident triage script and integrating it with a Claude Code skill. To test it, I intentionally stopped the Nginx service on my lab VM and let the workflow investigate the problem.</p><p>Instead of jumping straight into a restart, the workflow gathered evidence first. It checked the service status, collected logs, inspected system resources, and presented the findings before suggesting a recovery action. Only after I approved the recommendation was the service restarted. A second triage confirmed everything had returned to a healthy state.</p><p>That sequence might sound simple, but it highlighted an important lesson. AI should never have unrestricted operational access. If an agent blindly restarted every failed service, it could hide deeper problems, interrupt planned maintenance, or make an incident even worse. Good automation is not about removing humans from the process. It is about giving humans better information to make safer decisions.</p><p>I also spent plenty of time troubleshooting my own scripts. Small mistakes in Bash, missing paths, and unexpected outputs reminded me that automation only becomes reliable after careful testing. Every error became another opportunity to understand Linux a little better.</p><p>The biggest takeaway from this week is that observability comes before action. Collect evidence. Understand the problem. Approve the fix. Verify the outcome.</p><p>That mindset applies far beyond Linux. Whether you’re working with cloud infrastructure, AI agents, or production systems, disciplined troubleshooting will always outperform guesswork.</p><p>Week 3 wasn’t just about writing scripts. It was about learning how to build automation that people can actually trust.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58c92224c017" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[POV: You are learning Claude Code for the First time.]]></title>
            <link>https://medium.com/@jacquelinastanley/pov-you-are-learning-claude-code-for-the-first-time-0c15b63ea2ac?source=rss-2168a1c046ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/0c15b63ea2ac</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[reflections]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Jacquelina Stanley]]></dc:creator>
            <pubDate>Thu, 09 Jul 2026 17:02:46 GMT</pubDate>
            <atom:updated>2026-07-17T17:49:29.308Z</atom:updated>
            <content:encoded><![CDATA[<p>**P.S. This post is part of the DevOps Micro Internship with Agentic AI Cohort 3 by Pravin Mishra (<a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">https://www.linkedin.com/in/pravin-mishra-aws-trainer/</a>). You can begin your DevOps journey by joining the DMI waiting list (<a href="https://forms.gle/3hvrWJBDzsDeJoPs6">https://forms.gle/3hvrWJBDzsDeJoPs6</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ERWC5cbme2pvGFntVlultg.png" /></figure><p>This week I’m starting to explore the world of AI agents, I recently began a course on <strong>Claude Code ;</strong>(<a href="https://www.udemy.com/course/ultimate-agentic-ai-devops-with-claude-code/">https://www.udemy.com/course/ultimate-agentic-ai-devops-with-claude-code/</a>) and several concepts that make AI assistants far more capable than a traditional chatbot, including Skills, Subagents, Hooks, Permissions, Memory, and MCP…. however sorry I’m not going to talk about any of that.</p><p>Before this week, I thought AI was mainly useful for generating code or answering questions.</p><p>After working through the assignments, I now understand that these features allow AI to become part of a real engineering workflow rather than simply acting as an assistant.</p><p>One of the biggest lessons I learned came from Claude Code. I discovered that simply asking an AI to “build something” isn’t enough.</p><p>The quality of the output depends heavily on the ;</p><ul><li>instructions</li><li>permissions</li><li>context that you provide.</li></ul><p>I also learned that AI-generated solutions still require verification. There were several occasions where I had to investigate issues myself instead of assuming the first answer was correct.</p><p>A good example was when I was completing the Terraform assignments.</p><p>Initially, I expected the scaffold commands shown in the training material to work exactly as demonstrated. I had to adapt by using natural language prompts thinking I was some genius who came up with a revolutionary workaround helping others in my community. Eventually, I discovered that some slash commands files needed to be amended to SKILL.md. That experience reminded me that understanding the “why” behind a solution is far more valuable than solving the issue.</p><p>Another area that challenged me was working with Hooks and Permissions inside Claude Code. Setting up the User Prompt Guard was relatively straightforward, but getting the PreToolUse hook to execute correctly took much longer than expected. At one point, I couldn’t even find the debug log that should have been generated. Instead of giving up, I worked through the configuration step by step until I discovered the issue and eventually got it working.</p><p>Guess what, it was working the whole time and I was the problem. I was so caught up trying to get it to work I again forgot to realise the “WHY” I am doing this</p><p>Solving that problem wasn’t incredibly satisfying because it reinforced one core value when learning. Paitence.</p><p>Perhaps the biggest mindset shift this week was realizing that AI doesn’t replace critical thinking it actually demands more of it. AI can accelerate the work, but it cannot validate assumptions, understand business context, or determine whether a generated solution is the best one. Those responsibilities still belong to the engineer.</p><p>Going forward, I want to build one habit into my learning process. Whenever I solve a problem, I will spend a few extra minutes documenting <em>why</em> the issue is occuring worked instead of only recording <em>what</em> fixed it. I believe this simple system will help me develop stronger troubleshooting and decision making skills and make it easier to solve similar problems in the future.</p><p>This week wasn’t just about learning Agentic AI tools. It taught me that becoming a DevOps engineer is less about being the first or quickest to solve issues and more about developing a systematic approach to problem-solving. That lesson will stay with me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0c15b63ea2ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Future I Wrote Before It Existed]]></title>
            <link>https://medium.com/@jacquelinastanley/the-future-i-wrote-before-it-existed-ee70083dcf58?source=rss-2168a1c046ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee70083dcf58</guid>
            <dc:creator><![CDATA[Jacquelina Stanley]]></dc:creator>
            <pubDate>Tue, 30 Jun 2026 07:31:42 GMT</pubDate>
            <atom:updated>2026-06-30T13:22:28.252Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>This is an assignment as part of DevOps Micro Internship with Agentic AI Cohort-3 by </strong><a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/"><strong>Pravin Mishra</strong></a><strong>. You can start your DevOps journey by joining this </strong><a href="https://discord.pravinmishra.com/"><strong>Discord community</strong></a><strong> ( </strong><a href="https://discord.pravinmishra.com/"><strong>https://discord.pravinmishra.com/</strong></a><strong> ).</strong></p><h3><em>“How do you see yourself in 3–7 years , what would a journalist write about you ?”</em></h3><p>When I first read the requirement for this assignment, I smiled , I whined , I dreaded it (and yet now as I’ve completed it I feel accomplished……)</p><p>Let me explain.</p><p>FIRSTLY, talking about myself? It feels strange ….even uncomfortable.</p><p>Before even posting anything on Linked-In I ask about 5 friends if this seems out of character ? I mean we are all aware of the Linked-In memes we see online and I am guilty for laughing to them. So now in this position I asked myself …..</p><p>“How could I write about a future about myself that hadn’t happened yet?”</p><p>Isn’t that just delusion? maybe even self glorifying? I mean I do believe in manifestation but it was always on a personal level with myself by myself for myself.</p><p>But to post it online for everyone to see, I can feel the blood rushing to my cheeks already. I could feel like anyone who knew me personally this was would be their reactions :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/735/0*f35eX4OML4e4O-Ld.jpg" /></figure><p>But as I started writing, I realized it wasn’t about predicting the future.</p><p>It was about defining the person I wanted to become. I think it’s fair to say everyone wants to be successful in their career, I mean you are given the greatest privilege of education, you are given the opportunity to do honest work, you have aspirations to make your family proud…. if this gets me to where I need to go…. it it so wrong ? I mean it’s honestly so innocent.</p><p>Also, I think it’s fair for me as well to feel like in this lifetime, while I am young and hopeful of this future and the world we are living in, I do want to have a career I am proud of.</p><p>Maybe I might have lost you already because you would think there is more to life then a career ….. so keep your eye rolls and click away if you don’t want to continue reading, I mean honestly …. it’s your choice I’m not forcing this upon you at all..</p><h4>Okay since you want tooooooooo….</h4><p><strong>F</strong>ive years ago, I earned my bachelor’s degree in Cloud Engineering.</p><p>I was in a technical support role and while I loved that job it was never my forever job. I wanted to be in a role which reflected what I had studied so hard for in university.</p><p>Despite graduating , finding an entry level cloud role wasn’t as straightforward as I had imagined.</p><p>The technology industry was changing faster than ever. Artificial intelligence was transforming jobs. Every application seemed to ask for experience I didn’t yet have.</p><p>Some days, I felt confident. Other days, I questioned whether I was on the right path at all.</p><p>And yes , I was very confused and conflicted … and due to human nature discomfort often leads you wanting to giving up.</p><p>But I really did not want to give up. Somewhere deep inside I felt that perhaps guidance would get me further.</p><p>so I kept being confused….. but in a good way…. because here’s my unpopular opinion</p><p>Being confused isn’t a weakness. It’s one of the most honest places you can be.</p><p>The moment you’re confused is the moment you’ve acknowledged there’s something worth understanding.</p><p>From there, you have two choices.</p><p>You can let confusion convince you to stop</p><p>or</p><p>You can let it push you to ask better questions, learn new skills, seek advice, test ideas, fail a few times, and keep moving.</p><p>Looking back, every major turning point in my life started with confusion.</p><p>I was confused about whether university was worth it.</p><p>I was confused about which field to pursue.</p><p>I was confused after graduating when the opportunities I expected didn’t immediately come.</p><p>None of those moments were comfortable.</p><p>But each one forced me to grow.</p><p>So…….. I put in the work.</p><p>I earned certifications, completed courses, bootcamps, trainings and technical programs, and began writing about what I learned.</p><p>My GitHub slowly became more than a collection of repositories it became a record of persistence.</p><p>Eventually, my career shifted from technical support into cloud engineering and later into DevOps. I contributed to production systems, automated infrastructure deployments, built CI/CD pipelines, improved monitoring and observability, and worked alongside developers and security engineers to deliver reliable cloud platforms.</p><p>That reminded me of something important.</p><p>Knowledge grows when it is shared.</p><p>Those projects mattered.</p><p>But they weren’t what defined my career.</p><p>The habits did.</p><p>Showing up consistently.</p><p>Building when nobody was asking me to.</p><p>Publishing work before it felt perfect.</p><p>Learning from rejection instead of being discouraged by it.</p><p>Helping others while I was still learning myself.</p><p>Those ordinary decisions, repeated hundreds of times, became the foundation of everything that followed.</p><p>When people looked at my career from the outside, they often noticed the promotions, certifications, projects, or job titles.</p><p>They rarely saw the evenings spent debugging deployment failures.</p><p>The applications that received no response.</p><p>The weekends dedicated to learning technologies that felt overwhelming.</p><p>The moments when progress was invisible.</p><p>Success rarely arrived as one life-changing opportunity.</p><p>It arrived quietly, disguised as another day of choosing not to quit.</p><p>( However , dear self if for whatever reason it was better to take a step back because life was unpredictable and when you make a plan god laughs , then it’s all okay )</p><p>Writing this article from the perspective of my future self changed the way I think about goals.</p><p>The exercise wasn’t about pretending the future was guaranteed.</p><p>It was about asking a better question.</p><p><strong>If this were the story someone wrote about me five years from now, what decisions would I need to make today for it to become true?</strong></p><p>Maybe that’s what vision really is.</p><p>Not predicting the future.</p><p>But creating a direction that gives today’s effort a purpose.</p><p>Perhaps success isn’t built on hard work alone.</p><p>Hard work matters.</p><p>But so do clarity, resilience, belief, and the courage to keep moving before the results are visible.</p><p>Five years from now, I hope someone reads my story and thinks it was inevitable.</p><p>I’ll know it wasn’t.</p><p>It was built one project, one lesson, one setback, and one ordinary day at a time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee70083dcf58" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Key Management Service on AWS]]></title>
            <link>https://medium.com/@jacquelinastanley/understanding-key-management-service-on-aws-0e0b9a0203b2?source=rss-2168a1c046ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/0e0b9a0203b2</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devsecops]]></category>
            <category><![CDATA[km]]></category>
            <dc:creator><![CDATA[Jacquelina Stanley]]></dc:creator>
            <pubDate>Thu, 07 May 2026 03:41:04 GMT</pubDate>
            <atom:updated>2026-05-07T03:41:04.238Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YGL1F_616-SZow_3.png" /></figure><h4>Task 1: Create a Customer Managed Key</h4><p>Customer Managed Keys give you full control over encryption, including key policies and rotation schedules.</p><p>Step 1: Search for KMS in the AWS Console and open the Key Management Service.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aQ9exJrVECTywzl6wwvZ4Q.png" /></figure><p>Step 2: Click Create key and configure:</p><ul><li>Key type: Symmetric (Default).</li><li>Key usage: Encrypt and decrypt (Default).</li><li>Click Next.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zNAjrJ5Jin8AcUJFCg9cSw.png" /></figure><p>Step 3: Add Labels:</p><ul><li>Alias: lab-key (This helps you identify it).</li><li>Click Next.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e7opy98qt6lggXWyufq7nA.png" /></figure><p>Step 4: Define Key Administrators:</p><ul><li>Select your current user.</li><li>Click Next.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DV94tTz1v3DYHD-BEzm03w.png" /></figure><p>Step 5: Define Key Usage Permissions:</p><ul><li>Select your current user again.</li><li>Click Next &gt; Finish.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dK1EpcBQSl8CDH8l2uNz2A.png" /></figure><p>Verify: Confirm you see lab-key with status Enabled.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PcrFU-AowM7TwWZBHAD38A.png" /></figure><h4>Task 2: Enable automatic key rotation</h4><p>Key rotation automatically updates the cryptographic material every year without changing the Key ID. This enhances security by limiting the lifetime of each key version.</p><p>Step 1: In the KMS Console, click the alias lab-key (created in the previous task) to open its details.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ioAoozp_p10042qS9m8I6Q.png" /></figure><p>Step 2: Enable Rotation:</p><ul><li>Select the Key rotation tab and Click Edit.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7IfELiT_39vv3E-y6GCKvg.png" /></figure><ul><li>Enable key rotation and Click Save.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9aoYHntmXTrPBqcQBc6qWw.png" /></figure><p>Verify: Confirm that key rotation is now enabled for lab-key.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PcrHRYppIqg6gRAFO5VfFw.png" /></figure><h4>Task 3: Use the key to encrypt an S3 bucket</h4><p>Server-side encryption with KMS keys (SSE-KMS) provides an additional layer of control over who can decrypt your data.</p><p>Step 1: Navigate to S3 and click Create bucket.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yZfCX9LZxjHNiBGnzIh8hw.png" /></figure><ul><li>Bucket Name: Create a globally unique name.</li><li>Example: test-bucket-&lt;yourname&gt;-&lt;randomnumber&gt;</li><li>Click Create bucket.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gb_rOkeMbKdDUD_zVDdOZw.png" /></figure><p>Step 2: Configure Encryption:</p><ul><li>Once created, click the bucket name to open it.</li><li>Click Properties.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p_UgusHZ_evoV7VMK168BQ.png" /></figure><ul><li>Scroll to Default encryption &gt; Edit.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qhiBFltpnTY2upJR8kWBcg.png" /></figure><p>Step 3: Set KMS Encryption:</p><ul><li>Encryption type: Select Server-side encryption with AWS Key Management Service keys (SSE-KMS).</li><li>AWS KMS key: Select Choose from your AWS KMS keys.</li><li>Select lab-key from the list.</li><li>Click Save changes.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RBwqDp5kIzE5Q7Dpum9uZA.png" /></figure><h4>What You Learned:</h4><ol><li>Customer Managed Keys (CMK) — You created a custom KMS key (lab-key) instead of using the generic AWS-managed key. This gives <em>you</em> control over who can use it</li><li>Automated Security — You enabled Key Rotation, ensuring the underlying cryptographic material is automatically updated every year without breaking your applications</li><li>Encryption at Rest — You configured an S3 Bucket to use your specific KMS key, ensuring that every object uploaded is locked down before it ever hits the disk</li></ol><h4>Why This Matters:</h4><p>In highly regulated industries (like Finance or Healthcare), “default” encryption often isn’t enough. You need to prove you control the keys, you rotate them regularly, and you strictly define which services can use them. You just built that exact workflow.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0e0b9a0203b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding IAM on AWS]]></title>
            <link>https://medium.com/@jacquelinastanley/understanding-iam-on-aws-dce9c8b98555?source=rss-2168a1c046ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/dce9c8b98555</guid>
            <category><![CDATA[iam-roles]]></category>
            <category><![CDATA[aws-iam-user]]></category>
            <category><![CDATA[aws-iam]]></category>
            <category><![CDATA[aws-iam-security]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Jacquelina Stanley]]></dc:creator>
            <pubDate>Thu, 07 May 2026 03:39:55 GMT</pubDate>
            <atom:updated>2026-05-07T03:39:55.525Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pWag2gDUwwj8z7eb3fbitA.png" /></figure><h4>Task 1: Create an IAM User with console access</h4><p>IAM Users represent individual people who need access to your AWS account. Each user gets unique credentials, eliminating the need to share passwords.</p><p>Step 1: Log in to the AWS Console and search for IAM.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xMsw7mfCKeb8CoQ1wWis6Q.png" /></figure><p>Step 2: Click Users in the left navigation pane, then click Create user.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/325/1*dVufd-nJ13ZWdWnCWX-ffw.png" /></figure><p>Step 3: Configure the User details:</p><ul><li>User name: iamuser-analyst</li><li>Provide user access to the AWS Management Console: <em>Check this box.</em></li><li>Console password: Select Custom password and type a simple one (e.g., Password123!).</li><li>Users must create a new password at next sign-in: <em>Uncheck</em> this (for simplicity).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*asDY5nuU44V3Y6KUVXGrpA.png" /></figure><p>Step 4: Click Next.</p><p>Step 5: Attach Permissions:</p><ul><li>Permissions options: Select Copy permissions.</li><li>Select your current user.</li><li>Click Next -&gt; Create user.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kSsjyavtLrhSAioSZGWj0g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2oJt7kl8FXd6h2lk0wWcsg.png" /></figure><h4>Task 2: Create an IAM Group and add users to it</h4><p>Groups allow you to manage permissions for multiple users efficiently. Instead of attaching policies to each user individually, you attach them to the group once.</p><p>Step 1: In the IAM Dashboard, click on User groups in the left menu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/316/1*BjfaR029iK7KNc_HeGEa4Q.png" /></figure><p>Step 2: Click Create group and set:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yf1vL8xpXw-lZDZyVpQdRQ.png" /></figure><ul><li>User group name: finance-team</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-fKYl6oDsgxABJag_Q8a1g.png" /></figure><p>Step 3: Add Users to the Group:</p><ul><li>In the Add users to the group section, select all existing users.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4m0yUkJQkODpEzbaSxFG9w.png" /></figure><p>Step 4: Attach Permissions Policies:</p><ul><li>In the Attach permissions policies section, search for S3.</li><li>Select AmazonS3ReadOnlyAccess. (Finance needs to see reports stored in S3 buckets).</li><li>Click Create group.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fQW7TUCX8Zu2o5WToDfqTQ.png" /></figure><h4>Task 3: Create an IAM Role for temporary, secure access</h4><p>Roles provide temporary security credentials that expire automatically. This is more secure than long-term user passwords or access keys.</p><p>Step 1: In the IAM Dashboard, click on Roles in the left menu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/304/1*rh0A2lPRI-PHeBHFt_xPHg.png" /></figure><p>Step 2: Click Create role and configure:</p><ul><li>Trusted entity type: Select AWS account.</li><li>An AWS account: Select This account.</li><li>Click Next.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Un-WibTFBTpRzyyPyR1koA.png" /></figure><p>Step 3: Add Permissions:</p><ul><li>Search for S3.</li><li>Select AmazonS3ReadOnlyAccess.</li><li>Click Next.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ERQrk2uPng-j6-CYklFyow.png" /></figure><p>Step 4: Name and Create:</p><ul><li>Role name: finance-manager</li><li>Description: (Optional) e.g., “Role for finance data access”.</li><li>Click Create role.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zUMloDKMKFRqCGOBYP6hzQ.png" /></figure><h4>What You Learned:</h4><ol><li>Granular Identity — You created a specific IAM User (iamuser-analyst) with tailored permissions, ensuring individuals only see what they need to see</li><li>Scalable Management — You utilized IAM Groups (finance-team) to manage permissions efficiently. Instead of updating 50 users one by one, you learned to manage access by job function</li><li>Temporary Security — You created an IAM Role (finance-manager), mastering the concept of temporary, secure credentials that expire automatically—the gold standard for modern cloud security</li><li>Access Control — You applied Permissions Policies to strictly limit actions, preventing accidental deletions or unauthorized changes</li></ol><h4>Why This Matters:</h4><p>In the real world, security is Job Zero. By separating Users, organizing them into Groups, and using Roles for critical access, you have built the exact security framework used by enterprise organizations to protect sensitive data and comply with auditing standards.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dce9c8b98555" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why DevOps Engineers Must Understand Two-Tier vs Three-Tier Architecture]]></title>
            <link>https://medium.com/@jacquelinastanley/why-devops-engineers-must-understand-two-tier-vs-three-tier-architecture-2d43a08a3d06?source=rss-2168a1c046ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d43a08a3d06</guid>
            <category><![CDATA[three-tier-architecture]]></category>
            <category><![CDATA[two-tier-architecture]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Jacquelina Stanley]]></dc:creator>
            <pubDate>Wed, 29 Apr 2026 11:38:13 GMT</pubDate>
            <atom:updated>2026-04-29T11:38:13.225Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*19ecCpQPGKNGKxieg_nKdA.png" /></figure><p>When DevOps engineers deploy applications to the cloud, one of the first things they need to understand is <strong>how the application is structured</strong>.</p><p>Most applications follow either a <strong>two-tier architecture</strong> or a <strong>three-tier architecture</strong>.</p><p>Knowing the difference helps DevOps engineers <strong>deploy the right infrastructure, secure the system properly, and scale applications efficiently.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mdSIl8ENWa7gwI8LA2Mc7A.png" /></figure><h3>Two-Tier Architecture</h3><p>A <strong>two-tier application</strong> has only <strong>two layers</strong>:</p><ul><li><strong>Frontend</strong> — the interface users interact with</li><li><strong>Database</strong> — where the data is stored</li></ul><p>The frontend communicates <strong>directly with the database through a </strong>network request.</p><h3>Simple Example</h3><p>Imagine your friend launches a small <strong>employee management system</strong> for a company.</p><p>Employees log in and view their details. The application connects <strong>straight to the database</strong> to retrieve the information.</p><p>The flow looks like this:</p><p>User → Application → Database</p><p>This design works well for:</p><ul><li>Small internal systems</li><li>Prototypes</li><li>Applications with few users</li></ul><p>But it becomes harder to scale and secure as the system grows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4dgU7cqcXzUsFkSt5KCiMA.png" /></figure><h3>Three-Tier Architecture</h3><p>A <strong>three-tier architecture</strong> adds another layer between the frontend and database.</p><p>The three layers are:</p><ul><li><strong>Frontend</strong> — what users see</li><li><strong>Backend</strong> — processes requests and business logic</li><li><strong>Database</strong> — stores the data</li></ul><p>The frontend <strong>does not talk directly to the database</strong>. Instead, it sends requests to the backend.</p><h3>Simple Example</h3><p>Let’s say your friend launches an <strong>online bookstore called EpicReads</strong>.</p><p>When a customer searches for a book:</p><ol><li>The website sends the request to the <strong>backend server</strong></li><li>The backend checks the database for the book</li><li>The backend sends the results back to the website</li></ol><p>The flow looks like this:</p><p>User → Website → Backend → Database</p><p>This structure is used by platforms like <strong>Amazon, Netflix, and most modern web apps</strong> because it is easier to scale and secure.</p><h3>Why DevOps Engineers Need to Know This</h3><p>DevOps engineers build the infrastructure that runs applications.</p><p>Understanding the architecture helps them decide things like:</p><ul><li><strong>How many servers are needed</strong></li><li><strong>How the network should be structured</strong></li><li><strong>How the application scales</strong></li></ul><p>For example:</p><p>A <strong>two-tier app</strong> might run on:</p><ul><li>One server for the application</li><li>One database</li></ul><p>A <strong>three-tier app</strong> might require:</p><ul><li>Load balancers</li><li>Web servers</li><li>Backend API servers</li><li>Databases</li></ul><p>If the architecture is misunderstood, the infrastructure could become <strong>slow, insecure, or unnecessarily expensive</strong>.</p><h3>The Key Takeaway</h3><p>Before deploying an application, DevOps engineers must understand <strong>how the application layers communicate</strong>.</p><p>Knowing whether a system is <strong>two-tier or three-tier</strong> helps ensure the infrastructure is:</p><ul><li>scalable</li><li>secure</li><li>efficient</li></ul><p>In Devops, <strong>good architecture decisions start with understanding the application itself</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d43a08a3d06" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build an Auto-Deploy EC2 Dashboard Inside Your Own VPC]]></title>
            <link>https://medium.com/@jacquelinastanley/build-an-auto-deploy-ec2-dashboard-inside-your-own-vpc-08c179dbe221?source=rss-2168a1c046ce------2</link>
            <guid isPermaLink="false">https://medium.com/p/08c179dbe221</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[ec2]]></category>
            <category><![CDATA[vpc]]></category>
            <category><![CDATA[beginners-guide]]></category>
            <dc:creator><![CDATA[Jacquelina Stanley]]></dc:creator>
            <pubDate>Wed, 29 Apr 2026 05:35:34 GMT</pubDate>
            <atom:updated>2026-04-29T05:35:34.782Z</atom:updated>
            <content:encoded><![CDATA[<p>Create a custom VPC, drop an EC2 instance into it, and watch a live metadata dashboard — showing your VPC ID, subnet, CIDR blocks, and more.</p><h4>What you’ll build</h4><p>A custom VPC with a public subnet, an EC2 instance that installs Apache and fetches its own metadata including VPC ID, Subnet ID, and CIDR blocks and serves it all as a styled dashboard at its public IP address.</p><p>Most AWS beginner projects skip networking entirely , they use the default VPC and hope nobody notices. This project does it properly. You’ll create your own VPC, route it to the internet, place an EC2 instance inside it, and watch that instance report back exactly where it lives in the AWS network fabric.</p><p>The mechanism is <strong>EC2 User Data</strong>: a bash script you attach at launch that runs automatically on first boot. No SSH. No manual config. By the time the status checks turn green, your instance has already installed Apache, queried the metadata service, and written a custom HTML page.</p><h3>What You’ll Learn</h3><ul><li><strong>VPCs : </strong>creating an isolated virtual network with a CIDR block</li><li><strong>Public subnets + Internet Gateways : </strong>making your subnet reachable from the internet</li><li><strong>Security Groups : </strong>allowing HTTP traffic on port 80</li><li><strong>EC2 User Data</strong> : scripts that auto-run on first launch</li></ul><h3>Architecture Overview</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F9H6D1oYRCqgv3TFw9rVuQ.png" /></figure><h3>Step-by-Step Guide</h3><h4>Step 1 : Fork the GitHub repo</h4><p>Everything you need is in the GitHub repository:</p><p>👉 <a href="https://github.com/jacquelinastanley/sj-traffic-watch-project-s3bucket">Github Repo</a></p><p>Click <strong>Fork</strong> in the top right corner to copy it to your own account.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vA92lNfT7P7WDQUz4I7TZQ.png" /></figure><h4>Step 2 :Create the VPC</h4><p>Navigate to <strong>VPC Console → Your VPCs → Create VPC</strong> and choose <strong>“VPC and more”</strong>. This wizard creates the VPC, subnet, internet gateway, and route table in one go.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XcfhChDZ6XapfDZPG_aPTQ.png" /></figure><p># Settings in the “VPC and more” wizard:<br>Name tag auto-generation : my-dashboard-vpc<br>IPv4 CIDR block : 10.0.0.0/16<br>Number of AZs : 2<br>Public subnets : 2<br>Private subnets : 0<br>NAT gateways : None<br>VPC endpoints : None</p><p>After creation you’ll have a VPC, a public subnet (e.g. 10.0.1.0/24), an Internet Gateway, and a route table pointing 0.0.0.0/0 at the gateway.</p><blockquote>Important : Go to your new subnet → Actions → <strong>Edit subnet settings</strong> → enable <strong>“Auto-assign public IPv4 address”</strong>. Skip this and your EC2 instance won’t get a public IP — the dashboard will be unreachable.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cNuNMB7icvPvdHKvYl1R_w.png" /></figure><h4>Step 3: Create the Security Group</h4><p>Go to <strong>EC2 → Security Groups → Create security group</strong>. Attach it to your new VPC and add one inbound rule:</p><p># Security group inbound rules<br>Type: HTTP Port: 80 Source: 0.0.0.0/0 # dashboard access<br>Type: SSH Port: 22 Source: My IP # optional debugging</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4ovEEpWp39eOHHh0lvRmxg.png" /></figure><h4>Step 4 : Create the Security Group</h4><p>Launch the EC2 instance into your VPC<br>Go to EC2 → Launch Instances and fill in:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BxU780hn6lJZis88NAuqlQ.png" /></figure><p># Instance configuration<br>Name : my-info-dashboard<br>AMI : Amazon Linux 2 (free tier eligible)<br>Instance type : t3.micro (free tier eligible)</p><p># Network settings — this is where VPC comes in<br>VPC : my-dashboard-vpc # ← your VPC<br>Subnet : my-dashboard-vpc-subnet-public1-us-east-1a<br>Auto-assign public IP : Enable<br>Security group : ( the security group you created )</p><p># Advanced Details → User Data<br>→ Paste the full contents of scripts/user-data.sh<br>Hit Launch Instance.</p><h4>Step 5:Visit the dashboard</h4><p>Wait ~2 minutes for status checks to pass and the User Data script to finish. Then copy the <strong>Public IPv4 address</strong> and open:</p><pre>http://&lt;your-public-ip&gt;</pre><p>You’ll see the dashboard — and the VPC section will show exactly which VPC and subnet your instance is running in, with the CIDR blocks it was assigned.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3kzBjOrSWiuOy7ItliozEg.png" /></figure><h4>Cleanup</h4><p>Clean up in this order to avoid dependency errors:</p><p># 1. Terminate the EC2 instance<br>EC2 Console → Instances → Select → Instance State → Terminate</p><p># 2. Delete the Security Group (once instance is gone)<br>EC2 Console → Security Groups → WebDashboardSG → Delete</p><p># 3. Delete the VPC (deletes subnet, IGW, route table too)<br>VPC Console → Your VPCs → my-dashboard-vpc → Actions → Delete VPC<br>Delete EC2 before the VPC. AWS will refuse to delete a VPC that has running instances attached to it.</p><h4>Wrapping Up</h4><p>In about 15 minutes you’ve gone from nothing to a real cloud web server — with its own isolated network, proper internet routing, and a firewall — that bootstraps and deploys itself. The VPC section of the dashboard proves you understand more than just “launch an instance”: you understand the network it lives in.</p><p>Fork the repo, build it, and drop a screenshot in the comments. Bonus points if you show dashboards from two different AZs side by side.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=08c179dbe221" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>