Skip to content

DevOps · Cloud · Full-Stack

I run production, and I write the code on it.

Four and a half years as the DevOps and backend engineer behind live products. Kubernetes on AWS EKS serving millions of requests a day, ECS microservices behind a platform with 100,000+ users, and the Node.js services running on top of all of it.

one request · six layers · one engineer

One request, top to bottom

  1. Browser
  2. CDN
  3. ALB
  4. Cluster
  5. App
  6. Data

This page follows that path. Every stop is a layer I am responsible for, and the thing that tends to break there. Pick one and it will take you straight to it.

  • Kubernetes
  • AWS EKS
  • ECS
  • Terraform
  • ArgoCD
  • Jenkins
  • GitHub Actions
  • Prometheus
  • Grafana
  • CloudFront
  • Node.js
  • NestJS
  • Next.js
  • PostgreSQL
  • Redis
  • Elasticsearch
  • Socket.io
  • Docker
  • Nginx
  • Flutter
requests a day
Millions

Kubernetes on AWS EKS

users on ECS
100K+

microservices behind one platform

CI/CD toolchains
4

Jenkins, ArgoCD, CircleCI, CodePipeline

app stores
3

iOS, Android, macOS, signed and notarised

The path

Six layers. Six ways to lose a night.

Most engineers own one or two of these. The expensive bugs live in the gaps between them, where neither side is looking.

  1. The edge

    DNS · TLS · CDN

    Where the request arrives, and where it quietly dies.

    Route 53, CloudFront and ACM certificates in front of everything. Cache headers I set on purpose instead of inheriting whatever the framework does, TLS at the edge, and certificate renewals on a schedule so nobody meets them for the first time on a Sunday.

    Nothing changed. The certificate expired. It is always a Sunday, and it is never in the deploy log.

    CERTIFICATE VALIDITYmontuewedthufrisatsunDEPLOY LOGnothing shipped. it expired on its own.
    • CloudFront
    • Route 53
    • ACM
    • Nginx
    • SSL/TLS
    time here14%
  2. The load balancer

    ALB · target groups · health checks

    The layer that decides whether the fleet lives.

    Application load balancers with target groups, health check paths chosen carefully, and autoscaling policies tuned from measured peak traffic rather than a round number somebody picked in a meeting.

    If the health check path touches the database, one slow query drains the whole fleet at once.

    ALBhealthtarget 1target 2target 3target 4dbone slow query4 of 4 unhealthy. the app itself is fine.
    • ALB
    • Target groups
    • Autoscaling
    • Route 53
    time here18%
  3. The cluster

    Kubernetes · ECS · Terraform

    Kubernetes when it earns it. Not before.

    EKS clusters serving millions of requests a day, and ECS microservices behind a platform with 100,000+ users. Cluster design, HPA and Cluster Autoscaler, Helm charts, ECR, and GitOps delivery through ArgoCD so a bad release is one reverted commit. All of it defined in Terraform.

    Every rung up the ladder costs you a person. That is the real price, not the AWS bill.

    compose1 on callecs2 on callkubernetes4 on callthe bill is the cheap part.
    • Kubernetes (EKS)
    • ECS
    • Fargate
    • Terraform
    • Helm
    • ArgoCD
    • Docker
    • ECR
    time here26%
  4. The application

    Node.js · Next.js · React

    I write this part too.

    Node.js and Express services, REST APIs, Socket.io streaming live market data, Next.js with SSR on the front, React admin dashboards behind it. On my own product it is NestJS on Fastify with Prisma and PostgreSQL, and a Flutter app talking to it.

    One un-awaited promise blocks the event loop, and every user waits for one user's request.

    QUEUEreq 1 waitingreq 2 waitingreq 3 waitingreq 4 waitingreq 5 waitingeventloopone un-awaited promise
    • Node.js
    • Express
    • NestJS
    • Socket.io
    • Next.js
    • React
    • Flutter
    time here21%
  5. The data

    PostgreSQL · Redis · Elasticsearch

    Connections, not queries.

    PostgreSQL on RDS with replicas, Redis on ElastiCache for caching and pub/sub, Elasticsearch powering search across large catalogues. Schema design, replication, caching strategy and query tuning that holds under sustained production load.

    pool size × replicas quietly passes max_connections. It works perfectly right up until you scale out.

    4 replicas x pool 25 = 100 connectionsmax_connections 70refused connectionsit works perfectly right up until you scale out.
    • PostgreSQL
    • MySQL
    • Redis
    • Elasticsearch
    • RDS
    time here13%
  6. The machine

    Linux · Nginx · PM2

    The boring floor everything else stands on.

    Linux servers across the estate. Nginx reverse proxy with SSL termination and load balancing, PM2 process supervision, systemd units, log rotation, SSH access control and hardening. The layer nobody budgets for and everybody depends on.

    Logs fill the disk, and the app dies of something that has nothing to do with the app.

    DISK100%osappdata/var/logthe app did nothing wrong. it just had nowhere left to write.exit code 137killed, out of space
    • Linux
    • Nginx
    • PM2
    • systemd
    • Bash
    • SSH
    time here8%

