Deepti Mittal
Blogger, tech speaker and in love with distributed systems. Also happen to work as Principal software engineer for one of the leading cyber security company Mimecast.
Bengaluru, India
Actions
Deepti Mittal is a Principal Software Engineer at Mimecast with deep expertise in AI development, distributed systems, observability, scalability, and system architecture. Drawing on experience across healthcare, retail, and finance, she excels at building resilient, scalable solutions tailored to diverse business needs. Currently, she is exploring innovative ways to leverage Generative AI for enhancing everyday engineering and system resilience. A passionate technologist and blogger, Deepti Mittal is known for demystifying complex system internals and sharing practical insights. Her sessions blend technical depth with real-world lessons, empowering teams to build smarter, more scalable systems
Area of Expertise
Topics
The AI Adoption Lie: Why High Usage Hides a Failing Rollout
Your usage dashboard is green. Leadership thinks the AI rollout worked. It didn't. High usage is the most convincing lie in engineering today.
proof. It isn't. Across the industry, adoption is near-universal while trust in AI output keeps falling, most usage is ad hoc, and the early productivity spike flattens within two months. The dashboard says success. The ground says scattered, low-trust, unrepeatable work. That's the adoption lie — and most orgs are living inside it.
I'll start with the pain that's easy to miss: teams each inventing their own private AI habits, "almost right, but not quite" code piling up in reviews, senior engineers quietly opting out, reviewers spending more time checking AI output than they ever saved writing it.
Then the metrics. I'll name the vanity numbers that make a failing rollout look healthy — active users, seats filled, prompts sent, lines accepted — and why each one lies. And I'll reframe around the signals that actually predict embedded adoption: trust, repeatability, onboarding time, review confidence, and whether the workflow survives past week one.
Finally, what you can act on: how we closed the gap by consolidating fragmented practices into one blessed, installable path, building trust into the workflow instead of hoping for it, and measuring what matters. Honestly — including what stalled.
You'll leave able to audit your own rollout for the lie, drop the metrics fooling you, and start turning usage into adoption you can trust.
Key takeaways
How to spot the adoption lie where high usage masks a failing rollout
The vanity metrics that disguise failure as success — and why each misleads
The signals that actually predict durable adoption: trust, repeatability, onboarding, review confidence
A concrete way to close the usage-to-adoption gap without discarding what works
An honest account of the friction: skeptics, habits, and tradeoffs that don't resolve
Stop Vibe Coding: Spec-Driven Development That Reviewers Actually Trust
Picture the merge request that lands at 5pm. The code works — probably. But there's a duplicate test file, an API shape nobody recognizes, coverage with no rationale, and nothing explaining why. The plan the AI wrote to build it? Gone — it lived on a laptop just long enough to ship. The reviewer can rubber-stamp it or reverse-engineer the intent from scratch. That's the hidden tax of vibe coding: fast to start, impossible to trust. And when every team improvises its own version, you don't get velocity — you get a dozen private dialects and no path a new engineer can pick up.
This talk is about closing that trust gap. We built a spec-driven workflow where the spec — not the prompt, not the ephemeral plan — is the single source of truth, human-approved before any code exists, with agents implementing and validating against it. Work arrives review-ready: a diffable spec a human signed off on, a documented reason for every kept test, and a clean trail from ticket to result. Specs are committed alongside the code, so intent lives on as durable documentation and can power drift detection on future changes.
Then a second idea changed the feel of the whole thing: the work doesn't have to start in the editor. We made it possible to kick off spec-driven development straight from Slack, where teams already align and decide. When the journey begins in a shared channel instead of a solo IDE session, the spec becomes a conversation the whole team can shape before code exists — review starts at the idea, not the merge request, and onboarding means pointing someone at a thread. Individual AI assistance becomes a collaborative team practice.
I'll walk through the six-stage, human-gated loop, both entry points in action, and the honest tradeoffs — repo bloat, how much structure is too much, and where a human still holds the pen. You'll leave with a blueprint for moving from untrustworthy plan mode to a durable, collaborative SDD practice you can standardize.
Stop For-Looping Your Agents: Event-Driven Architecture for AI That Stays Up
Right now, most agents are a for loop with anxiety: call a model, wait, call a tool, wait, call another agent, pray. It's a beautiful demo and a production incident waiting to happen. One timeout, one rate limit, one flaky tool, and the whole synchronous chain collapses — taking your workflow (and your on-call weekend) with it.
Here's the uncomfortable truth: an agent isn't a script, it's a distributed system. And cloud native already solved distributed systems a decade ago. In this talk I'll rebuild an agent as an event-driven system on Kafka/NATS, where each step is an event, retries and idempotency are first-class, and long-running workflows survive failure instead of falling over. I'll walk through a working reference implementation, the failure modes that forced each decision, and the trade-offs you're signing up for — latency, complexity, debuggability.
You'll leave able to stop for-looping your agents and start engineering them.
Shipping Prompts Like Software: Declarative Artifacts, Automated Evals, GitOps
In LLM-driven applications, prompts dictate core business logic, safety boundaries, and data schemas—yet they are routinely buried in application code as unvalidated text strings. When a prompt change silently alters output formatting, degrades accuracy, or inflates token costs, traditional unit tests and linters pass without a warning.
This talk presents a cloud-native pattern for shipping prompts like software: treating them as first-class, declarative artifacts managed through GitOps.
We will explore how to package prompts into versioned manifests containing typed inputs, model parameters, and strict JSON output contracts. You will learn how to build an automated CI/CD pipeline using open-source evaluation tools to run golden datasets, LLM-as-judge assertions, and cost regression checks on every Pull Request.
Walk away with a concrete, vendor-neutral blueprint to version, test, and gate prompt deployments with the same engineering discipline as your microservices.
My AI Reviewer is Meaner Than My Tech Lead: Left-Shifting Reviews into a Partnership
Most developers treat AI like a fancy vending machine: insert prompt, receive code, and hope for the best. However, this "generate-and-pray" method often results in technical debt and late-stage bottlenecks that haunt distributed systems
What if your AI could catch architectural flaws before you even hit 'commit'?
This talk moves beyond basic code generation to explore how to "left-shift" the review process.
I will discuss/demonstrate a tool which transforms AI from a simple generator into a critical partner that provides high-quality, specific feedback, ensuring your code is production-ready before it ever reaches a human reviewer.
I provide a roadmap for using specific, persona-driven prompts to act as a rigorous quality gate
Designing APIs for Consumers That Never Sleep, Never Read, and Never Give Up
Your next API consumer won't read your documentation. It won't open a support ticket when confused. And when something fails, it won't pause to think—it will retry. Relentlessly.
We're entering an era where AI agents don't just call APIs—they orchestrate workflows, complete tasks, update records, and make autonomous decisions . Yet most of us are still designing APIs for humans who read, reason, and give up gracefully.
This talk is a wake-up call and a practical guide.
I'll challenge you to think differently about two things you thought you understood: API design and API governance. Because the rules that served us well for human consumers? They're about to become liabilities.
Consider this: An agent may initiate tasks without immediate human review—but that doesn't transfer responsibility to the system itself . So who's accountable when an autonomous agent misinterprets your API and causes chaos? Your governance framework better have an answer.
You'll discover:
The three questions every agent will ask your API—and why most APIs fail to answer them
Why "good enough" governance becomes dangerous when consumers operate at machine speed
A new mental model for designing APIs that agents can discover, understand, and use safely
This isn't about distant futures. Agents are already conducting deep investigations across sources, managing workflows spanning multiple systems, and resolving issues autonomously . The question isn't if they'll consume your APIs—it's whether your APIs are ready.
You'll leave with a framework to evaluate your APIs today and a governance checklist for the agentic tomorrow.
Know these Kafka configurations to sleep peacefully in night
Kafka is one of the most configurable framework to cater to the need of diverse use cases.
This talk is to highlight few important configurations which one should learn in details to arrive at right values based on use case, load and tolerance for failures in solution.
Knowing these configurations really helped me improve production stability by 100 times for Kafka cluster and applications.
Beyond Dashboards: Building a Self-Healing API Ecosystem with AI-Powered Observability on Kubernetes
Traditional observability tells you that something is broken. AI-powered observability tells you why it broke and how to fix it—before your users notice.
In this hands-on session, I will demonstrate how to evolve a standard Prometheus and Grafana monitoring stack into an Intelligent Layer that uses machine learning to dynamically adjust baselines and detect anomalies in real time . Using a live Java microservice running on Minikube and Podman, I will show how the OpenTelemetry Java Agent instruments bytecode "behind the scenes" to capture traces without code changes. We will then integrate a Sequencing Agent that queries logs and traces, sends them to an LLM, and auto-generates a remediation suggestion .
Attendees will leave with a practical, 100% open-source blueprint they can run on their own laptops—no cloud subscription required.
From Brain in a Jar to API Factory: How AI Agents + MCP Are Changing application Development
What if AI could do more than just answer questions or generate code snippets? What if it could become an autonomous collaborator—one that understands your intent, orchestrates complex workflows, and manages the entire API lifecycle with minimal human intervention? Thanks to advances in new AI era where AI can act as a true partner in software engineering, transforming the way we build, deploy, and operate APIs in cloud-native environments.
Session Overview:
We’ll begin by easing into core concepts of AI Models, MCPs and Agents
By building this foundational knowledge, you’ll shift your perspective on AI—from a passive tool to an active, autonomous collaborator.
Live Demo: End-to-End Automation in Action
This session will introduce a new mental model for working with AI. Imagine moving from the DRY (Don’t Repeat Yourself) principle in code to DRY as a software engineer, where you automate not just code, but entire workflows and decision-making processes.
API Observability by Design, why I will not do in silos
In today's complex distributed systems landscape, observability isn't something you bolt on after deployment—it must be woven into your API design from the beginning. This practical, code-focused session will demonstrate how thoughtful API design decisions directly impact your ability to gain actionable insights when systems are in production. Drawing from real-world implementation experience, I'll walk through specific design patterns, instrumentation approaches, and architectural considerations that make APIs inherently more observable, enabling teams to troubleshoot faster, understand usage patterns better, and continuously optimize their services. You'll leave with concrete implementation strategies that transform observability from an operational afterthought to a fundamental design principle.
Agentic Automation with MCP: From User Story to Monitored API
As the Model Context Protocol (MCP) rapidly becomes a foundational standard for connecting large language models (LLMs) with real-world applications, developers are discovering new ways to harness agentic AI for end-to-end automation. This session will demonstrate how MCP empowers AI agents to securely orchestrate the entire API lifecycle—from requirements gathering and code generation to deployment, observability, and monitoring—using open standards and open-source tools.
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