Skip to content

Bengaluru, India · PetasenseFull-stack engineer, backend-leaning

Eight hundredmilliseconds.

Currently
SDE 2, Petasense
Based
Bengaluru, India
Depth
Voice agents · Kafka · RAG
Open to
What's next
Turn latency · production voice agent
Turn total
800ms
Pixel portrait of Akash Singh wearing a headset, on the call

Under budget. The reply lands before the caller notices a gap. This is the entire job: every stage fighting for the same 800 milliseconds.

Past that, a caller starts talking over the bot. I spent two years building voice agents inside that budget, and everything since on systems where the deadline is just as unforgiving.

Five years across real-time voice AI, industrial IIoT, and the event pipelines underneath both.

Where I've worked

Five years,
four spans.

An enterprise customer-engagement platform, a conversational AI startup, its acquirer, and an industrial IIoT platform. Different domains, same shape of problem: something has to happen fast, correctly, and keep happening when a piece of it fails.

Petasense

SDE 2, Full-stack AI Engineer

April 2025 to Present

Bengaluru

Industrial machines generate the data here, so being wrong has a physical cost. I build the AI layer that plant operators actually trust.

  • Built a RAG-powered conversational analytics agent with LangChain, pgvector, and OpenAI embeddings, so non-technical operators can query account-specific industrial datasets in plain English. Multi-stage async pipeline: semantic retrieval over a vector store, NLP-driven dynamic SQL generation, multi-turn context memory, structured output validation.

    95% query accuracy · 60% less analyst workflow time

  • Designed a tool-use agent framework on LangChain tool-calling with configurable retrieval chains, plus an LLM eval harness benchmarking retrieval precision and SQL execution correctness. Prompt iteration and model upgrades ship on evidence now, not intuition.

    200-query golden dataset

  • Replaced the flat 2D machine schematic with an interactive Three.js digital twin that mirrors the real asset: the train built from real component bodies, sensors drawn at the mount points they are fitted to, and live vibration, temperature and open alarms rendered onto the geometry itself, so a bearing going bad shows up on that bearing rather than in a table beside it. Sensors are fitted by dragging onto a mount point and the train is edited in the scene, with layout changes applied optimistically and rolled back on refusal, asset model invariants enforced in the interaction rather than returned as a 400, and a 2D fallback where WebGL is unavailable.

    75 component types modelled

  • Owned a high-availability Annotations System across microservices with Redis caching and RBAC, with full audit logging on every write path.

    sub-second responses · >99% uptime

  • Worked directly with reliability engineers and plant operators to turn ambiguous maintenance workflows into product requirements, then shipped against them end to end.

  • LangChain
  • pgvector
  • OpenAI
  • Python
  • Three.js
  • Redis
  • Microservices
  • RBAC

Exotel

acquired Cogno AI

Software Development Engineer

June 2023 to April 2025

Bengaluru

Two years inside a latency budget. Live voice agents on real calls, where every stage of the pipeline is competing for the same 800 milliseconds.

  • Owned the full pipeline for production LLM voice agents on live phone calls: telephony media ingest, streaming ASR, intent resolution, TTS playback back onto the live call, all designed against a sub-800ms turn-latency budget.

    sub-800ms turn budget

  • Solved the hard parts of live conversation rather than the happy path: barge-in with in-flight TTS cancellation, endpointing and turn detection on partial ASR results, and graceful degradation when any single stage slowed. A slow LLM call never blocked the audio loop.

  • Engineered a real-time call intelligence pipeline in Node.js, Django, Redis, and Whisper, turning thousands of call recordings into transcripts, multi-label sentiment scoring, and agent performance summaries.

    +20% analysis accuracy · 6 hrs/analyst/week of manual QA removed

  • Designed an event-driven ingestion system on Apache Kafka and Node.js consuming call lifecycle events at scale. Exactly-once semantics anchored downstream through idempotent writes and unique constraints, rather than trusting the transport layer.

    40% lower event processing latency · zero data loss at peak

  • Shipped a context-aware LLM co-pilot for live agents on GPT-4 with RAG over internal knowledge bases: in-call suggestions, next-best-action prompts, dynamic FAQ resolution.

    +25% CSAT across 3 enterprise customers

  • Architected the Automated Contact Center platform frontend in TypeScript with Next.js and a Turborepo monorepo, introducing code-splitting and edge caching.

    30% faster page load · +25% engagement

  • Node.js
  • Kafka
  • Django
  • Whisper
  • GPT-4
  • Next.js
  • Turborepo
  • Redis

Cogno AI

intern through July 2022

Software Development Engineer

April 2022 to June 2023