The cluster

What autoscaling actually looks like.

One application, six workloads, and the two statefulsets that hold the state. Only the socket service moves. That last part is the whole design.

Splitting workloads so a spike stays contained is the difference between one busy service and an outage. Get it wrong and a single hot pod exhausts shared capacity and takes the platform with it.

  • EKS
  • ArgoCD
  • HPA
  • StatefulSets
  • Redis
  • Elasticsearch
  • Helm
anonymousproductionSyncedDegraded
  • inganonymous-alb3 rules
  • deployrealtime6 / 6
    rsrealtime-5b1ahpa6 / 2-8 · cpu 58%svcsticky
  • deployapi4 / 4
    rsapi-7d9f4chpa4 / 2-10 · cpu 38%svcClusterIP
  • deployworker2 / 2
    rsworker-2c7e91cmworker-config
  • stsredis3 / 3
    pvcgp3 8Gi x3svcheadless
  • stselasticsearch3 / 3
    pvcgp3 100Gi x3svcClusterIP

realtime-5b1a-q8vn CrashLoopBackOff. redis connection refused.

18 pods

On-call

Where a two hour incident actually goes.

I timed one properly out of curiosity, then timed four more. The numbers were consistent enough to change how I work.

  • Noticing at all18m
  • Working out what broke45m
  • Fixing it6m
  • Verifying and watching20m
  • Telling everyone12m
  • Writing it up30m

The fix is the smallest bar. It always is. If you want shorter incidents, do not get faster at fixing. Get faster at noticing and at working out what broke.

Your turn

Take the pager for eight alerts.

A short game made from real incidents. Read the curl and the kubectl output, pick what broke, 25 seconds each. Every answer comes with the fix I shipped.

Mon 02:44 · Alertmanagerredis-0 restarted 14 times in 1hWhat is the real fix?25s

Release engineering

One tag. Three stores. No manual signing.

The part that actually breaks releases is not the code. It is certificates, provisioning profiles, notarisation and store compliance.

iOS

App Store Connect
  1. 01Xcode Cloud
  2. 02Signing
  3. 03TestFlight
  4. 04App Store

Android

Play Console
  1. 01Signed AAB
  2. 02Upload key
  3. 03Internal track
  4. 04Staged rollout

macOS

Direct distribution
  1. 01Universal binary
  2. 02Developer ID
  3. 03Notarisation
  4. 04Signed DMG

I also set up and run the store accounts themselves. App Store Connect and Google Play Console from first enrolment onward: team roles, app records, bundle IDs, signing certificates, API keys for automated uploads, and the review submissions after.

How it went

Four and a half years, from DevOps to the whole stack.

  1. 2021

    Professional Web Development

    Shree Academy, Rajkot

    Six months, graded A. Where the foundation got built.

  2. 2022

    Joined on the DevOps side

    TST Technology, Ahmedabad

    AWS, Docker, CI/CD. First pipelines, first on-call.

  3. 2023

    Built the backends too

    Node.js, Express, schema design

    Started writing the services I was deploying.

  4. 2024

    Kubernetes and scale

    EKS, ECS, Terraform, ArgoCD

    Millions of requests a day. GitOps delivery. Infrastructure as code.

  5. 2025

    Release engineering

    iOS, Android, macOS

    Store accounts, signing, notarisation, staged rollouts.

  6. 2026

    Senior DevOps & Full-Stack Engineer

    Sole or lead infra engineer across the portfolio

    And shipping Anonymous India, my own product, solo.

What I believe

Six rules I did not have on day one.

Each of these replaced something I used to think. The ones that sound obvious are the ones that cost the most.

  1. Climb only when the rung below actually hurts.

    One EC2 box with systemd is not embarrassing. Moving to a cluster before the current setup causes real pain buys you complexity you then have to run.

  2. An alert that never needs action is not monitoring.

    It is noise with a pager attached. Muting the one that fires nightly is not laziness, it is the work. The rest only mean something once the noise is gone.

  3. You do not have backups until you have timed a restore.

    Everyone asks whether backups exist. Almost nobody asks how long the restore takes, and only one of those questions matters at 3 AM.

  4. Containment beats capacity.

    One service spiking should never be able to take the other three with it. Splitting workloads so a spike stays where it started is most of what reliability actually is.

  5. Write it down the same day, while it still hurts.

    A runbook written a week later is missing the part you only knew at 2 AM. Being the only person who understands something is not job security, it is a bill somebody pays later.

  6. The boring things are the ones that worked.

    Four and a half years of this and the changes that genuinely moved reliability were unglamorous. The exciting migrations mostly moved the problem somewhere new.