<?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 Sergio Romero  on Medium]]></title>
        <description><![CDATA[Stories by Sergio Romero  on Medium]]></description>
        <link>https://medium.com/@sergiors07?source=rss-0848394cfe61------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*UHiVwFTdIfPm8BiutwoDvQ.jpeg</url>
            <title>Stories by Sergio Romero  on Medium</title>
            <link>https://medium.com/@sergiors07?source=rss-0848394cfe61------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 20:35:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sergiors07/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[Runbooks That L1 Actually Executes: Writing Documentation for Support, Not for SREs]]></title>
            <link>https://aws.plainenglish.io/runbooks-that-l1-actually-executes-writing-documentation-for-support-not-for-sres-fe1f1f887004?source=rss-0848394cfe61------2</link>
            <guid isPermaLink="false">https://medium.com/p/fe1f1f887004</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[runbooks]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[incident-response]]></category>
            <dc:creator><![CDATA[Sergio Romero ]]></dc:creator>
            <pubDate>Wed, 23 Sep 2026 18:43:07 GMT</pubDate>
            <atom:updated>2026-09-23T18:43:07.218Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gElhTB-m1YLu9bYdO5vYQg.png" /></figure><p><em>Why most runbooks fail at 3 AM, and the structure that fixes it</em></p><h3>Introduction</h3><p>Picture a 3 AM page. The alert fires, the L1 engineer opens the runbook linked in the alert, and the first line says: “Verify the scheduler state and restart the instance if needed.”</p><p>Which scheduler? Verify where? What does “needed” mean? Twenty minutes later, the L1 engineer escalates to an SRE who is now awake, annoyed, and fixing in two minutes what the runbook should have made possible in five.</p><p>The runbook wasn’t wrong. It was written for the wrong reader.</p><h3>The Problem: Runbooks Written by the People Who Don’t Need Them</h3><p>Most runbooks are written by SREs, right after solving the problem. At that moment we know the system, the access model, the naming conventions, and the failure modes. Every step feels obvious because we already know the answer.</p><p>This is the curse of knowledge, and it produces a specific kind of document: accurate, concise, and unusable by anyone who doesn’t already understand the system. The steps are technically correct. The gaps are in everything the author stopped noticing.</p><p>A runbook is not a record of what an expert did. It is an interface between an expert’s knowledge and a person who doesn’t have it yet. Interfaces get designed for the caller.</p><h3>What L1 Actually Needs</h3><p>After writing and reviewing runbooks for L1/L2 support teams, the same requirements come up every time.</p><p><strong>One runbook, one symptom.</strong> Title it with what the person sees, not what the system does. “Scheduler did not start instance X” is findable from an alert. “EC2 Instance Scheduler internals” is not.</p><p><strong>Prerequisites first.</strong> Access, tools, and permissions go at the top. Nothing is worse than discovering at step 6 that you lack the role required for step 7.</p><p><strong>Commands before explanations.</strong> The person on call needs to act first and understand second. Put the command, then the reason.</p><p><strong>Expected output after every command.</strong> Without it, the reader cannot tell success from failure. “It ran without errors” is not verification.</p><p><strong>Explicit decision points.</strong> Replace “if needed” with a condition the reader can evaluate: “If the output is stopped, continue to step 4. If it is running, go to Escalation.&quot;</p><p><strong>Stated blast radius and reversibility.</strong> Before any disruptive step, say what it affects and whether it can be undone.</p><p><strong>Escalation criteria written into the document.</strong> When to stop, who to contact, and what information to bring.</p><h3>Anatomy of a Runbook L1 Can Follow</h3><p>This is the template I use:</p><pre># [Symptom the reader sees]</pre><pre>## When to use this runbook<br>Alert name or symptom. What this runbook does NOT cover.</pre><pre>## Prerequisites<br>- Access: role or group required<br>- Tools: CLI, version, login command<br>- Information needed: instance ID, environment, ticket number</pre><pre>## Impact<br>What this affects. Whether it is reversible. Estimated duration.</pre><pre>## Steps<br>1. Action<br>   Command<br>   Expected output<br>   If the output differs: go to [Escalation]</pre><pre>## Verification<br>How to confirm the issue is resolved. Command plus expected output.</pre><pre>## Escalation<br>Stop if: [explicit conditions]<br>Contact: [team / rotation]<br>Bring: [logs, timestamps, outputs from steps]</pre><pre>## Rollback<br>How to undo each disruptive step.</pre><pre>## Ownership<br>Owner, last validated date, next review date.</pre><p>Every section exists because its absence caused an escalation at some point.</p><h3>Before and After: Restarting an Instance the Scheduler Missed</h3><p>The example below is illustrative. Replace the identifiers with your own environment.</p><p><strong>Before:</strong></p><blockquote><em>Check whether the scheduler started the instance. If it is in a bad state, restart it and verify the service recovers.</em></blockquote><p><strong>After:</strong></p><pre># Instance did not start at its scheduled time</pre><pre>## Prerequisites<br>- AWS CLI authenticated to the correct account<br>- Instance ID from the alert (format: i-0123456789abcdef0)</pre><pre>## Impact<br>Starting a stopped instance is reversible. The service on it is<br>unavailable until the instance passes status checks (typically a few minutes).</pre><pre>## Steps<br>1. Check the current state.</pre><pre>   aws ec2 describe-instances --instance-ids i-0123456789abcdef0 \<br>     --query &quot;Reservations[0].Instances[0].State.Name&quot; --output text</pre><pre>   Expected: stopped<br>   If the output is &quot;running&quot;: go to Escalation (the issue is not the scheduler).</pre><pre>2. Start the instance.</pre><pre>   aws ec2 start-instances --instance-ids i-0123456789abcdef0</pre><pre>   Expected: JSON with CurrentState &quot;pending&quot;.</pre><pre>3. Wait until it is running.</pre><pre>   aws ec2 wait instance-running --instance-ids i-0123456789abcdef0</pre><pre>   Expected: returns with no output. If it does not return within 5 minutes,<br>   go to Escalation.</pre><pre>## Verification<br>   aws ec2 describe-instance-status --instance-ids i-0123456789abcdef0 \<br>     --query &quot;InstanceStatuses[0].InstanceStatus.Status&quot; --output text</pre><pre>   Expected: ok</pre><pre>## Escalation<br>Stop if: state is anything other than &quot;stopped&quot; in step 1, step 3 times<br>out, or status checks fail after 5 minutes.<br>Bring: instance ID, outputs from steps 1-3, alert timestamp.</pre><p>The second version is longer. It is also the only one a person without prior context can execute correctly.</p><h3>Escalation Is a Feature, Not a Failure</h3><p>Many runbooks avoid documenting escalation because it feels like admitting the runbook is incomplete. That gets it backwards.</p><p>L1 engineers who escalate at the right moment, with the right information, are doing the job correctly. The ones who improvise past step 4 because the document never told them to stop are the real risk. A clear stop condition protects the system, the engineer, and the SRE who gets the call.</p><p>Writing “Stop if…” into the document also gives L1 permission to escalate without feeling they failed. That matters as much as the commands.</p><h3>Validate With a Cold Run</h3><p>A runbook you haven’t tested with its real audience is a hypothesis.</p><p>The test is simple. Hand the runbook to an L1 engineer who hasn’t seen it. Sit next to them and say nothing. Write down every question they ask, every place they hesitate, and every command they type differently than written.</p><p>Each of those is a bug in the document. Fix the runbook, not the reader.</p><p>Then keep it alive:</p><ul><li>Every runbook has an owner and a last-validated date in the file itself.</li><li>Link the runbook directly from the alert, so nobody has to search for it.</li><li>Review after every incident where it was used, and on a fixed cadence otherwise.</li><li>Version it in the repository, so changes go through pull requests like code.</li></ul><h3>Measuring Whether It Works</h3><p>Completion of documentation is not a metric. Outcomes are:</p><ul><li>Escalation rate on alerts that have a runbook, tracked over time</li><li>Time from page acknowledged to first correct action</li><li>Number of questions asked during a cold run</li><li>Percentage of steps that include an expected output</li></ul><p>These follow the same principle I use for onboarding: the metrics that predict success are behavioral, not administrative.</p><h3>Final Thoughts</h3><p>A runbook’s job is not to prove that the author knows the system. It is to let someone who doesn’t know it yet act correctly under pressure.</p><p>That requires the same qualities as good onboarding: context, clear next steps, permission to ask for help, and confidence that the path in front of you has been tested by someone like you.</p><p>If you want reliable operations, write for the person who will use the document at 3 AM, not for the person who wrote it at noon.</p><h3>Want to Learn More?</h3><p>If you’re building support runbooks, training L1/L2 teams, or just want to compare notes on documentation practices, I’m happy to connect. You can find more about my work at rsergio.com.</p><p>Let’s make runbooks something the reader can trust — not something they have to decode.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe1f1f887004" width="1" height="1" alt=""><hr><p><a href="https://aws.plainenglish.io/runbooks-that-l1-actually-executes-writing-documentation-for-support-not-for-sres-fe1f1f887004">Runbooks That L1 Actually Executes: Writing Documentation for Support, Not for SREs</a> was originally published in <a href="https://aws.plainenglish.io/">AWS in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SRE + AI: Where Automation Breaks (and Humans Still Matter)]]></title>
            <link>https://aws.plainenglish.io/sre-ai-where-automation-breaks-and-humans-still-matter-b97809b1077c?source=rss-0848394cfe61------2</link>
            <guid isPermaLink="false">https://medium.com/p/b97809b1077c</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[sre]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Sergio Romero ]]></dc:creator>
            <pubDate>Tue, 21 Apr 2026 00:25:26 GMT</pubDate>
            <atom:updated>2026-04-21T00:30:01.304Z</atom:updated>
            <content:encoded><![CDATA[<h3>SRE + AI: Where Automation Breaks in Production</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wkhmi8J4PvJLtMdeXdwzdA.png" /></figure><h3>The Incident That “Resolved Itself” — Until It Didn’t</h3><p>A few weeks ago, during a controlled test in a Kubernetes environment, we introduced a failure in one of our services — nothing unusual, something we’ve done many times before. This time, however, the system was running with an AI-driven decision layer on top of our observability and automation stack. Alerts fired, the AI agent analyzed the metrics, and it decided no scaling action was needed. From the system’s perspective, the cluster was stable. From the user’s perspective, it wasn’t. Latency had increased and requests were timing out intermittently — not enough to trigger hard alerts, but enough to degrade the experience. The system didn’t fail; it behaved exactly as it was designed to behave. The issue was that the design didn’t include the right signals.</p><h3>The Promise of AI in SRE</h3><p>The appeal of AI in SRE is clear. It reduces toil, accelerates decision-making, and correlates signals across complex systems faster than any human can. In most cases, these systems outperform manual operations — especially in speed, consistency, and early signal detection. Predictive autoscaling can prepare capacity before demand spikes, and intelligent alerting can filter noise and highlight relevant issues. The result is faster response times and more efficient operations. But speed is not the same as understanding, and that distinction becomes critical once systems move beyond ideal conditions.</p><h3>Where Automation Meets Its Limits</h3><p>Automation reaches its limits when signals are no longer enough. AI systems operate on metrics, logs, and events, but they do not inherently understand business context unless that context is explicitly modeled. In this case, the system optimized for infrastructure health: CPU usage was within limits, memory was stable, and no pods were crashing. Based on those inputs, the decision to not scale was consistent. What it didn’t capture was the degradation in user experience. Latency was increasing, and while the infrastructure appeared healthy, the service quality was not. This is not a failure of AI — it is a gap in system design.</p><p>A second limitation appears as systems become trusted. As automation proves reliable, teams reduce validation. Decisions are accepted because they are automated. In this scenario, no one intervened immediately because nothing appeared critical from the system’s perspective. The absence of urgency from the system translated into the absence of urgency from the team.</p><p>This is compounded by partial observability. AI decisions are only as good as the data they receive. If user-impact signals are weak or missing, the system operates with blind spots. There were no strong SLO-driven alerts tied to latency and limited correlation between infrastructure metrics and user-facing performance. The system didn’t ignore the problem; it didn’t have enough context to recognize it as critical.</p><h3>A Real Scenario: When the System Needed Context</h3><p>As traffic increased gradually, latency began to rise, but CPU usage remained within acceptable thresholds. Since traditional scaling signals were not breached, no scaling action was triggered. From a resource perspective, the system appeared stable. From a user perspective, performance was degrading. When we manually scaled the service, latency dropped immediately. The system had the capacity to resolve the issue — it just lacked the context to act at the right time. This is the boundary between automation and judgment.</p><h3>The Trade-Off: Speed vs Understanding</h3><p>AI systems optimize for speed, consistency, and scale. Humans bring context, interpretation, and decision-making under uncertainty. Optimizing exclusively for speed introduces risk when signals are incomplete or ambiguous. Fast decisions are valuable, but only when aligned with the right objectives. In SRE, those objectives extend beyond infrastructure health to include user experience and business impact.</p><h3>Designing Systems Where AI and Humans Work Together</h3><p>The goal is not to reduce human involvement, but to elevate it. AI should handle signal processing, pattern detection, and rapid execution. Humans should focus on decisions where context, ambiguity, and trade-offs matter.</p><p>Critical decisions — especially those affecting user experience — should not be fully delegated when signals are unclear. AI should provide recommendations, while humans validate high-impact actions. Guardrails are essential: scaling limits, failover constraints, and controlled automation boundaries prevent systems from acting beyond safe conditions.</p><p>At the same time, observability must be designed for both machines and humans. SLO-driven dashboards, clear latency indicators, and direct mappings to business impact ensure that when intervention is needed, it is fast and informed.</p><h3>Practical Takeaways</h3><p>Do not delegate irreversible decisions to automation without context. Tie AI-driven actions to user-impact metrics, not just infrastructure signals. Design systems with clear fallback paths for human intervention. Validate automated decisions in ambiguous scenarios. Treat AI as a force multiplier, not a replacement for judgment.</p><h3>Final Thoughts</h3><p>AI does not replace good system design — it amplifies it. In well-designed systems, it becomes a force multiplier, accelerating decisions and improving reliability. In incomplete systems, it exposes missing context and weak signals.</p><p>The goal in SRE is not to choose between automation and humans. It is to design systems where both work together effectively. Because in production environments, speed matters — but understanding is what keeps systems reliable.</p><h3>Want to Learn More?</h3><p>If you’re building resilient systems or exploring AI-driven operations — or just curious about bringing these patterns into your own infrastructure — I’m happy to connect. You can find more about my work at rsergio.com</p><p>Let’s make intelligent resilience a design choice — not an afterthought.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b97809b1077c" width="1" height="1" alt=""><hr><p><a href="https://aws.plainenglish.io/sre-ai-where-automation-breaks-and-humans-still-matter-b97809b1077c">SRE + AI: Where Automation Breaks (and Humans Still Matter)</a> was originally published in <a href="https://aws.plainenglish.io/">AWS in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Production-Ready Multi-Agent Systems on Kubernetes: Real Lessons from Deploying 11…]]></title>
            <link>https://aws.plainenglish.io/building-production-ready-multi-agent-systems-on-kubernetes-real-lessons-from-deploying-11-b01976cd4236?source=rss-0848394cfe61------2</link>
            <guid isPermaLink="false">https://medium.com/p/b01976cd4236</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <dc:creator><![CDATA[Sergio Romero ]]></dc:creator>
            <pubDate>Mon, 29 Sep 2025 14:24:31 GMT</pubDate>
            <atom:updated>2025-10-01T04:31:46.011Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AFOaKfD8f_MOhVSvyjQ7_Q.png" /></figure><h3>Building Production-Ready Multi-Agent Systems on Kubernetes: Real Lessons from Deploying 11 Specialized AI Agents</h3><h3>The Technical Reality Behind AI-Powered Infrastructure Operations</h3><p>Last week at Cloud Native Costa Rica, I demonstrated something I’d been building for months: a comprehensive multi-agent system running on Kubernetes with eleven specialized Kagent agents, each designed for specific operational domains. The demo wasn’t about flashy AI magic — it was about showing how thoughtful agent specialization and proper cloud-native deployment patterns can create genuinely useful operational tools.</p><p>The architecture I built represents months of iterative development, learning how to properly deploy AI agents as Kubernetes custom resources, integrate dual AI providers seamlessly, and create realistic scenarios that expose both the capabilities and limitations of AI-augmented operations.</p><h3>The Real Architecture: Kubernetes-Native Agent Deployment</h3><p>The foundation of this system is treating AI agents as first-class Kubernetes resources. Each agent deploys as a custom resource definition with proper RBAC, resource limits, and tool integrations that actually work in production environments.</p><h3>Agent Specialization Strategy</h3><p>Rather than building one general-purpose AI assistant, I designed eleven focused agents:</p><p><strong>Infrastructure Operations:</strong></p><ul><li>k8s-agent - Core Kubernetes operations and cluster troubleshooting</li><li>helm-agent - Package management and chart lifecycle operations</li><li>observability-agent - Prometheus, Grafana, and metrics analysis</li></ul><p><strong>Network Management:</strong></p><ul><li>cilium-debug-agent - Network debugging and connectivity troubleshooting</li><li>cilium-manager-agent - CNI configuration and management</li><li>cilium-policy-agent - Network policy creation and validation</li><li>istio-agent - Service mesh operations and traffic management</li><li>kgateway-agent - API gateway configuration and routing</li></ul><p><strong>Deployment Orchestration:</strong></p><ul><li>argo-rollouts-conversion-agent - Progressive delivery patterns</li><li>promql-agent - Natural language to PromQL query generation</li><li>sre-companion - Custom blue-green deployment specialist</li></ul><p>Each agent runs with specific tool sets and system prompts tailored to their operational domain.</p><h3>The Kubernetes Deployment Pattern</h3><p>Here’s how each agent actually deploys:</p><pre>apiVersion: kagent.dev/v1alpha2<br>kind: Agent<br>metadata:<br>  name: sre-companion<br>  namespace: kagent<br>spec:<br>  type: Declarative<br>  description: SRE failover agent for blue/green deployment testing<br>  declarative:<br>    modelConfig: openai-gpt4o<br>    systemMessage: |<br>      You are a specialized SRE failover agent for managing Kubernetes <br>      blue/green deployment scenarios.<br>      <br>      Current Environment Context:<br>      - Primary namespace: &#39;sre-companion-demo&#39;<br>      - Blue deployment: &#39;web-blue&#39; (active when running, typically 2 replicas)<br>      - Green deployment: &#39;web-green&#39; (standby when inactive, typically 0 replicas)<br>      - Load balancer service: &#39;web&#39; (routes traffic between blue/green)<br>    <br>    tools:<br>      - type: McpServer<br>        mcpServer:<br>          apiGroup: kagent.dev<br>          kind: RemoteMCPServer<br>          name: kagent-tool-server<br>          toolNames:<br>            - k8s_get_resources<br>            - k8s_describe_resource<br>            - k8s_apply_manifest</pre><p>This deployment pattern ensures each agent has appropriate permissions and tool access while maintaining security boundaries.</p><h3>Dual-Provider Architecture: The Technical Implementation</h3><p>One of the most valuable aspects of the system is the ability to switch between AI providers — OpenAI GPT-4o and Anthropic Claude Sonnet 4 — while maintaining conversation context. This required solving several technical challenges.</p><h3>Provider Configuration</h3><p>The system maintains separate model configurations for each provider:</p><pre># OpenAI Configuration<br>apiVersion: kagent.dev/v1alpha2<br>kind: ModelConfig<br>metadata:<br>  name: openai-gpt4o<br>  namespace: kagent<br>spec:<br>  provider: OpenAI<br>  model: gpt-4o<br>  apiKeySecret: kagent-openai<br>  apiKeySecretKey: OPENAI_API_KEY<br><br>----<br><br># Anthropic Configuration  <br>apiVersion: kagent.dev/v1alpha2<br>kind: ModelConfig<br>metadata:<br>  name: anthropic-claude<br>  namespace: kagent<br>spec:<br>  provider: Anthropic<br>  model: claude-sonnet-4-20250514<br>  apiKeySecret: kagent-anthropic<br>  apiKeySecretKey: ANTHROPIC_API_KEY</pre><h3>Context Persistence</h3><p>The system maintains conversation state across provider switches through:</p><pre>apiVersion: kagent.dev/v1alpha1<br>kind: Memory<br>metadata:<br>  name: failover-memory<br>  namespace: kagent<br>spec: {}<br><br>----<br><br>apiVersion: kagent.dev/v1alpha1<br>kind: Session<br>metadata:<br>  name: failover-session<br>  namespace: kagent<br>spec:<br>  agent: sre-companion</pre><p>This architecture enables seamless switching between providers during the same operational session.</p><h3>The Demo Environment: Realistic Operational Scenarios</h3><p>The demonstration environment I built deliberately includes realistic challenges that teams face in production environments. The setup includes:</p><h3>Blue-Green Deployment Configuration</h3><p>The demo application deploys as two separate Kubernetes deployments:</p><ul><li><strong>Blue deployment:</strong> 2 replicas, actively receiving traffic</li><li><strong>Green deployment:</strong> 0 replicas, configured but not running</li><li><strong>Service configuration:</strong> Routes traffic based on version selector</li></ul><p>This setup intentionally exposes a common disaster recovery gap — having failover mechanisms that switch to unprepared standby environments.</p><h3>Autonomous Failover Controller</h3><p>I implemented a custom failover controller that monitors endpoint availability and automatically switches service selectors when failures are detected:</p><pre>def main():<br>    log(&quot;Starting Automatic Failover Controller&quot;)<br>    log(f&quot;Monitoring service &#39;{SERVICE_NAME}&#39; in namespace &#39;{NAMESPACE}&#39;&quot;)<br>    <br>    while True:<br>        try:<br>            selector = get_service_selector()<br>            endpoints_count = get_service_endpoints()<br>            <br>            if selector and selector.get(&#39;version&#39;) == &#39;blue&#39;:<br>                if endpoints_count == 0:<br>                    log(&quot;ALERT: Blue has no endpoints! Initiating failover...&quot;)<br>                    create_event(&quot;FailoverTriggered&quot;, &quot;Blue deployment has no available endpoints&quot;)<br>                    <br>                    if switch_to_green():<br>                        create_event(&quot;FailoverSuccess&quot;, &quot;Automatically switched traffic to green deployment&quot;)</pre><p>This controller demonstrates both the capabilities and limitations of automated failover systems.</p><h3>Real Demo Scenarios: What Actually Happened</h3><p>During the presentation, I walked through several scenarios that demonstrate different aspects of the multi-agent system:</p><h3>Load Testing and Scaling Analysis</h3><p>Using the load testing script I built:</p><pre>./scripts/load-test.sh 60 50 200</pre><p>The agents analyzed resource utilization, scaling behavior, and performance impacts in real-time. The sre-companion agent provided immediate scaling recommendations, while switching to Claude Sonnet 4 revealed deeper pattern analysis and optimization strategies.</p><h3>Deliberate Failure Scenarios</h3><p>The failure simulation script creates controlled outages:</p><pre>./scripts/simulate-failure.sh blue --outage 60</pre><p>This triggers the failover controller, which successfully switches traffic to green — but reveals that green has zero replicas, creating a “successful failover to nowhere” scenario that teams encounter in production.</p><h3>Agent Specialization in Action</h3><p>During the demo, different agents provided distinct perspectives on the same operational scenarios:</p><ul><li><strong>k8s-agent:</strong> Rapid cluster state assessment and immediate remediation steps</li><li><strong>observability-agent:</strong> Metrics analysis and alerting strategy recommendations</li><li><strong>promql-agent:</strong> Query generation for complex monitoring scenarios</li></ul><p>The value came from having specialized tools and context for each operational domain rather than trying to make one agent handle everything.</p><h3>Technical Lessons from Building This System</h3><h3>Agent Specialization Beats Generalization</h3><p>Focused agents with curated tool sets consistently outperformed general-purpose assistants on domain-specific tasks. The network debugging agent, with its specialized CNI troubleshooting tools, provided better connectivity analysis than broader infrastructure agents.</p><h3>Context Management Is Critical</h3><p>The ability to maintain conversation state across agent switches and provider changes proved essential for complex operational scenarios. Kubernetes-native session management made this possible.</p><h3>Realistic Scenarios Reveal Real Value</h3><p>The most valuable demonstrations came from scenarios that exposed actual operational gaps — like unprepared standby environments and incomplete monitoring coverage — rather than perfect success stories.</p><h3>Deployment Complexity and Resource Requirements</h3><p>Building this system required significant infrastructure:</p><ul><li><strong>Kubernetes cluster:</strong> Minimum 6 CPU, 12GB RAM</li><li><strong>Multiple Helm charts:</strong> Prometheus stack, Kagent platform, custom applications</li><li><strong>API key management:</strong> Secure secrets for dual AI providers</li><li><strong>Monitoring integration:</strong> Custom Grafana dashboards and alerting rules</li></ul><p>The setup script I created handles the full deployment:</p><pre>./scripts/setup-sre-companion.sh</pre><p>But getting all components working together reliably took considerable iteration and debugging.</p><h3>The Reality of AI-Augmented Operations</h3><p>After months of building and demonstrating this system, several insights emerged:</p><p><strong>AI agents excel at knowledge synthesis and pattern recognition</strong> but still require careful tool integration and domain-specific prompting to be genuinely useful in operational contexts.</p><p><strong>Multi-agent architectures provide flexibility</strong> that single-agent systems cannot match, but they also introduce complexity in coordination and context management.</p><p><strong>Production deployment requires significant infrastructure</strong> and ongoing maintenance that goes well beyond simple API integrations.</p><h3>Looking Forward: Practical Applications</h3><p>The techniques demonstrated in this system have practical applications for teams managing complex infrastructure:</p><ul><li><strong>Specialized troubleshooting agents</strong> for different technology stacks</li><li><strong>Context-aware operational documentation</strong> that updates based on current system state</li><li><strong>Comparative analysis capabilities</strong> using different AI providers for strategic decisions</li></ul><p>The key is focusing on specific operational domains where AI can genuinely augment human expertise rather than trying to automate entire operational workflows.</p><h3>Getting Started: Building Your Own Agent System</h3><p>The complete demo environment, including all configurations and deployment scripts, is available as open source. The Kagent platform provides the foundation for building specialized agent systems with production-grade session management and tool integration.</p><p>For teams interested in AI-augmented operations, the path forward involves identifying specific operational domains where agent specialization can provide genuine value, then building focused tools rather than trying to solve everything with general-purpose AI.</p><p>The future of operational excellence lies in thoughtful human-AI collaboration, not in replacing operational expertise with artificial intelligence.</p><p><strong>Repository:</strong> <a href="https://github.com/rsergio07/Kagent-SRE-Companion">Kagent SRE Companion Demo</a></p><p><strong>Want to Learn More?</strong></p><p>If you’re building resilient systems or exploring AI-driven operations — or just curious about bringing these patterns into your own infrastructure — I’m happy to connect. You can find more about my work at <a href="https://rsergio.com/">rsergio.com</a></p><p>Let’s make intelligent resilience a design choice — not an afterthought.</p><h3>A message from our Founder</h3><p><strong>Hey, </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>Sunil</strong></a><strong> here.</strong> I wanted to take a moment to thank you for reading until the end and for being a part of this community.</p><p>Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? <strong>We don’t receive any funding, we do this to support the community. ❤️</strong></p><p>If you want to show some love, please take a moment to <strong>follow me on </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>LinkedIn</strong></a><strong>, </strong><a href="https://tiktok.com/@messyfounder"><strong>TikTok</strong></a>, <a href="https://instagram.com/sunilsandhu"><strong>Instagram</strong></a>. You can also subscribe to our <a href="https://newsletter.plainenglish.io/"><strong>weekly newsletter</strong></a>.</p><p>And before you go, don’t forget to <strong>clap</strong> and <strong>follow</strong> the writer️!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b01976cd4236" width="1" height="1" alt=""><hr><p><a href="https://aws.plainenglish.io/building-production-ready-multi-agent-systems-on-kubernetes-real-lessons-from-deploying-11-b01976cd4236">Building Production-Ready Multi-Agent Systems on Kubernetes: Real Lessons from Deploying 11…</a> was originally published in <a href="https://aws.plainenglish.io/">AWS in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Truth About SRE Onboarding: How to Make New Hires Succeed Faster]]></title>
            <link>https://aws.plainenglish.io/the-truth-about-sre-onboarding-how-to-make-new-hires-succeed-faster-b1ea43a21704?source=rss-0848394cfe61------2</link>
            <guid isPermaLink="false">https://medium.com/p/b1ea43a21704</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[mentorship]]></category>
            <category><![CDATA[onboarding]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <dc:creator><![CDATA[Sergio Romero ]]></dc:creator>
            <pubDate>Tue, 16 Sep 2025 17:26:11 GMT</pubDate>
            <atom:updated>2025-09-18T01:34:35.632Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7gS8ND5_dN60irjHKLOYDg.png" /></figure><h3>Beyond the Technical Checklist: What Really Makes or Breaks the First 90 Days</h3><h3>Introduction</h3><p>Three months into his role as our newest SRE, one team member was still struggling. On paper, he had everything: a computer science degree, cloud certifications, and experience with our tech stack. Yet during incidents, he froze. In team meetings, he rarely spoke up. His pull requests were technically sound but showed no understanding of our reliability philosophy.</p><p>The problem wasn’t him. The problem was our onboarding.</p><p>Like most tech companies, we had focused on the technical checklist: access to systems, documentation reviews, and shadowing experienced engineers. What we hadn’t addressed was the invisible curriculum — the unspoken knowledge, cultural norms, and decision-making frameworks that separate effective SREs from those who merely know the tools.</p><p>After redesigning our approach and mentoring dozens of new hires over the past six years across different organizations, I’ve learned that successful SRE onboarding isn’t about faster technical competency. It’s about building confidence, context, and connection from day one.</p><h3>The Hidden Curriculum of SRE Work</h3><p>Traditional onboarding treats SRE work like a collection of technical tasks. Learn Kubernetes. Understand our monitoring stack. Read the runbooks. Check, check, check.</p><p>But SRE work is fundamentally about judgment under pressure. When a production system fails at 2 AM, technical knowledge is just the foundation. What matters is knowing which questions to ask, who to escalate to, and how to communicate clearly while your heart is racing.</p><p>During my second week mentoring a career changer from backend development, she made an observation that stuck with me: “The hardest part isn’t learning Prometheus queries. It’s learning when not to use them.”</p><p>She was right. The technical skills are learnable. The wisdom — understanding the trade-offs, reading the room during incidents, knowing when to push back on unrealistic reliability targets — that’s what takes months to develop. Unless we’re intentional about it.</p><h3>What New Hires Really Need (But Rarely Get)</h3><p>After tracking the progress of 40+ new SREs over six years across multiple teams and organizations, clear patterns emerged. The engineers who succeeded fastest shared common early experiences that had nothing to do with technical training:</p><p><strong>Psychological Safety in Learning</strong> The best-performing new hires were those who felt safe making mistakes early. When one engineer accidentally triggered a non-critical alert during his first week, instead of hiding it, he immediately shared what happened in our team chat. The response wasn’t judgment — it was collective problem-solving and shared stories of similar experiences. That moment established trust that accelerated his learning for months.</p><p><strong>Context Before Content</strong> Rather than diving straight into technical documentation, successful onboarding starts with the “why” behind our systems. I now begin every new hire relationship with the same question: “What’s the most reliable system you interact with daily?” The answers — elevators, traffic lights, their car’s engine — become the foundation for discussing reliability trade-offs in familiar terms.</p><p><strong>Mentorship, Not Just Management</strong> There’s a difference between having a manager and having a mentor. Managers handle logistics and performance. Mentors share war stories, explain unwritten rules, and provide the emotional support that turns overwhelming complexity into manageable challenges. Every successful new hire had someone who genuinely cared about their growth beyond their deliverables.</p><p><strong>Exposure to Real Decisions</strong> The fastest path to SRE wisdom is watching experienced engineers make decisions in real-time. Not just during incidents, but during architecture reviews, capacity planning sessions, and priority discussions. I started including new hires as silent observers in senior-level technical discussions from week two. The learning curve compressed dramatically.</p><h3>The Framework That Actually Works</h3><p>Based on these insights, here’s the framework that consistently produces confident, effective SREs within 90 days:</p><p><strong>Week 1–2: Foundation and Context</strong> Instead of jumping into technical deep-dives, focus on reliability philosophy. Share the stories behind current systems — why certain architectural decisions were made, what incidents shaped current practices, how the team’s role evolved. This builds the mental models that inform future technical decisions.</p><p><strong>Week 3–4: Guided Observation</strong> Pair new hires with different team members for various activities: incident response simulation, architecture reviews, vendor discussions. The goal isn’t participation — it’s pattern recognition. They’re learning how experienced SREs think, not just what they know.</p><p><strong>Week 5–8: Safe Practice with Real Stakes</strong> Assign ownership of non-critical but real systems. Set up scenarios where they can make meaningful decisions without catastrophic consequences. The key is genuine responsibility with appropriate support structures.</p><p><strong>Week 9–12: Reverse Mentoring</strong> Have new hires teach something back to the team — a new tool they investigated, a process improvement they identified, or a fresh perspective on an existing problem. This solidifies their learning and establishes them as contributors, not just consumers of knowledge.</p><h3>Measuring What Matters</h3><p>Most onboarding programs measure completion of training modules or systems access. But the metrics that predict long-term success are different:</p><ul><li>How quickly do they ask clarifying questions during incidents?</li><li>Do they proactively share learnings with team members?</li><li>Can they explain technical decisions in terms of business impact?</li><li>How do they handle uncertainty and ambiguity?</li></ul><p>These behaviors emerge from confidence and context, not technical competency alone.</p><h3>Final Thoughts</h3><p>The truth about SRE onboarding is that speed isn’t the goal — sustainability is. An engineer who takes 120 days to become fully effective but stays engaged and growing for years is far more valuable than one who appears productive at 60 days but burns out or stagnates.</p><p>The most successful new hires I’ve mentored didn’t just learn our systems — they learned our values, our decision-making frameworks, and our approach to balancing competing priorities. They became not just technically competent, but culturally integrated and psychologically prepared for the unique challenges of reliability engineering.</p><h3>Call to Action</h3><p>If you’re designing SRE onboarding programs, start with empathy, not efficiency. Ask your newest team members what they wish they had known sooner. Review your last three new hire experiences — not for technical gaps, but for emotional and contextual ones.</p><p>And if you’re a new SRE reading this, remember that feeling overwhelmed is normal, temporary, and shared by everyone who came before you. The complexity you’re experiencing isn’t a reflection of your capability — it’s a reflection of the sophisticated systems and practices that make modern reliability engineering both challenging and rewarding.</p><p>The best SREs aren’t those who never struggled during onboarding. They’re those who learned to turn that struggle into wisdom they could share with the next person walking through the door.</p><p><em>What aspects of SRE onboarding do you think matter most? I’d love to hear about your experiences — both as someone being onboarded and as someone helping others get started in their reliability engineering journey.</em></p><p>“I’m happy to connect. You can find more about my work at my site <a href="https://rsergio.com/">https://rsergio.com</a>&quot;</p><h3>A message from our Founder</h3><p><strong>Hey, </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>Sunil</strong></a><strong> here.</strong> I wanted to take a moment to thank you for reading until the end and for being a part of this community.</p><p>Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? <strong>We don’t receive any funding, we do this to support the community. ❤️</strong></p><p>If you want to show some love, please take a moment to <strong>follow me on </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>LinkedIn</strong></a><strong>, </strong><a href="https://tiktok.com/@messyfounder"><strong>TikTok</strong></a>, <a href="https://instagram.com/sunilsandhu"><strong>Instagram</strong></a>. You can also subscribe to our <a href="https://newsletter.plainenglish.io/"><strong>weekly newsletter</strong></a>.</p><p>And before you go, don’t forget to <strong>clap</strong> and <strong>follow</strong> the writer️!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b1ea43a21704" width="1" height="1" alt=""><hr><p><a href="https://aws.plainenglish.io/the-truth-about-sre-onboarding-how-to-make-new-hires-succeed-faster-b1ea43a21704">The Truth About SRE Onboarding: How to Make New Hires Succeed Faster</a> was originally published in <a href="https://aws.plainenglish.io/">AWS in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Distributed Resilience: How I Brought Agentic AI Into Kubernetes]]></title>
            <link>https://aws.plainenglish.io/distributed-resilience-how-i-brought-agentic-ai-into-kubernetes-17f261ba81db?source=rss-0848394cfe61------2</link>
            <guid isPermaLink="false">https://medium.com/p/17f261ba81db</guid>
            <category><![CDATA[conference]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Sergio Romero ]]></dc:creator>
            <pubDate>Thu, 21 Aug 2025 14:41:58 GMT</pubDate>
            <atom:updated>2025-09-18T01:34:40.000Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*whvbXEkgUzl3COAHQtooHg.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/739/1*SNGLs4frF0kfqg-2hT5Cow.jpeg" /></figure><p>When I look back at my journey in Site Reliability Engineering, one theme keeps coming up again and again: <strong>resilience</strong>. Not just resilience of systems, but resilience of people, teams, and the way we adapt when things fail.</p><p>This week, I had the privilege of speaking to a group of students in the <strong>Information Technology Management program at the Tecnológico de Costa Rica (TEC)</strong>. I had the chance to share one of my favorite topics: <em>Distributed Resilience in Cloud-Native Systems</em>.</p><p>But this wasn’t just a presentation — it was a hands-on journey from traditional reactive automation to intelligent, AI-driven operations.</p><h3>Beyond Theory: Building Resilience in Real Time</h3><p>In the world of cloud-native, we often talk about scale, speed, and innovation. But what really matters is what happens when things go wrong. A failing node, a crashing container, or a regional outage.</p><p>During my session at TEC, we didn’t just discuss resilience — we built it. Starting with familiar Kubernetes patterns and advancing to cutting-edge AI-driven operations, the students experienced firsthand how systems can evolve from reactive automation to proactive intelligence.</p><p>We began with <strong>Blue/Green Resilience with HPA + Auto-Failover</strong>. The students watched as traditional Kubernetes demonstrated its strengths: horizontal pod autoscaling reacting to CPU thresholds, blue/green deployments providing redundancy, and a failover watcher instantly redirecting traffic when one side failed. This gave them a solid foundation in reactive automation and reliable recovery under pressure.</p><p>Then we pushed further.</p><h3>The Evolution: From Reactive to Intelligent</h3><p>The part of the hands-on session that generated the most engagement was when we transitioned to <strong>Intelligent Failover with AI Agents</strong>.</p><p>Here’s where the magic happened. Using <a href="https://kagent.dev/">CNCF’s Kagent framework</a> for AI-driven operations alongside Prometheus for metrics collection, Grafana for visualization, and Alertmanager for intelligent alerting, the students watched an AI operations agent:</p><ul><li><strong>Monitor patterns</strong> across workload behavior</li><li><strong>Predict scaling needs</strong> before they became critical</li><li><strong>Balance performance, cost, and user experience</strong> in real-time decisions</li></ul><p>We ran live failure simulations where the AI agent had to make contextual failover decisions — shaped by business impact as much as technical health. The system learned from each scenario to optimize future behavior.</p><p>One student asked a particularly sharp question: <em>“What happens when the AI agent makes the wrong decision?”</em></p><p>We explored this by deliberately introducing network latency and partial failures. The students saw how the system recognized degraded states and triggered corrective action, but also witnessed moments where the AI’s predictions weren’t perfect — and how the system recovered from those imperfect decisions.</p><h3>The Numbers Tell the Story</h3><p>What made this demonstration compelling wasn’t just the technology — it was the measurable impact. Throughout the session, we tracked key metrics:</p><p><strong>Failover time</strong>: How quickly the platform detected unhealthy deployments and redirected traffic. Traditional HPA: 45–60 seconds. AI-driven: 15–20 seconds with predictive scaling already in progress.</p><p><strong>Scaling latency</strong>: The interval between workload triggers and available capacity. The AI agent’s predictive capabilities often had capacity ready before demand peaked.</p><p>We used the included cost calculator to simulate monthly expenses for different strategies — always-on, peak-hour scaling, and scale-to-zero — giving students a concrete understanding of the financial implications of their architectural choices.</p><h3>Real-World Applications</h3><p>The students quickly grasped how these patterns extend beyond the lab. During our discussion, they identified applications in:</p><ul><li><strong>Financial systems</strong> where transaction processing must remain uninterrupted during node failures or traffic surges</li><li><strong>E-commerce platforms</strong> preparing for seasonal sales by increasing capacity based on historical demand patterns</li><li><strong>SaaS providers</strong> maintaining service availability across regions while automatically rebalancing during data center issues</li><li><strong>Public sector systems</strong> where budget oversight is as critical as uptime</li></ul><p>One student from the IT management program made a particularly insightful connection: <em>“This isn’t just about Kubernetes — it’s about building decision-making into infrastructure that understands business priorities.”</em></p><h3>From Lab to Production</h3><p>The beauty of this hands-on approach is that everything we demonstrated runs offline and can be immediately applied. The complete lab environment includes:</p><ul><li><strong>Deployment and cleanup scripts</strong> for consistent setup</li><li><strong>Architecture diagrams</strong> showing component interactions</li><li><strong>Realistic failure simulations</strong> including chaos experiments</li><li><strong>Cost modeling tools</strong> with configurable pricing assumptions</li><li><strong>Two complete runbooks</strong> guiding the journey from traditional to intelligent resilience</li></ul><p>What impressed the students most was seeing how the AI agent integrated financial considerations directly into scaling strategies. When we simulated budget constraints, they watched the system balance cost and performance in real-time — making infrastructure decisions that a traditional HPA could never handle.</p><h3>The Future of Operations</h3><p>Sharing these advanced resilience strategies with future IT professionals was rewarding, but watching them immediately grasp the implications of AI-driven operations was exciting.</p><p>During the live demo, when we pushed the system beyond its default boundaries — introducing artificial network latency, crashing partial deployments, testing in different cluster configurations — the students saw that resilience isn’t a checkbox. It’s a mindset. And with AI in the loop, systems don’t just recover from failure — they <strong>anticipate and adapt intelligently</strong>.</p><p>The questions kept coming: <em>“How does this scale across multiple clusters?”</em> <em>“Can the AI learn from security events too?”</em> <em>“What about compliance constraints in decision-making?”</em></p><p>These aren’t just academic questions — they’re the challenges that will define the next generation of infrastructure.</p><h3>Built on Industry Standards</h3><p>This hands-on demonstration leveraged production-ready tools from the cloud-native ecosystem: <a href="https://kagent.dev/">Kagent</a> for agentic AI operations, <a href="https://prometheus.io/">Prometheus</a> for metrics collection, <a href="https://grafana.com/">Grafana</a> for visualization, and <a href="https://prometheus.io/docs/alerting/latest/alertmanager/">Alertmanager</a> for intelligent alerting. By building on these established platforms, the students could see how AI-driven resilience integrates with existing observability and monitoring workflows.</p><h3>Open Source, Open Learning</h3><p>For those who want to experience this journey themselves, the complete hands-on environment is available as an open-source project: <a href="https://github.com/rsergio07/Distributed-Resilience">Distributed Resilience Demo on GitHub</a>.</p><p>The repository includes everything from the TEC session and more:</p><ul><li>Complete runbooks for both traditional and AI-driven scenarios</li><li>Offline-ready scripts for any network environment</li><li>Chaos engineering experiments and failure simulations</li><li>Cost calculation tools with real-world pricing models</li><li>Extensible architecture for production adaptation</li></ul><h3>Beyond the Demo</h3><p>If the engagement at TEC was any indication, the next generation of IT professionals isn’t just ready for AI-driven infrastructure — they’re eager to push its boundaries.</p><p>Because resilience is evolving. We’re moving from systems that survive failure to systems that learn from it, anticipate it, and turn it into an opportunity for optimization.</p><p>And after watching these students immediately grasp these concepts and start asking the right questions about production implementation, I’m confident that the future of intelligent infrastructure is in capable hands.</p><p><strong>Want to Learn More?</strong></p><p>If you’re building resilient systems or exploring AI-driven operations — or just curious about bringing these patterns into your own infrastructure — I’m happy to connect. You can find more about my work at my site <a href="https://rsergio.com/">https://rsergio.com</a></p><p>Let’s make intelligent resilience a design choice — not an afterthought.</p><h3>A message from our Founder</h3><p><strong>Hey, </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>Sunil</strong></a><strong> here.</strong> I wanted to take a moment to thank you for reading until the end and for being a part of this community.</p><p>Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? <strong>We don’t receive any funding, we do this to support the community. ❤️</strong></p><p>If you want to show some love, please take a moment to <strong>follow me on </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>LinkedIn</strong></a><strong>, </strong><a href="https://tiktok.com/@messyfounder"><strong>TikTok</strong></a>, <a href="https://instagram.com/sunilsandhu"><strong>Instagram</strong></a>. You can also subscribe to our <a href="https://newsletter.plainenglish.io/"><strong>weekly newsletter</strong></a>.</p><p>And before you go, don’t forget to <strong>clap</strong> and <strong>follow</strong> the writer️!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17f261ba81db" width="1" height="1" alt=""><hr><p><a href="https://aws.plainenglish.io/distributed-resilience-how-i-brought-agentic-ai-into-kubernetes-17f261ba81db">Distributed Resilience: How I Brought Agentic AI Into Kubernetes</a> was originally published in <a href="https://aws.plainenglish.io/">AWS in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Structure an 8-Day SRE Onboarding Plan to Cover Soft and Technical Skills]]></title>
            <link>https://aws.plainenglish.io/how-i-structure-an-8-day-sre-onboarding-plan-to-cover-soft-and-technical-skills-4b31b296be62?source=rss-0848394cfe61------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b31b296be62</guid>
            <category><![CDATA[sre]]></category>
            <category><![CDATA[mentorship]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[leadership]]></category>
            <dc:creator><![CDATA[Sergio Romero ]]></dc:creator>
            <pubDate>Thu, 07 Aug 2025 12:35:47 GMT</pubDate>
            <atom:updated>2025-09-18T01:34:46.607Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F62lsuEDheCqhdPaVc1YnQ.png" /></figure><p><em>Behind the scenes of a program designed to help new SREs succeed faster, with confidence and clarity</em></p><h3>Introduction</h3><p>When I transitioned into Site Reliability Engineering, I brought years of experience in IT, automation, and cloud infrastructure. But I still remember the feeling of starting from scratch — trying to find my footing in a fast-moving, high-responsibility environment.</p><p>Even with all my background, onboarding as an SRE was overwhelming. The tooling was complex. The expectations weren’t always clear. And the documentation was often scattered or outdated.</p><p>That experience stuck with me.</p><p>So when I got the opportunity to help design the onboarding experience for new SREs, I didn’t want to just create a checklist or a document to skim through on day one. I wanted to build an <em>actual onboarding journey</em> — one that gives engineers not only technical foundations but also the confidence, context, and human connection they need to thrive.</p><p>This is how I structured it.</p><h3>Why an Onboarding Plan Matters in SRE</h3><p>SRE is one of the most interdisciplinary roles in tech. A new hire might be expected to understand:</p><ul><li>Linux internals</li><li>Terraform and GitHub workflows</li><li>Cloud architecture</li><li>Monitoring and observability tools</li><li>Incident response</li><li>Compliance frameworks</li><li>And also… soft skills like documentation, collaboration, and prioritization</li></ul><p>If you throw all that at someone without a plan, even the most capable engineer will struggle.</p><p>A well-designed onboarding process reduces friction, accelerates ramp-up, and builds trust between the new engineer and the team.</p><p>And in my experience, <strong>blending soft skills with technical content makes all the difference</strong>.</p><h3>Designing the 8-Day SRE Onboarding Plan</h3><p>The plan I built is structured across <strong>eight days</strong>, balancing hands-on practice with high-level context and team alignment.</p><p>It’s modular, repeatable, and tailored for people coming from different backgrounds — including career changers and junior engineers.</p><p>Here’s a breakdown:</p><h3>Day 1 — Welcome and Foundations</h3><ul><li>Introduction to the team and mission of SRE</li><li>Overview of company culture, reliability mindset, and expectations</li><li>Git &amp; GitHub fundamentals (for those unfamiliar)</li><li>Emphasis on documentation, communication, and psychological safety</li><li>Setup of working environment and access credentials</li></ul><p><em>Focus:</em> Make new hires feel welcomed, oriented, and safe to ask questions.</p><h3>Day 2 — Infrastructure as Code</h3><ul><li>Hands-on session with Terraform: basic modules, variables, and state</li><li>Review of internal repositories and standards</li><li>Overview of CI/CD pipelines (GitHub Actions, Jenkins)</li><li>Demo of how changes move from code to production</li></ul><p><em>Focus:</em> Build confidence in making safe, observable infrastructure changes.</p><h3>Day 3 — Linux &amp; Cloud Fundamentals</h3><ul><li>Linux permissions, system logs, and troubleshooting tips</li><li>SSH keys, networking basics, and package management</li><li>AWS or hybrid cloud overview (IAM, VPC, EC2, tagging policies)</li><li>Common gotchas and cost-saving practices</li></ul><p><em>Focus:</em> Sharpen foundational skills and connect them to real operations.</p><h3>Day 4 — Monitoring &amp; Observability</h3><ul><li>Introduction to Prometheus and Grafana</li><li>Hands-on lab: visualize golden signals</li><li>Overview of alerting systems and Slack integrations</li><li>Exploration of what makes a good alert (signal vs noise)</li></ul><p><em>Focus:</em> Understand the difference between knowing something broke — and knowing <em>why</em>.</p><h3>Day 5 — Logging &amp; Incident Response</h3><ul><li>Overview of logging stacks (e.g., Loki, ELK)</li><li>Incident workflow walkthrough (roles, responsibilities)</li><li>Intro to blameless retrospectives and how to contribute</li><li>Golden rules of writing postmortems</li></ul><p><em>Focus:</em> Prepare new hires to respond calmly and constructively during incidents.</p><h3>Day 6 — Automation &amp; Housekeeping Pipelines</h3><ul><li>Intro to Ansible and task runners</li><li>Review of automated cleanup workflows (e.g., TTL-based EC2 cleanup)</li><li>Working with error handling and reporting</li><li>Slack alert formatting and pipeline messaging</li></ul><p><em>Focus:</em> Show how automation reduces toil — and how to design for safety.</p><h3>Day 7 — Security &amp; Compliance Basics</h3><ul><li>Overview of security tooling and policies</li><li>Access management, secrets rotation, EOL/EOSL asset workflows</li><li>FedRAMP, SOC 2, HIPAA context (as applicable)</li><li>SRE’s role in secure infrastructure and asset hygiene</li></ul><p><em>Focus:</em> Reinforce security as a shared responsibility, not just a checklist.</p><h3>Day 8 — Final Project Presentations</h3><ul><li>Each participant presents a mini-project or lab outcome</li><li>Live review, Q&amp;A, and feedback</li><li>Group reflection: “What did I learn?” / “What still confuses me?”</li><li>Wrap-up discussion and next steps (mentorship, buddy system, resources)</li></ul><p><em>Focus:</em> Build confidence, reinforce learning, and encourage ownership.</p><h3>Lessons I’ve Learned from Running This Plan</h3><ul><li><strong>Pacing matters.</strong> Don’t flood new hires with tools — build layers.</li><li><strong>Mentorship amplifies the plan.</strong> A plan is just content. What brings it to life is the mentor.</li><li><strong>Psychological safety is the foundation.</strong> The best onboarding outcomes come from environments where people feel comfortable asking “simple” questions.</li><li><strong>Soft skills are not optional.</strong> The ability to communicate, document, and collaborate is as important as knowing how to write a Helm chart.</li></ul><h3>Final Thoughts</h3><p>Onboarding isn’t about pushing people through a list of tools.</p><p>It’s about giving them the context to understand why those tools matter, the space to experiment, and the confidence to contribute meaningfully from day one.</p><p>If you want reliable systems, you need reliable people. And that starts with how we bring them in.</p><h3>Want to Learn More?</h3><p>If you’re building your own onboarding program — or just curious how to improve SRE ramp-up — I’m happy to connect. You can find more about this structure, my portfolio, and my mentoring work at <a href="https://rsergio.com/">my site</a> or on <a href="https://www.linkedin.com/in/romero-sergio/">LinkedIn</a>.</p><p>Let’s make onboarding a team priority — not just a checklist.</p><h3>A message from our Founder</h3><p><strong>Hey, </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>Sunil</strong></a><strong> here.</strong> I wanted to take a moment to thank you for reading until the end and for being a part of this community.</p><p>Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? <strong>We don’t receive any funding, we do this to support the community. ❤️</strong></p><p>If you want to show some love, please take a moment to <strong>follow me on </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>LinkedIn</strong></a><strong>, </strong><a href="https://tiktok.com/@messyfounder"><strong>TikTok</strong></a>, <a href="https://instagram.com/sunilsandhu"><strong>Instagram</strong></a>. You can also subscribe to our <a href="https://newsletter.plainenglish.io/"><strong>weekly newsletter</strong></a>.</p><p>And before you go, don’t forget to <strong>clap</strong> and <strong>follow</strong> the writer️!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b31b296be62" width="1" height="1" alt=""><hr><p><a href="https://aws.plainenglish.io/how-i-structure-an-8-day-sre-onboarding-plan-to-cover-soft-and-technical-skills-4b31b296be62">How I Structure an 8-Day SRE Onboarding Plan to Cover Soft and Technical Skills</a> was originally published in <a href="https://aws.plainenglish.io/">AWS in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mentorship in SRE: Why Sharing Your Knowledge Is the Best Investment]]></title>
            <link>https://aws.plainenglish.io/mentorship-in-sre-why-sharing-your-knowledge-is-the-best-investment-db9045751a14?source=rss-0848394cfe61------2</link>
            <guid isPermaLink="false">https://medium.com/p/db9045751a14</guid>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[training]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[mentorship]]></category>
            <dc:creator><![CDATA[Sergio Romero ]]></dc:creator>
            <pubDate>Thu, 17 Jul 2025 17:38:15 GMT</pubDate>
            <atom:updated>2025-09-18T01:34:51.242Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_h7jymvrkh6-eJfN5x4ZUQ.png" /></figure><p><em>How mentoring others helped me grow as an engineer, a leader, and a human being</em></p><h3>Introduction</h3><p>When I think back to some of the most pivotal moments in my career, they rarely involved certifications, new job titles, or major technical wins. What I remember most vividly are conversations — mentorship moments where someone guided me, challenged me, or simply listened.</p><p>For a long time, I saw mentorship as something that happened later in your career — when you had “enough” experience to give back. But over time, I’ve learned that mentorship isn’t a one-way street, and it certainly isn’t something you need to wait for permission to do.</p><p>In fact, <strong>mentorship has been one of the most valuable investments I’ve made — not only in others, but in myself.</strong></p><p>As a Senior Site Reliability Engineer, I’ve had the opportunity to mentor junior engineers, career changers, high school students, and new SREs. But what I didn’t expect was how much it would transform me as an engineer and as a leader.</p><h3>How It Started: A Pattern of Mentorship Before the Title</h3><p>Long before I had a formal mentorship title, I was already mentoring.</p><p>I supported women transitioning into tech through the <em>Career Conversation</em> program between IBM and CINDE — helping them translate their strengths into new careers, often from completely non-technical backgrounds. I shared what I knew about the industry, helped them map possible career paths, and gave them a sounding board as they explored unfamiliar territory.</p><p>Inside engineering teams, I was often the one answering questions on Slack, walking teammates through Terraform, or demystifying how our observability stack worked. I didn’t wait to be asked — I leaned in where I saw a gap.</p><p>So when I joined IBM’s SRE organization and noticed the lack of a clear onboarding path, I didn’t hesitate. I built a structured two-week onboarding program from the ground up, combining technical topics with soft skills like collaboration, documentation, and the reliability mindset.</p><p>That program caught attention. Soon after, I was invited to join the core team behind the SRE Academy — a four-month, hands-on learning experience designed to help aspiring SREs succeed, especially those coming from non-traditional paths.</p><p>There, I helped shape the curriculum, built labs, led sessions, and mentored dozens of future engineers. But none of that happened by accident. It was the continuation of a journey I had already started years earlier: building others up, one conversation at a time.</p><h3>Why Mentorship Matters in SRE</h3><p>Site Reliability Engineering is often viewed as a deeply technical discipline. And yes, it is. But under the hood, SRE is about <strong>shared ownership, psychological safety, and learning from failure.</strong> Those things don’t happen in isolation. They require culture. And culture is built through people.</p><p>Mentorship is what sustains that culture.</p><p>Here’s why mentorship is essential in SRE teams:</p><ul><li><strong>It accelerates onboarding and reduces burnout.</strong><br>New SREs often face a steep learning curve. Having someone to guide them — especially through systems, tooling, and expectations — can make the difference between thriving and drowning.</li><li><strong>It spreads reliability knowledge beyond the ‘heroes’.</strong><br>When knowledge lives only in senior engineers, systems become fragile. Mentorship helps distribute operational knowledge, creating teams that are resilient — not just individuals.</li><li><strong>It sharpens your own thinking.</strong><br>Every time I teach something, I understand it better. Mentoring forces you to slow down, articulate assumptions, and re-examine why things are done a certain way.</li><li><strong>It builds trust.</strong><br>Reliability isn’t just built in code. It’s built in relationships. Mentorship creates trust, and trust leads to better collaboration during high-stakes moments — like incidents and postmortems.</li></ul><h3>What I’ve Learned by Being a Mentor</h3><p>Mentoring others has taught me lessons that no certification or book ever could. Here are a few:</p><h4>1. You don’t need to know everything.</h4><p>Early on, I hesitated to mentor because I thought, “What if they ask something I can’t answer?” But the truth is, mentorship isn’t about having all the answers — it’s about being <em>willing to explore them together</em>.</p><h4>2. Listening is more powerful than fixing.</h4><p>Some of the most impactful mentoring moments I’ve had weren’t about solving technical problems — they were about understanding someone’s blockers, fears, or frustrations. Listening is a skill, and mentoring develops it.</p><h4>3. Imposter syndrome doesn’t disappear — it evolves.</h4><p>Even as a Senior SRE, I still wonder whether I’m doing enough, or whether my advice is “good enough.” But seeing mentees grow is the best antidote to that self-doubt. It reminds me that <em>we all start somewhere</em>.</p><h4>4. You grow when you teach.</h4><p>Mentoring has pushed me to get better at documentation, architecture reviews, onboarding flows, and even public speaking. It’s forced me to turn personal habits into team practices — and that has made me more effective.</p><h3>A Few Real Examples</h3><ul><li>I’ve mentored newcomers to SRE through structured programs, helping them understand CI/CD pipelines, Terraform modules, and monitoring best practices from day one.</li><li>I’ve supported high school students building their first robotics projects — teaching them how to document code and turn a school challenge into a personal portfolio.</li><li>I’ve guided mid-career professionals transitioning into SRE, helping them map their transferable skills and gain confidence in a new technical landscape.</li></ul><p>These experiences aren’t side projects. They are a core part of my work — and my growth.</p><h3>Final Thoughts</h3><p>Mentorship isn’t just a way to give back. It’s a way to <strong>invest forward</strong> — in others, in your team, and in yourself.</p><p>It’s how we scale reliability, not just across systems, but across people.</p><p>And here’s what I’ve found to be true again and again: the more I mentor, the more I grow. Not despite the time it takes — but <em>because of it</em>.</p><h3>Let’s Connect</h3><p>If you’re just starting out in SRE — or thinking about mentoring others — I’d love to hear from you. You can read more about how I structure mentorship and onboarding at my <a href="https://rsergio.com/">portfolio</a>, or connect with me on <a href="https://www.linkedin.com/in/romero-sergio/">LinkedIn</a>.</p><h3>A message from our Founder</h3><p><strong>Hey, </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>Sunil</strong></a><strong> here.</strong> I wanted to take a moment to thank you for reading until the end and for being a part of this community.</p><p>Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? <strong>We don’t receive any funding, we do this to support the community. ❤️</strong></p><p>If you want to show some love, please take a moment to <strong>follow me on </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>LinkedIn</strong></a><strong>, </strong><a href="https://tiktok.com/@messyfounder"><strong>TikTok</strong></a>, <a href="https://instagram.com/sunilsandhu"><strong>Instagram</strong></a>. You can also subscribe to our <a href="https://newsletter.plainenglish.io/"><strong>weekly newsletter</strong></a>.</p><p>And before you go, don’t forget to <strong>clap</strong> and <strong>follow</strong> the writer️!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db9045751a14" width="1" height="1" alt=""><hr><p><a href="https://aws.plainenglish.io/mentorship-in-sre-why-sharing-your-knowledge-is-the-best-investment-db9045751a14">Mentorship in SRE: Why Sharing Your Knowledge Is the Best Investment</a> was originally published in <a href="https://aws.plainenglish.io/">AWS in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From IT to SRE: My Journey and the Skills That Made It Possible]]></title>
            <link>https://aws.plainenglish.io/from-it-to-sre-my-journey-and-the-skills-that-made-it-possible-76398dfd185d?source=rss-0848394cfe61------2</link>
            <guid isPermaLink="false">https://medium.com/p/76398dfd185d</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[mentorship]]></category>
            <dc:creator><![CDATA[Sergio Romero ]]></dc:creator>
            <pubDate>Thu, 03 Jul 2025 18:46:05 GMT</pubDate>
            <atom:updated>2025-09-18T01:34:55.406Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p0bIkkp6ZKUBPa4Ujb0ZBA.png" /></figure><p><em>How I transitioned from classic IT to Site Reliability Engineering by following my curiosity, embracing automation, and rethinking what success really meant</em></p><h3>Introduction</h3><p>If you had told me years ago that I’d one day be leading global onboarding programs for SREs, automating infrastructure with Terraform, and mentoring engineers worldwide — I probably would’ve smiled politely and gone back to troubleshooting a server issue.</p><p>Like many people in tech, I didn’t start in SRE. My path took time — and detours. I began in traditional IT support roles and slowly advanced into Level 2 support, virtualization, and eventually worked as a Solution Architect. For a while, I thought <em>that</em> was the pinnacle of a technical career.</p><p>But something didn’t feel right.</p><p>Despite the title and scope, I realized I wasn’t enjoying the architect role. I missed the hands-on problem-solving. The speed. The building. That moment led me to re-evaluate my direction — and that’s when I discovered Site Reliability Engineering. Not long after, I joined VMware as an SRE, and eventually returned to IBM in a senior SRE role.</p><p>This is the story of that transformation — and the skills that made it possible.</p><h3>Step 1: From Classic IT to Systems Thinking</h3><p>My early career revolved around classic IT. I worked across global companies like <strong>Sykes</strong>, <strong>HP</strong>, <strong>VMware</strong>, and <strong>IBM</strong>, holding roles that spanned help desk, Linux system administration, and infrastructure support.</p><blockquote><em>What I didn’t realize at the time was that I was building the foundations of reliability thinking — understanding system behavior, troubleshooting under pressure, and learning to deliver support across complex, distributed environments.</em></blockquote><p>Over time, I moved into <strong>Level 2 support</strong> and <strong>virtualization platforms</strong>, expanding my scope and deepening my understanding of enterprise systems. Those years taught me:</p><ul><li>How to work under fire (and remain calm)</li><li>The importance of monitoring and patterns</li><li>Why root cause isn’t just technical — it’s systemic</li></ul><p>It also taught me that manual work scales poorly. And that the real value lies in building systems that don’t need constant intervention.</p><h3>Step 2: Discovering Automation and Infrastructure-as-Code</h3><p>The real shift came when I started automating small tasks — first with Bash, then with Ansible. That experimentation turned into something bigger: Terraform, GitLab CI/CD pipelines, infrastructure pipelines, and full automation of on-demand environments.</p><p>One of my most impactful initiatives was leading the automation of a multi-tenant lab platform, reducing deployment time from <strong>2–3 days to just 15 minutes</strong>. It was a game-changer — not just technically, but mentally. I was no longer firefighting — I was <strong>designing for resilience</strong>.</p><blockquote><em>Automation wasn’t just about speed. It was about freeing engineers from toil, enabling consistency, and shifting reliability from reactive to proactive.</em></blockquote><p>This stage also involved creating internal housekeeping pipelines to clean up AWS resources automatically and safely, integrating Slack alerts and Terraform logic to avoid costly manual errors.</p><p>These were the kinds of problems I wanted to solve. And SRE was the role where I could do it full time.</p><h3>Step 3: Moving into Cloud, Scale, and Systems Design</h3><p>As I stepped deeper into cloud infrastructure, I began working in hybrid and cloud-native environments. I led cloud cost optimization efforts, improved infrastructure observability, and built feedback loops into every part of the system lifecycle.</p><p>I didn’t just learn new tools — I learned to think differently:</p><ul><li>Infrastructure is ephemeral</li><li>Everything should be versioned and observable</li><li>Failures aren’t just expected — they’re part of the design</li></ul><p>This stage pushed me to pursue <strong>relevant certifications</strong> in areas like <strong>AWS</strong>, <strong>Linux</strong>, <strong>Kubernetes (CKA)</strong>, and even <strong>AI</strong>, ensuring I had both the technical knowledge and the confidence to operate in fast-evolving environments.</p><p>I also gained a deeper appreciation for observability, not just as a monitoring function — but as a key enabler for debugging, scaling, and continuous improvement.</p><h3>Step 4: Becoming — and Growing — as an SRE</h3><p>When I transitioned to a formal SRE role at VMware, it felt like I had finally found a discipline that blended everything I enjoyed:</p><ul><li>Building and fixing systems</li><li>Collaborating across functions</li><li>Thinking about <em>reliability</em> as a design goal, not a metric</li></ul><p>Eventually, I returned to IBM — this time as a <strong>Senior SRE</strong>, focusing on automation pipelines, cost optimization, security automation, and technical mentoring. But perhaps my most fulfilling role has been shaping the <strong>SRE onboarding journey</strong> for others.</p><p>I designed and led a structured <strong>8-day onboarding program</strong>, blending soft skills (communication, ownership, documentation) with technical topics like Git, observability, CI/CD, Terraform, and more. It’s now part of a broader SRE Academy that I help lead globally.</p><h3>Skills That Made the Transition Possible</h3><p>Here are the core competencies that helped me make the leap from IT into SRE — and thrive in it:</p><p><strong>Skill</strong> <strong>How It Helped Me</strong> <strong>Systems Thinking</strong> Solving problems at the root, not just the surface <strong>Automation</strong> Eliminating toil and building consistent, reusable processes <strong>Cloud Architecture</strong> Designing systems that scale and fail gracefully <strong>Observability</strong> Making systems transparent and actionable <strong>Documentation</strong> Sharing knowledge at scale and creating reusable onboarding content <strong>Mentorship &amp; Teaching</strong> Empowering others while reinforcing my own understanding</p><h3>Final Thoughts</h3><p>I didn’t take a shortcut to become an SRE. I took the long, winding road — learning what <em>not</em> to do, hitting roadblocks, saying yes to challenges that scared me, and choosing to reinvent myself when comfort was holding me back.</p><p>And I’m still learning.</p><p>The best part of the SRE journey is that it never really ends — there’s always a new system to improve, a teammate to support, a process to rethink.</p><blockquote><em>If you’re in IT today and wondering whether SRE is right for you, here’s what I’d say: </em><strong><em>If you’re curious, proactive, and committed to learning — you’re already halfway there.</em></strong></blockquote><h3>Let’s Connect</h3><p>Want to explore this transition yourself?<br>Check out my <a href="https://rsergio.com/">portfolio</a>, or feel free to connect with me on <a href="https://www.linkedin.com/in/romero-sergio/">LinkedIn</a>.</p><h3>A message from our Founder</h3><p><strong>Hey, </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>Sunil</strong></a><strong> here.</strong> I wanted to take a moment to thank you for reading until the end and for being a part of this community.</p><p>Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? <strong>We don’t receive any funding, we do this to support the community. ❤️</strong></p><p>If you want to show some love, please take a moment to <strong>follow me on </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>LinkedIn</strong></a><strong>, </strong><a href="https://tiktok.com/@messyfounder"><strong>TikTok</strong></a>, <a href="https://instagram.com/sunilsandhu"><strong>Instagram</strong></a>. You can also subscribe to our <a href="https://newsletter.plainenglish.io/"><strong>weekly newsletter</strong></a>.</p><p>And before you go, don’t forget to <strong>clap</strong> and <strong>follow</strong> the writer️!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76398dfd185d" width="1" height="1" alt=""><hr><p><a href="https://aws.plainenglish.io/from-it-to-sre-my-journey-and-the-skills-that-made-it-possible-76398dfd185d">From IT to SRE: My Journey and the Skills That Made It Possible</a> was originally published in <a href="https://aws.plainenglish.io/">AWS in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>