srinath-r · devops

Srinath R

DevOps Engineer · Kubernetes, GitOps, observability

I help ship changes to live trading platforms almost every evening after the market closes, and I own the monitoring that shows what they're doing while it's open.

Open to DevOps, SRE and Platform roles · Chennai · Bengaluru · Mumbai
illustrative · release after 15:30 IST market close
$ argocd app sync trading-api
$ kubectl rollout status deploy/api -n trading
Waiting for deployment "api" rollout to finish:
  2 of 3 updated replicas are available...
deployment "api" successfully rolled out
$ ▍
~67%lower monitoring cost after moving off New Relic
13microservices on Quantman, the platform I help deploy
13high-severity VAPT findings closed
~15 GBof production logs a day, searchable for 30 days
whoami

About

DevOps engineer on retail trading platforms, based in Coimbatore.

I work at Simply Algo Fintech on Quantman and Instaoptions, two retail trading platforms running on Kubernetes. My day is about keeping them deployable and observable: Jenkins builds, Helm charts, ArgoCD syncs, and the logging and monitoring stack I own. I'm part of the on-call rotation. On the 3 broker deployments of Quantman I've handled, I was the technical contact for the broker's team on infrastructure, network access and security.

Production changes go out after the market closes at 15:30 IST. I prefer changes I can roll back quickly, so releases are rolling updates behind readiness probes, with the desired state kept in Git. I also watch what things cost. Moving our observability off New Relic to self-hosted Elasticsearch, Kibana and Prometheus cut monitoring spend from ~$1,225 to $400 a month.

Next, I want a DevOps, SRE or Platform role with real work in AWS, Kubernetes and incident management. Right now I'm going deeper on Terraform and preparing for the CKAD.

three case studies

Selected work

Three pieces of work on live trading platforms: what was wrong, what I changed, and what happened.

Nov 2025 – present Simply Algo Fintech · DevOps Engineer · I own this stack
  • Elasticsearch
  • Kibana
  • Filebeat
  • ILM/SLM
  • Prometheus
  • Grafana
  • Uptime Kuma
  • Kubernetes

Moving production observability off New Relic

I moved production logging and monitoring for our retail trading platforms from New Relic to a self-hosted stack: Filebeat, Elasticsearch and Kibana for logs and Prometheus with Grafana for metrics. Monitoring cost dropped from about $1,225 a month to $400, and I designed the retention rules that keep it there.

~$1,225 → $400monitoring cost per month
~67%lower monitoring spend
~$10Ksaved per year
~15 GBproduction logs per day

The problem

Our trading platforms run on Kubernetes, and we paid New Relic for logs and monitoring. The bill was about $1,225 a month. Production produces around 15 GB of logs a day, so keeping everything in a hosted tool was the expensive path. We needed the same visibility for a fraction of the cost, with retention we controlled.

What I did

  • Built the log pipeline: Filebeat collects container and node logs and ships them straight to Elasticsearch, which stores and indexes them, and Kibana is where the team searches and builds views.
  • Set up Prometheus to scrape cluster and service metrics, with Grafana dashboards on top.
  • Configured alerting on the metrics so the team hears about problems quickly.
  • Added Uptime Kuma to check availability of our customer-facing web platforms, with alerts when a check fails.
  • Designed index lifecycle (ILM) and snapshot lifecycle (SLM) policies so storage stays bounded as log volume grows.
Self-hosted observability architecture and log retention Logs flow from Kubernetes pods and nodes through Filebeat and Elasticsearch to Kibana. Metrics flow through Prometheus and Grafana to alerts, and Uptime Kuma also raises alerts. Below, a timeline shows staging logs kept 7 days, production searchable for 30 days, and snapshots kept to 150 days. LOGS · ~15 GB/DAY METRICS & AVAILABILITY Pods & nodes Kubernetes Filebeat ship logs Elasticsearch ILM · SLM Kibana search · views Prometheus scrape metrics Grafana dashboards Alerts notify team Uptime Kuma web availability LOG RETENTION staging 7 days, then deleted production searchable snapshots (SLM) 0d 7d 30d 150d Indices roll over daily or at 5 GB, whichever comes first.
Logs and metrics run in two lanes from the same cluster. Elasticsearch lifecycle policies decide how long each index stays searchable and how long snapshots are kept.

Retention design

