Weak coding skills can hinder senior SRE roles but are manageable with targeted upskilling and leveraging existing strengths.

Problem Context

In senior platform/SRE roles, coding is rarely about writing apps from scratch. It’s about automating repetitive tasks, debugging systems under pressure, and extending platform capabilities. Weak coding skills slow you down in these areas, especially when troubleshooting or integrating tools.

Diagnosis

1. Assess gaps: Can you write a script to parse logs, automate a deployment, or debug a failing container?
2. Role alignment: If targeting pure SRE roles, scripting (Bash/Python) and API usage are critical. For platform engineering, deeper Kubernetes/OpenShift customization (Operators, controllers) may be required.
3. Self-audit: Run through common tasks:

   # Example: Debug a failing pod  
   kubectl describe pod <pod-name>  
   # Example: Write a script to rotate logs older than 7 days  
   find /var/log -name "*.log" -mtime +7 -exec rm {} \;  
   

Repair Steps

1. Prioritize scripting over syntax: Focus on languages used in your stack (Python for automation, Go for deeper Kubernetes work).
2. Build practical projects:
   • Automate a manual process (e.g., backup/restore for a namespace).
   • Write a script to alert on resource thresholds using Prometheus APIs.
3. Leverage existing strengths: Use observability skills to instrument your code. For example, add metrics to a script and visualize them in Grafana.

Prevention

• Maintenance routine: Dedicate 2-3 hours weekly to coding practice. Use real-world problems (e.g., fix a broken CI pipeline).
• Pair programming: Work with devs to understand their pain points and how your platform can ease them.

Policy Example

Personal Development Plan

1. Weekly: Complete 1 LeetCode Medium problem (focus on algorithms used in systems programming).  
2. Monthly: Build and deploy a small tool (e.g., a Prometheus exporter for a custom metric).  
3. Quarterly: Contribute to an open-source project (fix a bug in a Kubernetes operator).  

Tooling

• Editors: VS Code with Kubernetes/OpenShift extensions.
• CLI: Master kubectl, oc, helm, and terraform.
• Testing: Use kind or minikube for local Kubernetes testing.
• Debugging: strace, kubectl debug, and sysdig.

Tradeoffs

• Time vs. depth: Focusing on scripting (Python/Bash) gives quicker wins than learning Go for Operators. But deeper work may require the latter.
• Automation vs. understanding: Scripting can mask gaps in fundamentals. Balance automation with learning how systems actually work.

Troubleshooting

• Common failure: Over-reliance on GUIs. Fix: Force yourself to use CLI-only for a week.
• Stuck on debugging: Start with kubectl describe and logs. If stuck, use kubectl get events --sort-by=.metadata.creationTimestamp to trace recent issues.
• Script fails in production: Add error handling and logging. Example:

  import logging  
  logging.basicConfig(filename='app.log', level=logging.INFO)  
  try:  
      # code  
  except Exception as e:  
      logging.error(f"Failed: {e}")  
  

Weak coding skills aren’t a career blocker, but they require deliberate practice. Focus on tools and tasks that directly impact your ability to ship and maintain systems reliably.

Source thread: 18 yrs in observability/SRE-adjacent work, contract ending Dec, but my actual coding is weak — how bad is this really for the roles I’m targeting?