Platform / DevOps Engineer
● Open to opportunities
Focused on Kubernetes, scalable systems, and building reliable infrastructure. Currently working towards Kubestronaut.
● Open to opportunities
Focused on Kubernetes, scalable systems, and building reliable infrastructure. Currently working towards Kubestronaut.
Problem
Under load, apps became unresponsive. No HPA initially.
Even after scaling, traffic didn't distribute as expected and pods
(~1.5-2min startup on Fargate) came too late.
What I did
Introduced HPA and redesigned load testing to include scaling behavior.
Identified that CPU/memory signals lag real traffic patterns.
Outcome
HPA improved stability (~80%), but spike loads still broke the system.
Realization: pre-scaling and event-driven scaling were required.
Learning
Autoscaling is reactive, not instantaneous.
For bursty or async workloads, CPU/memory are weak signals of demand.
Scaling decisions must align with how the workload behaves, not just
what metrics are available.
Problem
Dozens of microservices had separate pipelines. Any change meant
updating every repo - and missed updates were discovered late.
What I did
Initially tried scripting updates across repos (didn't scale).
Moved to shared pipeline libraries and reduced flows into ~3–4
standard patterns.
Outcome
Pipeline changes became centralized. New services only needed a
minimal import - no pipeline setup/testing overhead.
Learning
Automating repeated tasks is not the same as solving duplication.
If duplication exists, automate-after-abstraction - not before.
Problem
Ephemeral CI runners (DIND) needed frequent updates with strict
security constraints. Using Alpine reduced vulnerabilities, but
introduced issues (musl + unofficial Node support).
What I did
Built an internal CLI to generate/update runner images with required
dependencies (Node, Helm, etc.) via arguments.
Outcome
Removed manual image maintenance and made updates repeatable under
security constraints.
Learning
When constraints stack (security, compatibility, tooling), pipelines
become brittle. Encapsulating complexity in a dedicated tool is often
more stable than pushing it into CI logic.
Problem
AI workloads (file uploads, async processing) didn't scale well with
HPA. CPU/memory signals didn't reflect actual pressure.
What I did
Analyzed scaling gaps during load tests and explored alternatives
beyond HPA/VPA.
Outcome
Identified that event-driven scaling (e.g., KEDA) fits the workload
better, even though not implemented at the time.
Learning
Choosing the wrong scaling signal is worse than no scaling.
The real problem wasn't tuning HPA - it was assuming the problem fit
HPA at all.
Problem
Manual onboarding across tools took 2–3 days per request.
What I did
Automated onboarding using tool APIs into a self-service flow.
Outcome
Reduced setup time to under 5 minutes.
Learning
Most developer friction isn't technical - it's process latency.
Understanding why containers change how we think about processes and systems.
Read →
Using dig to break down DNS step-by-step and understand what's happening.
Read →
Building a mental model of Git instead of memorizing commands.
Read →
Open to discussions around DevOps, Kubernetes, platform engineering, and interesting technical problems.
Pick a time that works for you.