Log storage is where self-hosting gets expensive if nobody plans for it. Staging indices are deleted after 7 days. Production indices stay searchable in Elasticsearch for 30 days, then live on as snapshots until day 150, so we can restore older logs for an investigation without paying to keep them hot. Indices roll over every day or at 5 GB, which keeps each one a predictable size.

# illustrative: production log policy, shape matches the real rules
PUT _ilm/policy/prod-logs
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover": { "max_age": "1d", "max_primary_shard_size": "5gb" }
        }
      },
      "delete": {
        "min_age": "30d",
        "actions": {
          "wait_for_snapshot": { "policy": "prod-snapshots" },
          "delete": {}
        }
      }
    }
  }
}

# illustrative: snapshots kept for 150 days
PUT _slm/policy/prod-snapshots
{
  "schedule": "0 30 1 * * ?",
  "name": "<prod-logs-snap-{now/d}>",
  "repository": "log-snapshots",
  "retention": { "expire_after": "150d" }
}

Result

Monitoring cost went from about $1,225 a month to $400, roughly 67% lower and about $10K saved a year. The team kept log search, dashboards and alerting, and we now control how long data is kept. I own the stack day to day: pipeline changes, dashboards, alert rules and retention.

What I'd do next

As traffic grows, I would add Elasticsearch replicas and more nodes for high availability. I would move alerting toward SLOs, so alerts fire on user-facing error budgets instead of raw thresholds. I would also look at OpenTelemetry to add traces and keep instrumentation portable as the company moves to AWS EKS.

Nov 2025 – present Simply Algo Fintech · DevOps Engineer · Quantman & Instaoptions
  • Jenkins
  • Helm
  • ArgoCD
  • Kubernetes
  • DigitalOcean
  • GitOps

Almost-daily releases to live trading platforms, after the market closes

Quantman is hosted for 4 major Indian stockbrokers and 2 white-label partners. Production changes ship almost every day, after Indian market hours end at 15:30 IST. I own deployments for a subset of Quantman's 13 microservices and help with the rest and with Instaoptions. I also handled 3 broker deployments of Quantman as the technical point of contact.

13Quantman microservices on a ~10-node cluster
Almost dailyproduction releases, after 15:30 IST
3broker deployments (2 end-to-end, 1 support)

The problem

Traders use these platforms while the market is open, so a bad release during or near market hours hits people with live positions. Releases have to land in the window after close and keep services available while pods are replaced. Each broker also gets its own deployment of Quantman.

What I did

  • Shipped releases through Jenkins (CI), Helm charts and ArgoCD, which syncs the cluster to what is in Git.
  • Used Kubernetes rolling updates with readiness probes, so a new pod only takes traffic once it reports ready.
  • Tuned maxSurge and maxUnavailable to keep trading services available while old pods are replaced.
  • Wrote ArgoCD Application manifests for newly deployed services, so they follow the same GitOps path as the rest.
  • Handled 3 broker deployments of Quantman: 2 end-to-end and 1 in a support role.
  • Acted as the technical point of contact for the broker's team. I gathered infra requirements, raised IP-whitelisting and network-access requests, attended networking and security meetings and handled security escalations.
Release pipeline and rolling update A change moves from git push to a Jenkins CI build, then an image in the registry, then Helm chart values, then an ArgoCD sync, then a Kubernetes rolling update. An inset shows 3 replicas being replaced one at a time: a new pod is added, it passes its readiness probe, an old pod drains, until all 3 run the new version. release window: after market close, 15:30 IST git push app repo Jenkins CI build Registry image:tag Helm values chart + tag ArgoCD sync (GitOps) Kubernetes rolling update Rolling update, 3 replicas (illustrative: maxSurge 1, maxUnavailable 0) 1 · steady v1 · ready v1 · ready v1 · ready serving 3 2 · surge +1 v1 · ready v1 · ready v1 · ready v2 · probing serving 3 3 · probe passed v1 · draining v1 · ready v1 · ready v2 · ready serving 3 4 · rolled out v2 · ready v2 · ready v2 · ready serving 3 ready, takes traffic readiness probe pending, no traffic old pod draining
The release path from commit to cluster. Inset: with maxUnavailable at 0, a new pod must pass its readiness probe before an old one drains, so the service never drops below its desired replica count. Replica count and values are illustrative.
# Illustrative only: generic names, not production values
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1         # add one new pod before removing an old one
      maxUnavailable: 0   # never drop below the desired replica count
  template:
    spec:
      containers:
        - name: api
          image: registry.example.com/api:1.4.2
          readinessProbe:      # no traffic until this passes
            httpGet:
              path: /healthz
              port: 8080
            initialDelaySeconds: 5
            periodSeconds: 5
            failureThreshold: 3

