Ashish Kattamuri
Staff Software Engineer, Proofpoint
Denver, Colorado, United States
Actions
Ashish Kattamuri is a Staff Software Engineer with over a decade of experience designing and scaling large-scale backend systems. He specializes in building resilient, high-throughput services and solving complex challenges around data-intensive pipelines, distributed architectures, and cost-efficient scaling in cloud-native environments.
Beyond production engineering, Ashish actively contributes to the research community in AI/ML systems, with publications at top venues such as NeurIPS, ACL, ICLR and AAAI.
Links
Area of Expertise
Topics
Under the Harness: The Systems Mechanics Behind AI Coding Agents
When a coding agent starts losing track of a task, should you compact the context, start a fresh session, create a subagent, change the instructions, or give it another tool?
Most developers learn answers to questions like these as rules of thumb. But those rules become much easier to apply and debug once you understand the mechanics underneath the agent.
This session builds a systems-level mental model of modern coding-agent harnesses using tools such as Claude Code and Pi as examples. We will start by separating the model from the harness around it, then follow how a task actually moves through the system: how the harness constructs context, how the model generates the next action, how structured outputs become tool calls, how tool results return to context, and how this process creates an agent loop.
From there, we will use that model to explain practical behaviors engineers encounter every day: why context is working memory rather than storage, what compaction actually changes, why persistent instruction files work, when subagents help through context isolation, where MCP and tools fit into the architecture, and why tests, compilers, linters, and other deterministic systems are critical for verifying probabilistic agents.
The goal is to give software engineers a durable mental model they can use to understand, debug, and engineer effectively with any coding-agent harness.
Bridging the demo to production gap for LLM prototypes
Deploying Large Language Models (LLMs) in a production environment presents significant technical and financial challenges that are often underestimated during the initial prototyping phase. While LLM demonstrations are impressive, the transition to a live, scalable service reveals critical issues related to cost, latency, and throughput. This session provides a practical, engineering-focused framework for overcoming these obstacles and successfully deploying LLMs at scale.
Recording of the presentation: https://www.loom.com/share/86e60e540c52490da131c72edacbf743?t=21
When metrics tell a different story: Rearchitecting Kafka consumers for sharded databases
In high-volume event pipelines, it’s tempting to think scaling equals more hardware. But sometimes the real scaling solutions lie in the architecture.
Our ingestion service pulled batches from Kafka, regrouped events by shard, and processed them in parallel. The catch? The batch couldn’t finish until every shard completed its work. If one shard ingestion lagged, the entire system slowed.
Instead of rushing to scale databases, we turned to observability. Metrics exported to Prometheus and visualized in Grafana revealed the truth: throughput was bottlenecked by the slowest shard more than 90% of the time.
Armed with this insight, we reimagined the pipeline. Inspired by stream processing systems, we shifted from a single consumer group to shard-specific consumer groups. Each service instance filtered out irrelevant events and owned its shard fully. This independence meant shard 3 could take its time without holding back the others. Scaling became precise: we could add resources for one shard without touching the rest.
The results were immediate: higher throughput, fewer wasted resources, and a leaner ingestion backbone. Beyond performance, the bigger lesson was cultural — observability didn’t just alert us to problems, it guided an architectural shift.
This session will walk through the full journey: spotting the bottleneck with metrics, challenging the “one service = one consumer group” assumption, and designing for shard-level independence at scale.
Key Takeaways:
- Observability can drive architecture decisions, not just alerts.
- Why one-consumer-group-per-service isn’t always the right fit.
- How shard-aware design localizes scaling pressure.
- Practical patterns for faster, more resilient ingestion pipelines.
Weighted Sharding: Tackling Data Hotspots in Large-Scale Systems
Sharding is one of the most widely used strategies to scale databases. The assumption is simple: evenly distribute data across shards, and the workload balances itself. But in practice, workloads are rarely uniform. Some shards attract more traffic, some datasets are heavier, and “hotspots” emerge. The result? Certain shards run hot while others remain underutilized, driving inefficiencies and unpredictable performance.
In our production environment, we faced this very problem. Conventional sharding left us with overloaded shards that slowed down queries and ingestion, while others idled. Instead of brute-forcing with more infrastructure, we developed a weighted sharding scheme. Each shard was assigned a weight reflecting its capacity and traffic profile. Events and queries were routed accordingly, allowing us to balance load dynamically across the cluster.
This talk walks through the full journey: how we identified hotspots through monitoring, the design of our weighted sharding prototype, and the measurable improvements in throughput and cost efficiency. Beyond the technical implementation, we’ll share lessons about data modeling choices, observability, and keeping the solution simple enough to operate at scale.
By the end of this session, attendees will see how weighted sharding can transform uneven workloads into predictable, efficient systems and how shard-aware design choices can make infrastructure scale smarter.
Bridging the Semantic Gap in Text-to-SQL Systems
Text-to-SQL technology promises to democratize data access, but its effectiveness has been largely confined to English. When deployed in multilingual environments, these systems suffer a dramatic drop in performance, not just in execution accuracy, but more critically, in semantic alignment, failing to capture the user's true intent. This session dives deep into a novel framework that bridges this multilingual gap, presenting a production-oriented approach that moves beyond brittle translation-based methods and static prompting.
At the core of this solution is a sophisticated reinforcement learning strategy (Group Relative Policy Optimization - GRPO) combined with a groundbreaking contrastive reward signal. This semantic reward, powered by a multilingual encoder, teaches the model to prioritize the meaning and intent of a query, regardless of the source language. We will explore how this focus on semantic fidelity, rather than simple execution accuracy, leads to the generation of robust, precise, and reliable SQL queries that hold up even when the underlying database schema changes.
The most compelling aspect of this approach is its efficiency. We will demonstrate how a small, 3B parameter model, fine-tuned with this framework on only 3,000 examples, significantly outperforms a much larger 8B zero-shot model. This isn't just about better accuracy; it's about achieving it with a fraction of the computational cost, making truly global Text-to-SQL systems both practical and affordable.
Ashish Kattamuri
Staff Software Engineer, Proofpoint
Denver, Colorado, United States
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top