Mumbai

Early engineer at a pre-Series-A startup, acquired by Exotel in 2023. The place where I learned that most systems problems are really scheduling problems.

  • Built the video layer for LiveChat on Django, WebSockets, and the Dyte SDK: meetings created and participant tokens minted server-side so no call credential ever reached the browser, with signalling and presence riding the WebSocket channel the chat already held open. The work that mattered was the failure paths rather than the happy path: denied camera and microphone permissions, rooms left orphaned by a closed tab, and a mid-call network drop that has to put the customer back into the same session instead of a fresh one.

    30% fewer video support tickets · +18% session engagement

  • Rebuilt LiveChat agent assignment from a polling scheduler into an event-driven service on Django, Celery, and Redis. The old path swept every 30 seconds, scanning every waiting customer and matching each to a free agent by query domain and preferred language, so a request raised just after a sweep waited out the whole interval, and the sweep still ran on the cycles where nothing was waiting. Assignment now fires off the request event itself: routed on domain and language against live agent availability, with an atomic claim so two concurrent events cannot take the same agent, and bounded retry with backoff that re-queues a request rather than spinning when no match is free.

    30s worst-case wait removed · 110 hrs/week of manual ops removed

  • Brought Instagram and Facebook into LiveChat Fusion as first-class channels on the Meta Graph API, normalising each platform's payload shape into one conversation model so an agent worked a single queue instead of a tab per network. Inbound webhooks acknowledge immediately and fan out to workers, because Meta redelivers anything it does not get a fast 200: messages are deduplicated on the platform message ID so a retry cannot post twice, and outbound sends are shaped to the per-page rate limit and the messaging window rather than finding them at runtime.

    3 messaging channels · 15% faster average response

  • Django
  • Celery
  • Redis
  • WebRTC
  • WebSockets
  • Meta Graph API

Ameyo

internship · now part of Exotel

Software Engineer

July 2021 to April 2022

Gurugram

Where it started. Ten months on an enterprise customer-engagement platform, learning that most of software is reading what is already there before adding anything to it.

  • Built and tested REST APIs for communication between application components, working to the reliability bar of a platform that was already in production.

  • Debugged and resolved live production issues, which is where I learned to read a stack trace and a log timeline before touching any code.

  • Worked the full cycle inside an agile team: code review, design discussion, and feature work shipped to deadline.

  • Java
  • Spring Boot
  • JavaScript
  • REST APIs

Things I've built

Four things
I finished.

Not a list of repositories. For each one: what was actually broken, what I built, and the part that was genuinely hard, which is usually the only part worth talking about.

DistributedKV

Fault-tolerant key-value store · Go

The problem

Consensus is the thing every distributed system leans on and almost nobody has implemented. Reading the Raft paper is not the same as watching a leader die under load.

What I built

Raft from scratch (leader election, log replication, read replicas) with consistent hashing over virtual nodes for placement, and a custom binary gRPC wire protocol for inter-node RPC.

The hard part

Correctness at the leader-crash boundary. Failover is easy to demo and hard to prove; I verified it by killing leaders mid-write and checking that nothing was lost on the other side.

p99 read
<2msp99 read
node cluster
4node cluster
data loss on failover
0data loss on failover
  • Go
  • Raft
  • gRPC
  • Consistent hashing
  • Docker

AgentBench

LLM evaluation & testing framework

The problem

Every team shipping LLM features hits the same wall: you change a prompt, and you have no idea whether you made it better. Vibes are not a regression suite.

What I built

A configurable eval framework that runs automated suites against RAG pipelines and tool-use agents, scoring retrieval precision, answer faithfulness, and SQL execution equivalence against curated golden datasets.

The hard part

Scoring SQL by execution equivalence rather than string match. Two very different queries can be the same answer, and a grader that doesn't know that will punish you for being right.

scoring dimensions
3scoring dimensions
tracing & latency profile
per-runtracing & latency profile
cost analysis per suite
tokencost analysis per suite
  • Python
  • RAG
  • Tool-calling
  • Golden datasets

Driftbell

Multi-tenant SaaS changelog platform

The problem

Product teams ship constantly and tell nobody. The tools that fix that are either a heavyweight suite or a Notion page someone forgets to update.

What I built

Zero to paying customers, solo. Web dashboard, public changelog, email digest system, and an embeddable widget that drops into any site with a single script tag.

The hard part

The widget had to run inside other people's pages without breaking them or dragging a framework along, so it ships as a zero-dependency IIFE under 15KB. And billing has to be correct on every write path, not just at checkout.