Result

Production changes ship almost daily in the window after market close. Rolling updates with readiness probes replace pods gradually, so trading services stay available while a release goes out. New services get an ArgoCD Application manifest and follow the same Git-driven path as existing ones. I handled three broker deployments of Quantman (two end to end, one in a support role) and was the technical point of contact for the broker's team.

What I'd do next

I want to try progressive delivery with Argo Rollouts, so a release goes to a small canary first and is promoted only if its metrics look healthy. I'd pair that with automated rollback when an SLO error budget starts burning too fast. For the company's move to AWS EKS, I'd like to define the new infrastructure in Terraform from the start, which also means taking my Terraform skills past the basics.

Nov 2025 – present Simply Algo Fintech · DevOps Engineer
  • Kubernetes RBAC
  • VAPT
  • SOC audit
  • rsyslog
  • On-call

Scoped access and audit hardening for a trading platform

Quantman runs in-house for 4 major Indian stockbrokers and 2 white-label partners, so who can touch the cluster matters. I set up namespace-scoped Kubernetes RBAC so developers can debug their own services without reaching cluster internals. I also supported VAPT and SOC audits with an external audit firm and remediated the findings.

13high-severity findings closed
Nonedeveloper access to cluster-critical namespaces

The problem

Developers need to read logs, port-forward to a service and open a shell in a pod to debug what they own. Cluster-wide access would make that easy, but it would also expose kube-system and other cluster-critical namespaces. At the same time, the company was going through VAPT and SOC audits. Auditors needed access to inspect the cluster, and we needed audit logs to show what happened inside pods.

What I did

  • Wrote namespace-scoped Roles and RoleBindings. Developers can list pods and services, port-forward and exec only in their own app namespaces.
  • Kept kube-system and kube-node-lease out of every developer binding. A request there has no matching rule, so the API server denies it.
  • Gave the external audit firm scoped cluster access for the VAPT and SOC work.
  • Set up pod-level audit logging with rsyslog so activity inside pods leaves a record.
  • Worked through the audit findings and remediated them until the 13 high-severity vulnerabilities were closed.
  • Took part in on-call, including off-hours security escalations with broker clients. One of them was a 4 AM call on a Sunday.
Namespace-scoped RBAC for developers A developer is bound by a RoleBinding to a Role that allows get, list and watch on pods, pod logs and services, plus create on pods/portforward and pods/exec. This applies only in app namespaces. kube-system and kube-node-lease have no binding, so access there is denied. Developer kubectl user RoleBinding one per app namespace Role get · list · watch pods, pods/log, services create (port-forward) pods/portforward create (exec) pods/exec ALLOWED team-app and other app namespaces no binding: API server denies CLUSTER-CRITICAL · BLOCKED kube-system kube-node-lease
Developers get a Role only through RoleBindings in app namespaces. kube-system and kube-node-lease have no developer binding, so those requests are denied. Rule details are illustrative.
# Illustrative only: the shape of a developer Role, not the production manifest.
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: developer
  namespace: team-app
rules:
  # read pods, their logs and services
  - apiGroups: [""]
    resources: ["pods", "pods/log", "services"]
    verbs: ["get", "list", "watch"]
  # kubectl port-forward and kubectl exec need create on these subresources
  - apiGroups: [""]
    resources: ["pods/portforward", "pods/exec"]
    verbs: ["get", "create"]

Result

Developers can debug their own services without asking for admin access, and no developer binding reaches kube-system or kube-node-lease. The audit firm got the access it needed for VAPT and SOC, pods now produce audit logs through rsyslog, and 13 high-severity vulnerabilities from the findings are closed.

What I'd do next

I would move these rules into policy as code with Kyverno or OPA Gatekeeper, so a risky manifest is rejected at admission time instead of found in an audit. I would add image scanning with Trivy to the Jenkins pipeline so vulnerable images fail the build. I would also move application secrets into a dedicated secrets manager as part of the move to AWS.

more deployments

Other things I've built

Smaller pieces of work from both jobs. Two of them I built from scratch.

Simply Algo · 2025–26

