Platform & Backend Engineer, Ahmedabad, India

I make systems work together that weren’t designed to.

Right now, that’s the internal developer platform at Techolution: built in four months, used by 150+ engineers, and the reason a deployment takes 15 minutes instead of days.

Scroll

What I do

Systems that weren’t meant to work together

Most of my best work sits in the gap between two systems. A few of them:

GitHub connected to Cloud Build

CI past a 600-trigger ceiling

Cloud Build caps triggers at 600, and our CI was trigger-based. I replaced it with a GitHub App → Pub/Sub → expander pipeline: ordered per-deployment queues and a 45-retry dead-letter queue.

No trigger ceiling; durable, auditable delivery.

Vertex AI connected to Post-processing engine

~40s to 8s to first response

Our post-processing engine expected complete LLM responses. I streamed Vertex AI tokens through it in chunks instead of waiting for the full generation.

5× faster first response on a production RAG chatbot.

Slack & Teams connected to Jira & ServiceNow

Incident triage across chat and ticketing

A multi-tenant, event-driven service linking Slack and Teams to Jira and ServiceNow, with severity classification and escalation workflows, built on FastAPI, PostgreSQL and Pub/Sub.

Load-tested at 5,000+ events per hour.

Smart-home app connected to LLM agent

A smart home that takes orders from an LLM

I intercepted the vendor app’s traffic with a MITM proxy and packet captures, found its MQTT control channel and decoded the payloads, then put a LangChain + Gemini agent on top.

Voice control through iPhone Shortcuts, self-hosted 24/7.

Cloud Tasks connected to Trial Releases

Releases that roll themselves back

Trial releases run for a set window, from 30 minutes to 6 hours. Cloud Tasks schedules an automatic revert to the last known-good build unless a newer build succeeds.

Part of the approval and release state machine I own.

Kubernetes client connected to Bulk deletion

When the client library breaks

The Python Kubernetes client failed during bulk service deletion. I root-caused the defect, added safeguards, and routed the affected calls through kubectl.

Bulk deletions made safe again.

Experience

Where I’ve built

AI Engineer, Platform Engineering · Techolution

– Present · Hybrid

  • Co-architected the company’s internal developer platform (IDP) on GCP and Kubernetes; I own its FastAPI orchestration engine, approval and release state machine, and event-driven CI pipeline. Details in the case study below.
  • Co-designed the split of the platform backend into three services (deployment orchestration, builds, and deployment management with environment administration), each scaled to fit its load.
  • Cut a production RAG chatbot’s time to first response from ~40s to 8s by streaming Vertex AI tokens to our post-processing engine in chunks instead of waiting for the full response.
  • Built an agent-config promotion system that carries 90%+ of each AI agent’s configuration across environments, cutting setup from 45 to 5 minutes per agent.
  • Built GPU ML infrastructure: model deployment on GPU-backed GKE node pools and Cloud Run, and a training-job scheduler that auto-provisions VMs and shuts down idle compute.
  • Architected an event-driven incident-triage service connecting Slack and Teams to Jira and ServiceNow.

Tools: Python · FastAPI · GKE · Cloud Run · Argo CD · Helm · Pub/Sub · Cloud Tasks · MongoDB · PostgreSQL · Vertex AI

Python Developer Intern · Smollan

– · Remote

  • Built an Amazon Textract + OCR pipeline with regex parsing over rendered page screenshots, extracting structured product listings at ~95% accuracy.
  • Built 15+ Flask API endpoints powering live kiosk-usage analytics dashboards.

Tools: Python · Flask · AWS Textract

Data Analyst Intern · Ernst & Young (EY)

– · On-site

  • Analyzed clickstream data from high-stakes assessments with SQL and automated suspicious-behaviour detection in Python, cutting manual querying by 20%.
  • Built a KD-Tree face-similarity engine for large-scale pairwise matching: 60 billion comparisons.

Tools: SQL · Python

Education

Manipal University Jaipur · B.Tech, Information Technology · CGPA 8.17/10

Graduated

Download the full résumé (PDF), opens in a new tab

Skills

Tech stack

Languages
  • Python
  • SQL
  • Bash
Backend
  • FastAPI
  • Flask
  • asyncio
  • Pydantic
  • REST APIs
  • Microservices
  • Event-driven design
