<?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 Oluwabunmi Olowoyeye on Medium]]></title>
        <description><![CDATA[Stories by Oluwabunmi Olowoyeye on Medium]]></description>
        <link>https://medium.com/@bunmiolowoyeye20?source=rss-a596a81bcbb8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Oluwabunmi Olowoyeye on Medium</title>
            <link>https://medium.com/@bunmiolowoyeye20?source=rss-a596a81bcbb8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 18:29:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@bunmiolowoyeye20/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[Connecting Jira to Claude Code with MCP: Building a Read-Only Sprint Health Skill]]></title>
            <link>https://medium.com/@bunmiolowoyeye20/connecting-jira-to-claude-code-with-mcp-building-a-read-only-sprint-health-skill-cbf4f8d48edc?source=rss-a596a81bcbb8------2</link>
            <guid isPermaLink="false">https://medium.com/p/cbf4f8d48edc</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[mcps]]></category>
            <category><![CDATA[jira-agile]]></category>
            <category><![CDATA[claude]]></category>
            <dc:creator><![CDATA[Oluwabunmi Olowoyeye]]></dc:creator>
            <pubDate>Sat, 22 Aug 2026 16:30:18 GMT</pubDate>
            <atom:updated>2026-08-22T16:30:18.334Z</atom:updated>
            <content:encoded><![CDATA[<p>As part of my DevOps learning journey, I worked on a project that brought together <strong>Jira, Model Context Protocol (MCP), and Claude Code</strong> to create a practical AI-assisted sprint management workflow.</p><p>The goal was not simply to connect an AI assistant to Jira, but to build a solution that could retrieve <strong>real-time sprint information</strong>, analyze the team’s sprint health, and provide useful insights while ensuring that the AI could not make unauthorized changes to the Jira board.</p><h4>Project Overview</h4><p>The project focused on connecting a Jira MCP server to Claude Code and creating a custom /sprint-health skill.</p><p>The skill was designed to analyze an active sprint and provide information such as:</p><ul><li>Sprint velocity</li><li>At-risk stories</li><li>Issues missing estimates</li><li>Current issue status</li><li>Other useful sprint-health indicators</li></ul><p>A key requirement was that the skill should be <strong>strictly read-only</strong>. It could gather and analyze Jira data but should never create, update, transition, or comment on Jira issues.</p><p>This provided an excellent opportunity to explore not only AI integration but also the importance of <strong>security, permissions, and human oversight</strong> when using AI with project-management tools.</p><h4>Connecting Jira Through MCP</h4><p>The first step was configuring the Jira MCP server.</p><p>MCP provides a standardized way for AI applications such as Claude Code to communicate with external tools and data sources. Instead of building a custom integration for every tool, an MCP-compatible server exposes capabilities that Claude can use through the standard MCP protocol.</p><p>For the Jira connection, three important credentials were required:</p><ul><li><strong>Jira site URL</strong> — identifies the Jira instance.</li><li><strong>Account email</strong> — identifies the Jira account.</li><li><strong>API token</strong> — authenticates the account.</li></ul><p>The API token was stored securely in the local Claude Code settings rather than inside the shared MCP configuration.</p><p>This separation is important because configuration files can be committed to source control, while credentials should remain private.</p><h4>.mcp.json Configuration</h4><p>I configured the Jira MCP server in the project’s .mcp.json file.</p><p>One interesting part of the exercise was comparing the Jira configuration with the GitHub MCP configuration from an earlier project.</p><p>The GitHub MCP server used npx, while the Jira MCP server used uvx. Although these tools run packages from different programming ecosystems, Claude Code does not need to know whether the underlying MCP server was written in Python, JavaScript, or another language.</p><p>What matters is that the server follows the <strong>Model Context Protocol</strong> and can communicate with Claude Code through the expected MCP interface.</p><p>This demonstrated one of the major benefits of MCP: <strong>standardized communication between AI applications and external tools.</strong></p><h4>Keeping Credentials Secure</h4><p>Security was an important part of the implementation.</p><p>The Jira API token was stored in:</p><p>settings.local.json</p><p>and the file was added to .gitignore.</p><p>The MCP configuration contains information about how the server should be launched, while sensitive credentials are supplied through environment variables at runtime.</p><p>This prevents secrets from being accidentally committed to GitHub or shared with other developers.</p><p>It also reinforces an important DevOps principle:</p><blockquote><strong><em>Configuration can be shared; secrets should not be.</em></strong></blockquote><h4>Verifying the MCP Connection</h4><p>After configuring the Jira MCP server, I restarted Claude Code and used the /mcp command to verify the connection.</p><p>The Jira server appeared as:</p><p><strong>jira: connected</strong></p><p>This confirmed that Claude Code could successfully communicate with the Jira MCP server.</p><p>However, simply seeing a successful connection was not enough. I also needed to verify that the integration could retrieve <strong>real Jira data</strong>.</p><h4>Retrieving Live Sprint Data</h4><p>I asked Claude Code to retrieve the issues from the active sprint.</p><p>To confirm that the information was not being generated or guessed, I compared the response with the live Jira board in the browser.</p><p>I checked details such as:</p><ul><li>Issue keys</li><li>Issue summaries</li><li>Statuses</li><li>Estimates</li><li>Sprint information</li></ul><p>The information returned by Claude matched the information displayed on the Jira board.</p><p>This provided practical proof that Claude was retrieving live data through the Jira MCP connection.</p><h4>Building the /sprint-health Skill</h4><p>The most interesting part of the project was creating the /sprint-health skill.</p><p>The skill was designed to act like a sprint-health assistant for a Scrum Master.</p><p>It analyzes the current sprint and produces a triage report covering areas such as:</p><h4>Sprint Velocity</h4><p>The skill examines sprint data to provide insight into the team’s completed work and overall delivery performance.</p><h4>At-Risk Stories</h4><p>It identifies items that may require attention based on their status or sprint conditions.</p><h4>Missing Estimates</h4><p>It highlights issues without estimates, helping the team identify gaps that could affect sprint planning and reporting.</p><p>The resulting report provides a quick way to understand the current health of the sprint without manually reviewing every Jira ticket.</p><h4>Why the Skill Is Read-Only</h4><p>One of the most important design decisions was restricting the skill to <strong>read-only Jira tools</strong>.</p><p>The skill was intentionally prevented from accessing tools that could:</p><ul><li>Create issues</li><li>Update issues</li><li>Transition issues</li><li>Add comments</li></ul><p>It also did not have access to the Write tool.</p><p>This creates a clear separation between <strong>analysis and action</strong>.</p><p>Claude can gather information and identify potential problems, but it cannot independently change the team’s Jira board.</p><p>For a Scrum Master, this restriction is particularly important because sprint data represents decisions and commitments made by the team.</p><p>Changing an issue’s status, estimate, priority, or comment can affect reporting and team communication. Those actions should remain under human control.</p><h4>Testing the Human-in-the-Loop Workflow</h4><p>I also tested the skill to make sure it was genuinely reading live Jira data.</p><p>The workflow followed the:</p><p><strong>Gather → Analyze → Human Act → Verify</strong></p><p>model.</p><h4>1. Gather</h4><p>The /sprint-health skill gathered current sprint information through the Jira MCP connection.</p><h4>2. Analyze</h4><p>Claude analyzed the information and produced the sprint-health report.</p><h4>3. Human Act</h4><p>I manually changed a ticket on the Jira board through the browser.</p><h4>4. Verify</h4><p>I ran /sprint-health again and confirmed that the updated report reflected the change.</p><p>This was an important validation because it demonstrated that the skill was not relying on previously generated information. It was reading the current state of the Jira board each time.</p><h4>Key Lessons Learned</h4><p>This project provided several important lessons beyond simply configuring an MCP server.</p><h4>1. AI Integrations Need Proper Access Control</h4><p>Connecting AI to external systems is powerful, but access should be limited to what the AI actually needs.</p><p>A read-only skill is safer than giving an AI assistant unrestricted access to a project-management platform.</p><h4>2. MCP Simplifies Tool Integration</h4><p>MCP provides a standardized approach for connecting AI applications to external tools. The underlying implementation language does not need to be exposed to the AI client as long as the server communicates through MCP.</p><h4>3. Secrets Must Be Separated from Configuration</h4><p>API tokens and other credentials should never be hardcoded into shared configuration files or committed to source control.</p><p>Using environment variables and local settings provides a safer approach.</p><h4>4. Human Oversight Still Matters</h4><p>AI can gather information, analyze patterns, and provide recommendations, but important project decisions should remain with the appropriate human stakeholders.</p><p>The <strong>Human Act</strong> step is especially important when changes could affect project commitments or team reporting.</p><h4>Conclusion</h4><p>This project gave me practical experience connecting <strong>Jira with Claude Code through MCP</strong> and using that integration to build an AI-assisted sprint-health workflow.</p><p>More importantly, it demonstrated how AI automation can be designed responsibly.</p><p>The final workflow allows Claude to access real Jira data, analyze sprint health, and provide useful insights while deliberately preventing it from modifying the board.</p><p>For me, the biggest takeaway is that effective AI automation is not about giving AI unlimited access. It is about giving AI <strong>the right access, for the right purpose, with the right controls</strong>.</p><p>This project strengthened my understanding of <strong>MCP, Claude Code, Jira integration, access control, DevOps automation, and human-in-the-loop AI workflows</strong> — and it is another valuable step in my journey toward building practical and responsible AI-powered DevOps solutions.</p><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/bummieboaxyl.html">https://dmi.pravinmishra.com/s/bummieboaxyl.html</a> · 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=cbf4f8d48edc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Safe Linux Incident Triage Workflow with Bash and AI]]></title>
            <link>https://medium.com/@bunmiolowoyeye20/building-a-safe-linux-incident-triage-workflow-with-bash-and-ai-903029e8a807?source=rss-a596a81bcbb8------2</link>
            <guid isPermaLink="false">https://medium.com/p/903029e8a807</guid>
            <dc:creator><![CDATA[Oluwabunmi Olowoyeye]]></dc:creator>
            <pubDate>Wed, 29 Jul 2026 09:30:53 GMT</pubDate>
            <atom:updated>2026-08-01T12:29:13.950Z</atom:updated>
            <content:encoded><![CDATA[<p>As DevOps engineers, one of our key responsibilities is responding to incidents quickly and safely. While automation can help us gather information faster, it’s equally important to ensure that recovery actions are controlled and evidence-driven.</p><p>In a recent hands-on lab, I built a <strong>Linux Incident Triage Workflow</strong> that combines <strong>Bash scripting</strong> and <strong>AI-assisted analysis</strong> to diagnose and recover from service failures while maintaining strict operational guardrails.</p><h4>The Goal</h4><p>The objective was to create a workflow that follows a simple but effective incident response process:</p><ol><li><strong>Gather Evidence</strong></li><li><strong>Analyze the Evidence</strong></li><li><strong>Approve and Execute Recovery</strong></li><li><strong>Verify the Recovery</strong></li></ol><p>Rather than allowing AI to make system changes automatically, the workflow ensures that human approval remains part of every recovery action.</p><h4>Building the Health-Check Script</h4><p>The first step was creating a Bash script that performs read-only health checks against an Ubuntu server running Nginx.</p><p>The script validates five key indicators:</p><ul><li>Nginx service status</li><li>Port 80 listening state</li><li>Local HTTP response</li><li>Root disk utilization</li><li>Available memory</li></ul><p>To make the script modular and maintainable, each health check was implemented as a separate function and stored in an array that could be executed sequentially.</p><p>The script generates a structured report containing:</p><ul><li>PASS, WARN, and FAIL results</li><li>Recent Nginx service logs</li><li>Overall health status</li><li>Exit codes for automation</li></ul><p>Example statuses:</p><ul><li><strong>HEALTHY (Exit Code 0)</strong> — No issues detected</li><li><strong>WARN (Exit Code 1)</strong> — Attention required but service is operational</li><li><strong>FAIL (Exit Code 2)</strong> — Critical issue requiring intervention</li></ul><h4>Establishing a Baseline</h4><p>Before simulating any incident, I captured a healthy baseline.</p><p>The report showed:</p><ul><li>Nginx service active</li><li>Port 80 listening</li><li>HTTP response returning status 200</li><li>Available memory within normal limits</li></ul><p>The only warning observed was elevated disk utilization at 88%, resulting in an overall status of <strong>WARN</strong>.</p><p>Capturing a baseline is important because it provides a reference point for comparison when troubleshooting future incidents.</p><h4>Introducing AI with Operational Guardrails</h4><p>To assist with analysis, I created a CLAUDE.md file that defined strict operational rules.</p><p>Some of the key rules included:</p><ul><li>Never restart services automatically</li><li>Never install or remove packages</li><li>Never modify Nginx configurations</li><li>Never delete files</li><li>Use only collected evidence as the source of truth</li><li>Recommend recovery actions but never execute them</li><li>Do not claim a root cause without supporting evidence</li></ul><p>These rules ensure that AI operates within clearly defined boundaries and does not perform risky actions.</p><h4>Creating the Linux Triage Skill</h4><p>Next, I created a custom Claude skill called <strong>linux-triage</strong>.</p><p>The skill was designed to:</p><ol><li>Read the project rules</li><li>Run the health-check script</li><li>Read the generated report</li><li>Analyze the results</li><li>Recommend a safe recovery command</li><li>Request human approval before any action is taken</li></ol><p>The skill only had access to:</p><ul><li>Bash</li><li>Read</li><li>Grep</li></ul><p>Notably, it did not have permission to write files or make system modifications.</p><h4>Simulating an Incident</h4><p>To test the workflow, I simulated an outage by stopping the Nginx service.</p><p>After running the health-check script again, the report immediately identified multiple failures:</p><pre>[FAIL] Nginx service is not active<br>[FAIL] Port 80 is not listening<br>[FAIL] Local HTTP check returned status 000</pre><p>The service logs further confirmed the issue:</p><pre>Stopped nginx.service<br>nginx.service: Deactivated successfully</pre><p>The report correctly returned:</p><pre>Overall Status: FAIL<br>Exit Code: 2</pre><h4>AI Analysis</h4><p>Using only the evidence contained in the report, Claude analyzed the incident and identified the most likely cause:</p><blockquote><em>Nginx had been stopped, causing the service to become unavailable.</em></blockquote><p>The AI then recommended a recovery command for review but did not execute it.</p><p>This distinction is critical.</p><p>The system remained compliant with the project’s safety rules because recovery actions required explicit human approval.</p><h4>Manual Recovery</h4><p>After reviewing the recommendation, I manually started the Nginx service.</p><p>This represented the <strong>Recover</strong> phase of the workflow.</p><p>Because the action was performed by a human rather than automatically by the AI, operational control remained intact.</p><h4>Verification</h4><p>Recovery is never complete without verification.</p><p>I reran the health-check script and confirmed:</p><ul><li>Nginx service active</li><li>Port 80 listening</li><li>HTTP status 200 returned successfully</li></ul><p>The service had recovered and was once again serving traffic.</p><p>This final verification step closed the incident and completed the workflow.</p><h4>Mapping the Agentic Loop</h4><p>This exercise demonstrated a practical implementation of an Agentic AI workflow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/903/1*4AnMJPO0pA2lOi3BWowcPA.png" /></figure><p>The key takeaway is that AI was not acting independently. Instead, it functioned as an intelligent analyst working alongside automation and human oversight.</p><h4>Key Lessons Learned</h4><p>Throughout this lab, I gained valuable experience in:</p><ul><li>Building modular Bash automation scripts</li><li>Using functions, arrays, loops, and conditionals effectively</li><li>Designing structured health-check reporting</li><li>Creating safe operational guardrails for AI systems</li><li>Implementing an evidence-driven incident response process</li><li>Understanding the importance of human approval in recovery workflows</li><li>Applying the Agentic Loop to real-world troubleshooting scenarios</li></ul><h4>Final Thoughts</h4><p>AI can significantly improve operational efficiency, but effective incident response requires more than intelligent suggestions. It requires evidence, safety controls, and human judgment.</p><p>This project showed how Bash and AI can work together to create a reliable incident triage workflow: Bash gathers the facts, AI analyzes the evidence, and humans remain in control of critical decisions.</p><p>That balance between automation, intelligence, and accountability is what makes modern DevOps practices both powerful and safe. 🚀</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*jer-2A0aFiCc842P8fU1uA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B_dyjJzslVv-dUA0OYe7Ig.jpeg" /></figure><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/Bummieboaxyl.html">https://dmi.pravinmishra.com/s/Bummieboaxyl.html</a> . 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><p><strong>#DMIByPravinMishra</strong> <strong>#DevOps #Linux #Bash #Automation #AI #AgenticAI #Nginx #SRE #CloudEngineering #LearningInPublic</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=903029e8a807" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Git Basics to AI-Assisted Code Reviews: My Week 4 Journey]]></title>
            <link>https://medium.com/@bunmiolowoyeye20/from-git-basics-to-ai-assisted-code-reviews-my-week-4-journey-110158370f6c?source=rss-a596a81bcbb8------2</link>
            <guid isPermaLink="false">https://medium.com/p/110158370f6c</guid>
            <category><![CDATA[github]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Oluwabunmi Olowoyeye]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 21:37:12 GMT</pubDate>
            <atom:updated>2026-08-01T12:26:30.439Z</atom:updated>
            <content:encoded><![CDATA[<p>Every software engineer uses Git, but this week taught me that there’s a big difference between <strong>knowing Git commands</strong> and <strong>understanding the workflows that keep teams productive</strong>.</p><p>As part of my <strong>DevOps Micro Internship (DMI) Cohort 3</strong>, Week 4 focused entirely on Git and GitHub. What started with configuring Git ended with building an AI-assisted Pull Request review workflow. Looking back, it’s amazing how each task built naturally on the previous one.</p><h4>Starting with the fundamentals</h4><p>The first task was simple, verify my Git setup and create my first repository for the week.</p><p>Although it felt straightforward, it reminded me that every successful project begins with a properly configured environment. Getting these fundamentals right eliminates many of the issues teams face later in development.</p><p>From there, I explored Git’s staging area, learning why staging exists and how it gives developers control over exactly what gets committed.</p><p>That distinction between <strong>modified files</strong>, <strong>staged changes</strong>, and <strong>committed history</strong> became much clearer after working through real examples.</p><h4>Version control meets deployment</h4><p>One of my favorite challenge was deploying my project to an Ubuntu EC2 server using Nginx.</p><p>This connected two concepts that are often learned separately:</p><ul><li>Git manages source code.</li><li>Deployment makes that code available to users.</li></ul><p>Seeing my application move from my local machine to a running web server reinforced how version control fits into the bigger DevOps picture.</p><h4>Learning how teams really collaborate</h4><p>The middle of the week focused on collaboration.</p><p>I practiced working with feature branches, creating Pull Requests, and syncing forks with upstream repositories.</p><p>These are workflows I’ve seen discussed countless times, but implementing them myself gave me a much better appreciation for why teams rely on them.</p><p>Instead of everyone working directly on the main branch, changes remain isolated until they’re reviewed and ready.</p><p>It’s a simple idea, but one that dramatically improves collaboration.</p><h4>Building a professional GitHub presence</h4><p>Beyond writing code, I also spent time improving my GitHub presence.</p><p>I updated my profile to better showcase my projects, contributions, and technical interests. A well-maintained GitHub profile serves as a portfolio, helping recruiters and fellow engineers understand both your technical skills and your approach to software development.</p><h4>Combining Git with AI</h4><p>The highlight of my week was definitely building an <strong>AI-assisted Git safety workflow</strong>.</p><p>I implemented:</p><ul><li>A Git <strong>pre-commit hook</strong> to automatically detect potential secrets and oversized files before commits are created.</li><li>A <strong>Claude Code </strong><strong>/pr-ready skill</strong> that reviews staged changes and drafts Pull Request descriptions while intentionally avoiding any repository modifications.</li></ul><p>Testing the workflow with a fake AWS access key was a practical reminder that automation should prevent mistakes before they reach production.</p><p>That combination made one thing very clear:</p><p><strong>Automation enforces standards. AI improves judgment. Together, they create a safer and more efficient development workflow.</strong></p><h4>Lessons I’ll carry forward</h4><p>This week wasn’t just about learning Git commands.</p><p>It was about understanding how modern engineering teams collaborate, review code, protect repositories, and maintain quality throughout the development lifecycle.</p><p>Some of my biggest takeaways were:</p><ul><li>Version control is about collaboration, not just backups.</li><li>Small, focused commits and feature branches make development much easier to manage.</li><li>Pull Requests are opportunities for discussion and improvement — not just approvals.</li><li>Git hooks provide consistent guardrails, while AI offers thoughtful feedback that fixed rules can’t always provide.</li><li>Human judgment remains essential, even when AI is part of the workflow.</li></ul><h4>Final thoughts</h4><p>Week 4 gave me much more confidence using Git and GitHub beyond personal projects.</p><p>I’m no longer just learning commands, I’m learning the engineering practices that support collaboration, code quality, and secure software delivery.</p><p>I’m excited to see how these skills continue to build as I progress through the DevOps Micro Internship.</p><p><strong>What Git or GitHub feature has had the biggest impact on your development workflow? I’d love to hear your experience.</strong></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/Bummieboaxyl.html">https://dmi.pravinmishra.com/s/Bummieboaxyl.html</a> . 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><p>#DMIbyPravinMishra #DevOps #Git #GitHub #CloudEngineering #SoftwareEngineering #OpenSource #AgenticAI #ContinuousLearning #TechJourney #DMI</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4djEpjHXf0UkhZvaGAck4g.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=110158370f6c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Week 2 Reflection: DevOps Micro Internship]]></title>
            <link>https://medium.com/@bunmiolowoyeye20/week-2-reflection-devops-micro-internship-7c934f68846a?source=rss-a596a81bcbb8------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c934f68846a</guid>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[anthropic-ai]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Oluwabunmi Olowoyeye]]></dc:creator>
            <pubDate>Sat, 11 Jul 2026 00:08:57 GMT</pubDate>
            <atom:updated>2026-08-01T12:30:59.234Z</atom:updated>
            <content:encoded><![CDATA[<p>Week 2 pushed me past the “getting familiar” phase and into actually building things and breaking them, and fixing them. Here’s what stood out.</p><h4>Turning Repetition Into Something Reusable</h4><p>The biggest unlock this week was realizing that repetitive, detailed prompts don’t have to be retyped every time. By packaging them into skills, I can turn a long, carefully-worded instruction into a simple slash command I call whenever I need it.</p><p>This changed how I think about working with AI agents day to day. Instead of re-explaining context or re-writing the same instructions across sessions, I can build the instruction once, save it as a reusable command, and just invoke it going forward. It’s a small shift, but it’s the difference between working <em>with</em> the tool repetitively and working <em>through</em> a system I’ve actually designed.</p><h4>Learning by Doing, Not Watching</h4><p>I noticed something clearly about myself this week, watching a tutorial or reading documentation only gets me so far. The concepts don’t really land until I’m the one typing the command, hitting the error, and figuring out why it happened.</p><p>This isn’t a new realization exactly, but this week made it undeniable. Every time I tried to shortcut by just reading through something quickly, I retained less than when I sat down and actually ran it myself, even if I fumbled through it.</p><h4>Catching Myself Moving Too Fast</h4><p>Here’s the honest part. More than once this week, I caught myself skimming instructions instead of reading them properly. Moving fast because I wanted to get to the “doing” part. And more than once, that same impulse cost me time, because I’d end up stuck on something that was actually already explained, just a few lines up.</p><p>It’s a pattern worth naming clearly: eagerness to move fast quietly working against me.</p><p>Directly off the back of that, one thing I want to carry into Week 3 is simple, read the full instructions before touching the keyboard. Not skimming, not jumping to the first command that looks familiar. Actually reading it end to end first. I know this will save me time, not cost me time. Every minute spent understanding the full picture upfront is a minute I don’t spend later stuck, backtracking, or re-reading the same doc after already getting stuck.</p><h4>Where Automation Meets Control</h4><p>This week also made something click about what DevOps actually asks of an engineer. It’s not just about automating things, anyone can automate a task. The harder, more important skill is knowing where automation needs guardrails.</p><p>Working with an AI agent that can execute commands made this real in a very concrete way: automation without control is a risk, and control without automation is just manual work with extra steps. Good DevOps and increasingly, good agentic workflows, sit right at the intersection of both: let the agent move fast, but make sure there are boundaries around what it’s allowed to touch.</p><h4>A Small Win Worth Naming</h4><p>If I had to pick one moment I’m proud of this week, it’s this: I hit a failure, and instead of guessing or restarting from scratch, I sat with the actual output, read it carefully, and traced it back to the real cause.</p><p>The clearest example was a dependency my hook relied on (jq) showed as installed in one terminal but not another. It turned out to be a PATH issue tied to how the install tool registered it on Windows. Nothing about it was complicated once diagnosed, but it was a good reminder that &quot;it&#39;s not working&quot; often has a boring, specific, and fixable reason underneath it. You just have to be willing to actually look.</p><p>It sounds small, but it didn’t feel small in the moment. It felt like the first real evidence that I’m starting to think like an engineer, not just running commands and hoping, but actually diagnosing what went wrong and why.</p><p>One thing that genuinely surprised me this week was testing Claude Code’s persistent memory. I gave it a set of project-specific details to remember, closed the session completely, reopened a fresh one, and asked it to recall what I’d shared. It came back accurate, without me repeating anything.</p><p>Two weeks in, and the biggest lessons haven’t been about tools, they’ve been about how I approach problems. Onward to Week 3.</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/Bummieboaxyl.html">https://dmi.pravinmishra.com/s/Bummieboaxyl.html</a> 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><p>#DMIByPravinMishra #AgenticAI #ClaudeCode #DevOps #LearningInPublic</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c934f68846a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From support queue to production pipeline: how Oluwabunmi engineered her way into the cloud]]></title>
            <link>https://medium.com/@bunmiolowoyeye20/from-support-queue-to-production-pipeline-how-oluwabunmi-engineered-her-way-into-the-cloud-3726bf46a342?source=rss-a596a81bcbb8------2</link>
            <guid isPermaLink="false">https://medium.com/p/3726bf46a342</guid>
            <dc:creator><![CDATA[Oluwabunmi Olowoyeye]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 14:01:03 GMT</pubDate>
            <atom:updated>2026-06-29T14:01:03.925Z</atom:updated>
            <content:encoded><![CDATA[<p><em>She started by resolving tickets for Microsoft Azure customers. A few years later, she was the one shipping infrastructure that thousands of workloads depended on — with monitors, runbooks, and published write-ups to prove every step.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/686/1*ohSFnDoARfhbKS8FdW0QBA.png" /></figure><p>Oluwabunmi Olowoyeye did not wait for permission. When she was still working as a technical support engineer, troubleshooting IaaS issues for Microsoft customers and digging into Azure IaaS at odd hours, she had already started building. Not just reading documentation, not just watching tutorials, building, committing, and shipping.</p><p>By the time she transitioned fully into a DevOps engineering role, she had already proven the point most hiring managers want candidates to make she had done the work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/691/1*55ljtQk0c0u3w01aNhNf3w.png" /></figure><blockquote><em>“She didn’t just tell us what went wrong, she showed up to the next sprint with a working fix, a write-up, and an offer to walk the team through it.”</em></blockquote><blockquote>— Engineering lead, a fintech platform in Amsterdam</blockquote><p>That instinct, to document, to share, to make the path reusable became a throughline in Bunmi’s career. She published eighteen technical articles across Medium and dev.to covering Kubernetes disk management with KubeVirt, Git branch workflows for multi-environment deployments, and Azure infrastructure automation. Several were picked up by community newsletters. One became a pinned reference in a Microsoft Tech Community forum thread.</p><p>Her GitHub profile told the same story. Clean commit histories, descriptive READMEs, reproducible environment setups. Not a portfolio assembled for a job application, it’s an actual record of work done across real projects, over time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/696/1*e7MWPfOTvPbdhVEAIr8SOQ.png" /></figure><p>The certifications mattered, but they were confirmations, not foundations. Oluwabunmi had already been doing the work that AZ-400 tested, designing CI/CD pipelines, writing deployment strategies, governing Azure environments at scale. The credential named what she had built.</p><p>She also became someone others leaned on. She volunteered as a mentor through the Women in Cloud programme and an Amsterdam-based DevOps community group, working with over forty junior engineers across two years. She did not give generic advice. She reviewed their GitHub repositories, asked about their monitoring setups, pushed them to write up what they had shipped.</p><p>In 2028, she co-organized a local DevOps meetup series that drew engineers from across the Netherlands. Three sessions, each centered on a live demo infrastructure automation, incident response, container security. No slides without working code.</p><p>She received the Azure Community Champion award in 2029, recognized for her open-source contributions and the reach of her published technical writing. She accepted it, posted a short note on LinkedIn thanking the engineers who had pushed back on her pull requests over the years, and went back to work.</p><blockquote>“To engineer reliable cloud solutions through automation.”</blockquote><blockquote>— How she still describes her career goal, in exactly those words</blockquote><p>That statement has not changed since she wrote it down years ago. What has changed is the evidence behind it: the production systems, the published articles, the mentees who shipped their own first projects, and the GitHub commit history that documents exactly how she got here.</p><p><a href="https://github.com/Bummieboaxyl">https://github.com/Bummieboaxyl</a> <a href="https://bummie.name.ng/">https://bummie.name.ng</a> <a href="https://medium.com/www.linkedin.com/in/bummie">https://linkedn.com/Bummie</a></p><blockquote>P.S. This post is a part of DevOps Micro Internship with Agentic AI Cohort-3 by <a href="https://www.linkedin.com/in/pravin-mishra-aws-trainer/">Pravin Mishra</a>. You can start your DevOps journey by joining this <a href="https://discord.pravinmishra.com/">Discord community</a> ( <a href="https://discord.pravinmishra.com/">https://discord.pravinmishra.com/</a> ).</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3726bf46a342" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying a Linux EC2 Instance on AWS: A Beginner-Friendly Guide]]></title>
            <link>https://medium.com/@bunmiolowoyeye20/deploying-a-linux-ec2-instance-on-aws-a-beginner-friendly-guide-310ac15d4098?source=rss-a596a81bcbb8------2</link>
            <guid isPermaLink="false">https://medium.com/p/310ac15d4098</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[aws-ec2]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud]]></category>
            <dc:creator><![CDATA[Oluwabunmi Olowoyeye]]></dc:creator>
            <pubDate>Sun, 03 Aug 2025 07:33:20 GMT</pubDate>
            <atom:updated>2025-08-03T07:33:20.081Z</atom:updated>
            <content:encoded><![CDATA[<h3>Cloud computing has revolutionized how we build and manage applications, and Amazon Web Services (AWS) is at the forefront of this transformation. I’ll Walk you through the steps to deploy a <strong>Linux server,</strong> specifically <strong>Amazon Linux 2023</strong> on AWS using EC2 (Elastic Compute Cloud). But first, let’s understand what Linux is and why it’s such a popular choice.</h3><h4>🐧 What Is Linux and Why Use It?</h4><p><strong>Linux</strong> is a free, open-source operating system based on UNIX. It powers everything from smartphones and smart TVs to supercomputers and web servers. Linux offers:</p><ul><li><strong>Stability and performance</strong>: Ideal for servers and enterprise environments.</li><li><strong>Security</strong>: Its architecture and community-driven updates make it highly secure.</li><li><strong>Flexibility</strong>: You can customize it to suit your needs, whether you’re a developer, sysadmin, or hobbyist.</li><li><strong>Cost-effectiveness</strong>: Most Linux distributions are free to use, including Amazon Linux.</li></ul><h4>Deploying Amazon Linux 2023 EC2.</h4><p>Head over to <a href="https://aws.amazon.com/console">AWS Console</a> and navigate to the <strong>EC2 Dashboard</strong>.</p><p>Click <strong>“Launch Instance”</strong> and choose <strong>Amazon Linux 2023</strong>. This image is <strong>Free Tier eligible</strong>, making it perfect for testing and learning.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*8hCNFzonE3YyK3U3ykK3uA.png" /><figcaption>Click launch Instance</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6zvLiKTmcuWEJA9Hr140VA.png" /><figcaption>Choose Amazon Linux</figcaption></figure><p>Create a Key Pair</p><p>This key pair allows secure SSH access to your server. AWS will generate a .pem file (private key) which you must download and store safely usually in your <strong>Downloads</strong> folder.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u580U7h7tgNnavSsr2tUzg.png" /><figcaption>Create and download key pair</figcaption></figure><blockquote><em>🔐 </em>Important: You won’t be able to download the key again, so keep it secure.</blockquote><p>Configure Security Group</p><p>Create a new security group and allow <strong>SSH traffic (port 22)</strong> from <strong>Anywhere</strong>. You can restrict this later to specific IPs for better security.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*Q_ei0mKMAPqW-nqYliHcEA.png" /></figure><p>Scroll down and click <strong>“Launch Instance”</strong>. AWS will begin provisioning your server.</p><p>Give it a few minutes for the instance to pass its <strong>status checks</strong>. Once it’s ready, you’ll see a green checkmark.</p><h4>🔗 Connecting to Your Linux Server</h4><p>To connect via SSH, you’ll need an SSH client. Popular options include:</p><ul><li><strong>Git Bash</strong> (Windows)</li><li><strong>PuTTY</strong></li><li><strong>MobaXterm</strong></li><li><strong>Terminal</strong> (macOS/Linux)</li></ul><p>Navigate to Your Key File</p><p>Open your terminal and move to the folder where your .pem file is stored:</p><pre>cd ~/Downloads</pre><p>Run the following command to change the permission of your key:</p><pre>chmod 400 keypairname.pem</pre><p>Connect to EC2</p><p>Use the command below, replacing keypairname.pem and PublicIPaddress with your actual file name and public IP:</p><pre>ssh -i &quot;keypairname.pem&quot; ec2-user@PublicIPaddress</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*LIsF5Lbj7x46I9Bbto2nJw.png" /><figcaption>The default username for Amazon Linux is always ec2-user</figcaption></figure><p>🎯You are now logged into your Linux server! Ready for anything from development to running applications. You can install packages, configure firewalls and deploy web apps.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=310ac15d4098" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Setting Up and Configuring NGINX on a Fresh Ubuntu Server.]]></title>
            <link>https://medium.com/@bunmiolowoyeye20/setting-up-and-configuring-nginx-on-a-fresh-ubuntu-server-452516754d95?source=rss-a596a81bcbb8------2</link>
            <guid isPermaLink="false">https://medium.com/p/452516754d95</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[web-server]]></category>
            <category><![CDATA[nginx]]></category>
            <dc:creator><![CDATA[Oluwabunmi Olowoyeye]]></dc:creator>
            <pubDate>Fri, 31 Jan 2025 14:36:32 GMT</pubDate>
            <atom:updated>2025-01-31T14:49:26.812Z</atom:updated>
            <content:encoded><![CDATA[<p>Hello, fellow tech enthusiasts! Today, I want to share my journey of setting up and configuring NGINX on a fresh Ubuntu server. This is my first task in my newly enrolled DevOps program, and I am excited to share my experiences and challenges with you.</p><p><strong>Introduction</strong><br>As I embarked on this project, my goal was to set up and configure NGINX on a fresh Ubuntu server. This post will walk you through the steps I took to achieve this setup and configuration. Whether you’re a beginner or an experienced professional, I hope you find this guide helpful.</p><p><strong>Step-by-Step Guide</strong></p><ol><li>Deploying the Ubuntu Server<br>First, I deployed an Ubuntu 24.04 server on Azure. It’s essential to ensure that inbound SSH port 22 and HTTP port 80 are opened on the network security group (NSG). This allows secure access and web traffic to the server. While I used Azure, you can also deploy this Linux server using other cloud provider services such as AWS or Google Cloud.</li><li>Logging into the Server<br>Next, I logged into the server via an SSH client. This step is crucial for remotely managing and configuring the server. Once logged in, I ran the following commands to update the package list and install NGINX:</li></ol><p><em>sudo apt update<br>sudo apt install nginx</em></p><p>The first command updates the package list, ensuring that the server has the latest information about available packages. The second command downloads and installs NGINX along with the necessary dependencies.</p><p>3. Verifying NGINX Installation<br>After installing NGINX, I confirmed its status using the following command:</p><p><em>systemctl status nginx</em></p><p>This command checks whether the NGINX service is active and running. Seeing the “active (running)” status was a satisfying moment, knowing that the web server was up and running.</p><p>4. Creating a Custom HTML Page<br>To personalize the server, I created an index.html file in the /var/www/html directory, which is the default directory for web content. Using a text editor, I crafted a custom HTML page with the content:</p><p><em>Welcome to DevOps Stage 0 — Oluwabunmi Olowoyeye/BubbleBee</em></p><p>This simple yet meaningful page marked the beginning of my DevOps journey.</p><p>5. Configuring NGINX<br>I navigated to the conf.d directory in /etc/nginx and opened the default configuration (default.conf) file. Here, I configured the NGINX server to listen for incoming connections on port 80 and serve files from the /var/www/html directory. This configuration ensures that the server is ready to handle web traffic efficiently.</p><p>6. Testing and Restarting NGINX<br>After making the necessary configurations, I ran a test to ensure everything was set up correctly. The test was successful, and I restarted the NGINX server to apply the changes:</p><p><em>sudo systemctl restart nginx</em></p><p><strong>Challenges and Learnings</strong><br>Despite my limited knowledge of HTML, I encountered some challenges while creating the custom HTML page. However, with the help of online resources, I was able to create a simple yet functional page and host it on the web server. This experience taught me the importance of continuous learning and the value of community resources.</p><p><strong>Conclusion</strong><br>Setting up and configuring NGINX on a fresh Ubuntu server was a rewarding experience. It not only enhanced my technical skills but also boosted my confidence in tackling new challenges. I hope this guide helps you in your DevOps journey.</p><p>Feel free to share your thoughts, questions, or experiences in the comments below.</p><p>DevOps Engineers — <a href="https://hng.tech/hire/devops-engineers">https://hng.tech/hire/devops-engineers</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=452516754d95" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>