Available for backend & infrastructure work
Backend & DevOps engineer specializing in Go, Kubernetes, cloud infrastructure, and automation — designing systems that stay up, scale predictably, and fail safely.
Jahir Raihan
Backend & DevOps Engineer · CloudKops
About
I'm a backend engineer who spends most of my time in the layer users never see — the services, queues, and clusters that decide whether an application stays up under load or falls over quietly at 2 a.m. Over the past four years that's meant designing APIs in Go and Spring Boot, containerizing them, and running them on Kubernetes across AWS, GCP, and OCI.
What actually holds my attention isn't a specific framework — it's the failure modes: a service that can't recover from a dependency timeout, a deployment pipeline that can't roll back safely, an autoscaler tuned for the wrong signal. I care about tracing those problems back to root cause, then automating the fix so it doesn't recur.
That mindset shows up in how I build: infrastructure defined as code with Terraform, delivery pipelines that fail loudly instead of silently, and dashboards that tell you something is wrong before a customer does. Less about shipping more code, more about shipping systems that keep working.
Core Expertise
From the API layer down to the cluster it runs on — I work across the full stack of a production backend, not just the parts that are easy to demo.
Services and APIs designed for correctness under concurrency and load.
Infrastructure as code, provisioned and reproducible across providers.
Pipelines and observability that catch problems before customers do.
System design decisions that hold up as traffic and teams grow.
Featured Projects
A mix of open-source tooling and production backends — each one built to solve a specific operational problem, not to fill out a portfolio.
Open-source Kubernetes security scanner
A CLI tool written in Go that scans Kubernetes clusters for misconfigurations, RBAC risks, and drift from security baselines — built for teams that want CIS-style checks without a heavyweight platform.
Highlights
Provision infrastructure across AWS, GCP, and OCI
A unified provisioning layer that wraps Terraform modules behind a single API, letting teams request compute, networking, and storage across three cloud providers without hand-writing HCL for each one.
Highlights
Backend APIs for large-scale hackathon operations
A microservices backend that runs registration, voting, judging, and notifications for multi-day technical events — designed to hold up under registration spikes and real-time judging traffic.
Highlights
Engineering Philosophy
Engineering isn't about writing code — it's about building systems you can trust at 3 a.m. Every project I take on runs through the same loop: understand the real behavior of the system, ship something small enough to verify, measure what actually happens in production, and use that evidence to decide what to fix next. Automation exists to make the good outcome the default one, not to remove judgment — just the need to repeat it manually. The loop never really finishes; it just resets at a more reliable baseline each time.
Understand the system as it actually behaves — not as the diagram claims.
Ship the smallest version that proves the design under real conditions.
Instrument it. An unmeasured system is a guess wearing a uniform.
Fix the bottleneck the data points to, not the one that's easiest to fix.
Turn the fix into a pipeline, a policy, or an alert — so a human isn't the safeguard.
Systems drift. The loop doesn't close — it just starts again at a higher baseline.
Writing
Long-form write-ups on the infrastructure and backend problems I run into most — published as they're ready, not on a schedule.
Tracing the kubelet's decision path from resource pressure to eviction, and what that means for how you set requests and limits.
Draft · in progressWhy treating ctx.Done() as your error strategy leads to goroutine leaks, and a pattern for separating the two concerns.
Draft · in progressUsing build stages to isolate secrets, speed up CI caching, and produce reproducible artifacts across environments.
Draft · in progressWhat it actually takes to make retried requests safe end-to-end — storage, TTLs, and the failure modes people miss.
Draft · in progressDesigning CI/CD so a rollback is a tested, one-command action instead of an improvised response during an incident.
Draft · in progressHow to avoid the common pitfalls of metrics collection, aggregation, and visualization that lead to misleading dashboards.
Draft · in progressOpen Source
I maintain tooling publicly because infrastructure problems are rarely unique to one company — a scanner or automation layer built well once should be reusable by anyone running the same stack.
Synced from GitHub
Public repositories
Synced from GitHub
Contributions (last 12mo)
Synced from GitHub
Stars earned
Synced from GitHub
Languages used
I open-source tools that solve a problem I've hit more than once — favoring a small, well-documented CLI over a sprawling platform. Issues and PRs get triaged the same way I'd treat a production ticket: reproduce it, understand the root cause, then fix it in a way that holds up for the next person who hits it.
A Kubernetes security scanner written in Go — misconfiguration detection, RBAC analysis, and CI-friendly JSON output in a single binary.
Tech Stack
Not an exhaustive list — the languages, runtimes, and infrastructure I use often enough to trust deeply.
Go 
Java 
Docker 
Kubernetes 
Terraform 
Ansible 
AWS 
GCP 
GitHub Actions 
Jenkins 
PostgreSQL 
Redis 
Kafka 
Grafana 
Prometheus 