Platform
  • Kubernetes
  • Helm
  • Argo CD
  • GitOps
  • KEDA
  • HPA
  • Kyverno
  • NGINX Ingress
  • Gateway API
  • Docker
Google Cloud
  • GKE
  • Cloud Run
  • Compute Engine
  • Cloud Build
  • Artifact Registry
  • Pub/Sub
  • Cloud Tasks
  • BigQuery
  • Firestore
Data
  • MongoDB
  • PostgreSQL
  • Redis
AI & LLMs
  • Vertex AI
  • Gemini
  • LangChain
  • LangSmith
Also
  • AWS S3
  • Amazon Textract
  • GitHub
  • Jira

Case study · Internal developer platform

A self-service platform for 150 engineers

Shipping a new service used to take 2–3 days. I co-architected an internal developer platform, built from scratch in four months, that turned it into one self-service workflow: from a repository to a running, health-checked service on GKE or Cloud Run, whether it’s a frontend, a backend or an AI agent. Behind that workflow is a whole platform: CI, GitOps delivery, autoscaling and routing, access control and approvals, self-reverting trial releases and an audit trail of every change.

  • 150 engineers across 10+ teams
  • 15 min average deploy, down from 2–3 days
  • 1,000+ deployments in 10+ months
  • 15+ environments, from dev to client
How it fits together

Self-service

  • Deploys to GKE or Cloud Run
  • HPA or KEDA autoscaling
  • Approval chains
  • Trial releases
  • One-action revert
  • Change history

Platform

  • Deployment orchestration
  • Builds
  • Deployment management & environment admin

Three FastAPI services, split from a monolith so each uses the scaling method that fits its load.

Built on

  • GitHub
  • Pub/Sub
  • Cloud Build
  • Helm
  • Argo CD
  • Kyverno
  • GKE
  • Cloud Run
  • Cloud Tasks
  • MongoDB

Inside the platform

  • Orchestration

    One engine runs every deploy

    A FastAPI engine runs each deploy as a series of stages, 9 on GKE and 5 on Cloud Run, including the CI build, pod sizing from measured usage plus 25% headroom, health checks and the Argo CD handoff. When a stage fails, its retry cleans up partial resources first.

  • CI

    No trigger ceiling

    Cloud Build caps triggers at 600, and CI used to be trigger-based. Now a GitHub App publishes every push to Pub/Sub, and an expander routes it into ordered per-deployment queues, with a 45-retry dead-letter queue and approval gates driven by PR summaries.

  • Delivery

    What’s in Git is what runs

    The platform generates each service’s Helm chart and versions it in GitHub. Argo CD syncs it to GKE and waits for pods to be ready, and Kyverno admission policies block out-of-band changes, so configuration doesn’t drift from Git.

  • Scaling & routing

    No Helm edits to scale or route

    Teams pick CPU-based autoscaling with HPA or request-based with KEDA. Each environment routes through NGINX, GCE Ingress or the Kubernetes Gateway API, and the pipeline adapts the routing to match, so nobody needs direct Helm access.

  • Approvals & releases

    Sign-off before prod, rollback built in

    Access is ACL-based RBAC backed by MongoDB, and prod and client deployments wait on approval chains of up to three levels. Trial releases run for 30 minutes to 6 hours, then Cloud Tasks reverts them to the last known-good build unless a newer build succeeds.

  • Audit

    Every change on record

    Route-level middleware logs every lifecycle event (deploys, retries, access changes, config, CI pushes, promotions) with its full request and response. That log powers per-user history, AI-generated change summaries and one-action revert to any earlier stable version.

My role

I own the orchestration engine, the approval and release state machine and the event-driven CI pipeline. I also implemented the GitOps delivery, shipped the autoscaling and routing options, built the audit log, and co-designed the split into three services.

Tech blog

Notes from the gaps between systems

Deep dives on the problems above, written for engineers who hit the same walls. The first posts are in progress.

How I got past Cloud Build’s 600-trigger limit

Why trigger-based CI hits a wall, and the GitHub App → Pub/Sub → expander design that replaced it.

  • Streaming LLM output through a post-processor: 40s to 8s

  • Reverse-engineering my smart home’s MQTT protocol