zero-dep widget bundle
<15KBzero-dep widget bundle
billing tiers, webhook-enforced
3billing tiers, webhook-enforced
engineer, end to end
1engineer, end to end
  • Next.js 14
  • TypeScript
  • Prisma
  • PostgreSQL
  • Stripe

Topograph

Service topology & observability platform

The problem

You cannot debug a distributed system you cannot see. Most teams discover their service topology by asking around, and the answer is always one service out of date.

What I built

Metrics, logs and traces off a fleet of microservices into one pipeline: Kafka for ingest and backpressure, Elasticsearch on the query side, and a rolling-baseline detector that alerts on deviation instead of on a threshold somebody guessed a year ago.

The hard part

Deriving the topology from traffic rather than from a config file. Edges come out of span parent and child relationships plus caller metadata, collapsed across instances so the map shows services and not pods, and decayed over time so a dependency that stops being called disappears instead of haunting the graph forever.

metric visibility
sub-secondmetric visibility
topology inference
zero-configtopology inference
baselines, not thresholds
rollingbaselines, not thresholds
  • Kafka
  • Elasticsearch
  • React
  • Anomaly detection

What I work in

Tools, with
reasons attached.

Grouped by the job they do. I’ve shipped production code in everything on this page. Where I’ve only operated something rather than built on it, it’s in the infrastructure row.

Languages I actually writeDay to day, in production.
  • Python (AsyncIO, FastAPI, Django)
  • TypeScript
  • Go
  • Node.js
  • C++
Voice & real-timeWhere the deadline is a person waiting on a phone line.
  • Streaming ASR & TTS pipelines
  • Barge-in and turn detection
  • Whisper
  • WebSockets
  • WebRTC
  • gRPC
Event-driven architectureDelivery guarantees you enforce yourself, because the transport won't.
  • Apache Kafka
  • Redis pub/sub
  • Webhook ingestion & routing
  • Distributed task queues
  • Idempotent consumers
  • Retry & dead-letter handling
AI & MLThe orchestration layer, not the model training.
  • LLM orchestration
  • Tool calling
  • LangChain
  • OpenAI API
  • RAG pipelines
  • pgvector & embeddings
  • NLP-to-SQL
  • Structured outputs
  • LLM evals
Infrastructure & dataWhat it runs on, and where the state lives.
  • AWS
  • Docker
  • Kubernetes
  • Nginx
  • Linux
  • Prometheus
  • CI/CD
  • PostgreSQL
  • MySQL
  • MongoDB
  • Redis
  • Elasticsearch
  • Apache Airflow
FrontendBackend-leaning, not backend-only. This site is the proof.
  • React
  • Next.js
  • Tailwind CSS
  • Turborepo
  • WebGL
  • D3.js

The person

How I
think about it.

Off the clock. Click to clock in

I got into systems work through the least glamorous door available: a 2am pager, a real-time voice platform behaving badly, and a Kafka consumer lag graph that would not come back down. Finding out why took most of the night. Understanding why took considerably longer, and I have been pulling on that thread ever since.

What I like about real-time systems is that they are honest. A batch job that is slow is an inconvenience. A voice agent that is slow is a person on a phone getting frustrated and talking over a robot. The feedback is immediate and it is not negotiable, which turns out to be an excellent way to learn.

I am backend-leaning but not backend-only. The most useful thing I have picked up from five years of shipping is that the interesting failures live at the seams: between the model and the pipeline, between the queue and the database, between what a plant operator meant and what the query actually asked. Owning both sides of a seam is how you fix them.

Guarantees belong in your code, not your infrastructure

Exactly-once delivery is a property you enforce with idempotent writes and unique constraints. If your correctness story starts with "the broker promises," you do not have one.

You have not shipped it until you can see it

Tracing, latency profiles, and eval harnesses are not polish added at the end. They are how you earn the right to change something on a Friday.

Design for the stage that is slow

Every pipeline has one component that will blow the budget. Build the graceful path for that stage first, before it is the one paging you.

600+ problems

LeetCode and GeeksforGeeks, 4 stars on HackerRank, and top 212 nationally in a 2019 contest. I still do them. Not for interviews, but because a hard problem with a clean answer is genuinely a nice way to spend an evening.

Reading

Distributed systems papers, mostly, and the postmortems companies are brave enough to publish. Someone else's outage is the cheapest lesson available.

Building

Small things, weekends, no roadmap. Most of them do not survive contact with Monday. The ones that do end up further up this page.

Get in touch

Still under budget.

I'm at Petasense in Bengaluru, building the AI layer for industrial reliability. Open to conversations about real-time systems, LLM infrastructure, and roles where the hard part is making something stay up.