First mobile CI/CD pipeline for Quantman Lite

  • Built the company's first mobile pipeline from scratch with Expo EAS for the React Native app.
  • Ships over-the-air (OTA) updates to the app.
  • Handles App Store and Play Store builds and submission.
  • Expo EAS
  • React Native
  • App Store
  • Play Store
Codingmart · VAHN · 2024–25

AWS foundation for a trucking payments platform

  • Set up separate staging and production accounts under AWS Organizations.
  • Built the VPC with NAT Gateways, ELB, PostgreSQL on RDS and least-privilege IAM roles.
  • Wrote Jenkins and Docker build and deploy pipelines.
  • AWS
  • VPC
  • RDS
  • IAM
  • Jenkins
  • Docker
Codingmart · TATA iQ · 2024–25

CI testing and monitoring for Connected Health

  • Wired the QA team's BrowserStack mobile test suites into GitHub Actions so they run on every build.
  • Built Prometheus and Grafana dashboards for device and service health.
  • Sent alerts to Slack.
  • GitHub Actions
  • BrowserStack
  • Prometheus
  • Grafana
  • Slack
git log --oneline career

Experience

About two years as a full-time DevOps engineer, after a 9-month internship.

  1. Nov 2025 – now
    DevOps Engineer
    Simply Algo Fintech
    • I own the monitoring and logging stack. I moved production observability from New Relic to self-hosted Elasticsearch/Kibana and Prometheus/Grafana, cutting monitoring cost from ~$1,225 to $400 a month. Case study
    • I own deployments for a subset of Quantman's 13 microservices and help with the rest and with Instaoptions. Releases ship almost daily after market hours through Jenkins, Helm and ArgoCD. Case study
    • I set up namespace-scoped Kubernetes RBAC and supported a VAPT and SOC audit, closing 13 high-severity vulnerabilities. Case study
    • I handled 3 broker deployments of Quantman (2 end-to-end, 1 in a support role) as the technical contact for the broker's team, and built the company's first mobile CI/CD pipeline with Expo EAS.
  2. Oct 2024 – Sep 2025
    Product Engineer (DevOps)
    Codingmart Technologies
    • Built the initial AWS foundation for VAHN, a trucking payments platform: separate staging and production accounts under AWS Organizations, VPC with NAT Gateways, ELB, RDS PostgreSQL and least-privilege IAM, with Jenkins and Docker pipelines.
    • For TATA iQ's IoT health-monitoring platform, wired the QA team's BrowserStack mobile tests into GitHub Actions on every build and set up Prometheus and Grafana dashboards with Slack alerts.
    • Containerised apps with Docker and Docker Compose for consistent dev, staging and prod, and provisioned EC2 instances with Terraform.
  3. Jan 2024 – Sep 2024
    Product Engineer Intern
    Codingmart Technologies
    • Started on CI/CD pipelines, Docker and AWS for client projects.
  4. 2020 – 2024
    B.E. Computer Science and Engineering
    Dr. N.G.P. Institute of Technology, Coimbatore
kubectl get skills

Tools I use in production

These are tools I have used on real systems. What I am still learning is listed separately at the end.

Cloud
  • AWS EC2
  • S3
  • IAM
  • RDS
  • ELB
  • VPC
  • NAT Gateway
  • AWS Organizations
  • DigitalOcean
Containers & orchestration
  • Kubernetes
  • RBAC
  • Ingress
  • Namespaces
  • Probes
  • Rolling updates
  • Helm
  • Docker
  • Docker Compose
CI/CD & GitOps
  • Jenkins
  • GitHub Actions
  • ArgoCD
  • Expo EAS
  • BrowserStack integration
Observability
  • Elasticsearch
  • Kibana
  • Filebeat
  • ILM/SLM
  • Prometheus
  • Grafana
  • Uptime Kuma
  • Slack alerting
Security
  • VAPT remediation
  • SOC audit support
  • IAM least privilege
  • Kubernetes RBAC
  • rsyslog audit logging
  • Nginx
Scripting & IaC
  • Bash
  • Python
  • YAML
  • Git
  • Terraform (basic: EC2)
Learning now
Going deeper with Terraform, learning Ansible, and preparing for the CKAD exam.
on-call for new roles

Get in touch

I'm open to DevOps, SRE and Platform roles in Chennai, Bengaluru and Mumbai. Email is the fastest way to reach me.

Emailsrinathram28@gmail.com
Based inCoimbatore, India · open to relocating to Chennai, Bengaluru or Mumbai