Mayur Madnani
Principal Engineer
Hyderābād, India
Actions
Links
Area of Expertise
Topics
Turning Rough One-Liners into Actionable JIRA Tickets with Gemma
Context and Background
In real-world software projects, developers and stakeholders often create JIRA tickets with only minimal input—such as a vague summary or a one-line description. Missing fields like acceptance criteria, priority, or labels can cause long-term issues: poor backlog grooming, unclear requirements, and slower resolution cycles. Writing high-quality tickets requires context, structure, and consistency, which can be time-consuming for developers and product managers. Small Language Models (SLMs) excel at structured expansion and can fill these gaps consistently. This session introduces TicketTuner, an ADK-powered agent that transforms rough inputs into complete JIRA tickets, automatically generating fields such as description, acceptance criteria, priority, and labels.
Session Abstract
This session demonstrates how to build and deploy TicketTuner, a production-ready ADK agent on Cloud Run that turns raw, incomplete inputs into structured JIRA tickets. By leveraging SLMs for instruction-following and text structuring, TicketTuner ensures that key fields—description, acceptance criteria, priority, and labels—are consistently populated. Attendees will learn how to implement, deploy, and validate the agent, and see how Cloud Run enables scalable, production-ready operation.
What the Session Covers
• Why incomplete tickets hinder project health and velocity
• Overview of SLMs for structured task expansion
• Implementing TicketTuner to populate:
o Description
o Acceptance criteria
o Priority
o Labels
• Deploying the agent on Cloud Run with ADK
• Validating outputs through the ADK interface
• Analyzing autoscaling and performance under load
Key Takeaways
• Learn how to operationalize an ADK agent that improves JIRA ticket quality
• Understand how SLMs can enforce consistency in project management workflows
• Gain hands-on insight into deploying agents with ADK and Cloud Run
• See how structured ticketing supports long-term project clarity and velocity
Making Pattern Matching Conversational with PatternPilot
Context and Background
Regular expressions (regex) are powerful for pattern matching but notoriously difficult to write, read, and debug. Even experienced developers often rely on trial-and-error or online tools to craft complex regex patterns. Meanwhile, non-technical users are effectively locked out of using regex in their workflows.
Small Language Models (SLMs) like Gemma can bridge this gap by understanding natural language intent and generating accurate, optimized regex patterns. This session introduces PatternPilot, an AI-powered agent that converts everyday language into regular expressions — making pattern matching more intuitive and accessible across technical skill levels.
Session Abstract
This session demonstrates how to build and deploy PatternPilot, a production-ready ADK agent on Cloud Run that acts as a natural language-to-regex translator. By leveraging SLMs for structured outputs and instruction-following, PatternPilot simplifies the process of creating and debugging regex. Attendees will learn how to operationalize PatternPilot—from model integration and Cloud Run deployment to validation workflows and autoscaling under load. Whether you’re a developer, data scientist, or business analyst, this session shows how to make pattern matching accessible to everyone through conversational AI.
What the Session Covers
• Introduction to SLMs and why they excel at structured tasks like text generation
• Overview of ADK and Cloud Run for agent deployment
• Implementing PatternPilot to:
o Convert natural language into valid regex expressions
o Translate regex patterns back into human-readable explanations
• Deploy and scale PatternPilot on Cloud Run
• Validating interactions through the ADK interface
• Observing autoscaling and performance under load
Key Takeaways
• Learn to operationalize a bidirectional regex translator using ADK
• Understand how SLMs make complex pattern generation more intuitive
• Gain practical insight into Cloud Run deployment and autoscaling for AI agents
• Discover how conversational regex tools can accelerate developer productivity and reduce syntax errors
From API to On-Device: Building AI-Powered Story Generators with KMP and Gemma Models
Abstract:
In an era where generative AI is rapidly evolving and cross-platform development is on the rise, Kotlin Multiplatform (KMP) offers a unique way to blend on-device and API-driven AI experiences. Our session will explore how to leverage these technologies to create a dynamic story generator app.
In this session, we’ll explore how to create a dynamic story generator using Google’s Kotlin Multiplatform (KMP) framework and the Gemma on-device language model. We’ll start by using the Gemini API to generate initial stories and then transition to on-device story generation with the Gemma model. Attendees will see how to move from a cloud-based model to an on-device solution, progressively refining the output through prompt tuning and adapter-based fine-tuning.
In essence, the app is a story generator, and the demo highlights how different model variations can enrich the storytelling experience. This abstract approach will give attendees a clear picture of how we’re blending API-based and on-device techniques to craft dynamic stories.
What the Session Covers:
* How to kickstart story generation using the Gemini API.
* Transitioning to Google’s Gemma model for offline personalization.
* Applying prompt tuning and fine-tuning to enhance on-device story quality.
* Evaluation methods to compare the different stages of model refinement.
Session Highlights:
* Cross-Platform AI Integration: How KMP enables seamless use of both API-based and on-device models.
* Story Generation Techniques: Comparing base, prompt-tuned, and fine-tuned model outputs to show how each step refines the storytelling.
* Practical Demo: A live walk-through of how the app generates and personalizes stories in real time.
From Cloud to Pocket: Refining Stories with Google’s Gemini API and Gemma On-Device Model
Context and Background
Generative AI has opened up new creative possibilities, but most applications rely on cloud-based models, which can introduce latency, privacy, and cost challenges. In this session, we explore how to shift from server-side story generation to efficient on-device personalization. By using Google’s Gemini API and Gemma models, we demonstrate a hybrid approach that maintains quality while optimizing for responsiveness, adaptability, and user control.
Abstract:
Join us as we journey from the cloud to your pocket, using Google’s Gemini API and Gemma on-device model to refine story generation. We’ll start with cloud-based story creation and then shift to running models directly on-device, showcasing how to enhance outputs with tuning techniques. By the end, you'll see how to measure and compare the results of each stage.
What the Session Covers:
This session dives deep into the practical use of language models for story generation, moving from a Gemini model to on-device Gemma models and refining them for richer output. We'll explore the transition to on-device models that can be progressively tuned.
* Starting with a Gemini API to generate initial stories.
* Transitioning to on-device models for offline and personalized story generation.
* Demonstrating three stages of on-device model use: the base model, a prompt-tuned version, and a fine-tuned version using adapter tuning.
* Evaluation methods to compare and measure the improvements in story quality across these different models.
Session Highlights:
* Practical steps for moving from API-based generation to on-device models.
* A detailed look at how prompt tuning and fine-tuning can enhance on-device model outputs.
* Simple evaluation metrics to assess the quality of generated stories.
Key Takeaways:
Attendees will gain insight into how to evolve from cloud-based to on-device models, how to refine model outputs through tuning, and how to evaluate the improvements effectively.
Supercharging Documentation with Cloud Run, ADK, and Gemma
Context and Background:
Small Language Models (SLMs) are increasingly practical for real-world developer workflows. Unlike large models that require heavy compute, SLMs are lightweight, cost-efficient, and can run in production environments with minimal overhead. Developers often capture notes, tasks, or meeting summaries in plain text, but struggle to consistently format them into clean documentation. This session shows how SLMs, combined with Google’s Agent Development Kit (ADK) and Cloud Run, can be used to build an Intent-to-Docs agent that automatically formats natural language into Markdown, making documentation faster and more reliable.
Session Abstract:
This session demonstrates how to build and deploy a production-grade ADK agent on Cloud Run that converts free-form text into structured Markdown documentation. By leveraging small language models (SLMs) and focusing on deployment patterns, attendees will learn how to operationalize lightweight AI agents built with Gemma in real-world developer environments. The workshop highlights service configuration, backend integration with ADK, validation via the ADK interface, and scaling under load.
What the Session Covers:
* Introduction to ADK and its role in building agents
* Overview of Small Language models and the Google's Gemma family
* Overview of Cloud Run as a serverless deployment platform
* Implementing an Intent-to-Docs agent that formats natural language into Markdown
* Deploying the agent to Cloud Run and Validating interactions with the ADK interface
* Running load tests and observing Cloud Run autoscaling behavior
Key Takeaways:
* Understand how to build and deploy agents using the Agent Development Kit (ADK)
* Learn how Cloud Run simplifies deploying and scaling AI-powered services
* See a practical application of an agent built with Gemma for documentation and developer productivity
* Gain insights into production deployment patterns such as autoscaling, environment configuration, and API testing
Making Databases Conversational with Gemma
Context and Background
Working with databases often requires switching between two worlds: business intent expressed in natural language and precise SQL syntax. Non-SQL users struggle to write queries, while developers and analysts sometimes need to explain SQL back to stakeholders. Small Language Models (SLMs) are well-suited for this bidirectional translation, making database access and collaboration more seamless. This session introduces SQLSense, an ADK-powered agent that converts natural language into SQL queries and translates SQL back into plain intent.
Session Abstract
This session demonstrates how to build and deploy SQLSense, a production-ready ADK agent on Cloud Run that acts as a bidirectional SQL translator. By leveraging SLMs for structured outputs and instruction-following, SQLSense enables developers, analysts, and non-technical users to bridge the gap between human language and database syntax. Attendees will walk through implementation, deployment, validation, and scaling patterns for this agent.
What the Session Covers
• Introduction to SLMs and why they excel at structured tasks like query translation
• Overview of ADK and Cloud Run for agent deployment
• Implementing SQLSense to:
o Convert natural language intent into SQL queries
o Translate SQL back into human-readable explanations
• Deploying SQLSense to Cloud Run with environment configuration
• Validating interactions through the ADK interface
• Observing autoscaling and performance under load
Key Takeaways
• Learn how to operationalize a bidirectional SQL translator with ADK
• See how SLMs can simplify query generation and explanation
• Understand Cloud Run deployment workflows and autoscaling behavior
• Gain practical insight into building AI agents for data-driven teams
Small Model, Big Impact: Gemma + PEFT + Android Inference
Context and Background
As language models get smaller and more efficient, the frontier of innovation shifts from massive cloud inference to edge-level intelligence. Google’s Gemma models open new possibilities for developers to fine-tune and deploy LLMs directly on resource-constrained environments. In this session, I’ll share my experience building an end-to-end workflow — from lightweight model adaptation using LoRA/PEFT to evaluating performance locally with Ollama and deploying the resulting model seamlessly to an Android app.
Session Abstract
This session demonstrates how to efficiently fine-tune and deploy a small language model for real-world mobile use. We’ll explore how to adapt Gemma using parameter-efficient fine-tuning (PEFT) on a sample dataset, validate it in a local inference environment, and run it natively on Android. The talk blends technical insight with practical deployment lessons — perfect for developers aiming to bridge the gap between model training and mobile integration.
What the Session Covers
• Choosing Gemma as a base model for mobile-scale applications.
• Applying LoRA/PEFT for efficient, low-compute fine-tuning.
• Setting up evaluation and benchmarking using Ollama.
• Integrating the model into an Android app, covering quantization, inference flow, and performance optimization.
• Lessons learned from data preparation, adapter merging, and balancing model quality vs. latency.
Key Takeaways
• A practical roadmap from fine-tuning → evaluation → Android deployment.
• How to achieve meaningful LLM adaptation without large compute resources.
• Design strategies for on-device AI with low latency and strong UX.
• A real example of bringing small language models to production at the edge.
Small Model, Big Impact: Gemma + PEFT + Android Inference
Context and Background
As language models get smaller and more efficient, the frontier of innovation shifts from massive cloud inference to edge-level intelligence. Google’s Gemma models open new possibilities for developers to fine-tune and deploy LLMs directly on resource-constrained environments. In this session, I’ll share my experience building an end-to-end workflow — from lightweight model adaptation using LoRA/PEFT to evaluating performance locally with Ollama and deploying the resulting model seamlessly to an Android app.
Session Abstract
This session demonstrates how to efficiently fine-tune and deploy a small language model for real-world mobile use. We’ll explore how to adapt Gemma using parameter-efficient fine-tuning (PEFT) on a sample dataset, validate it in a local inference environment, and run it natively on Android. The talk blends technical insight with practical deployment lessons — perfect for developers aiming to bridge the gap between model training and mobile integration.
What the Session Covers
• Choosing Gemma as a base model for mobile-scale applications.
• Applying LoRA/PEFT for efficient, low-compute fine-tuning.
• Setting up evaluation and benchmarking using Ollama.
• Integrating the model into an Android app, covering quantization, inference flow, and performance optimization.
• Lessons learned from data preparation, adapter merging, and balancing model quality vs. latency.
Key Takeaways
• A practical roadmap from fine-tuning → evaluation → Android deployment.
• How to achieve meaningful LLM adaptation without large compute resources.
• Design strategies for on-device AI with low latency and strong UX.
• A real example of bringing small language models to production at the edge.
Supercharging Documentation with Cloud Run, ADK, and Gemma
Context and Background:
Small Language Models (SLMs) are increasingly practical for real-world developer workflows. Unlike large models that require heavy compute, SLMs are lightweight, cost-efficient, and can run in production environments with minimal overhead. Developers often capture notes, tasks, or meeting summaries in plain text, but struggle to consistently format them into clean documentation. This session shows how SLMs, combined with Google’s Agent Development Kit (ADK) and Cloud Run, can be used to build an Intent-to-Docs agent that automatically formats natural language into Markdown, making documentation faster and more reliable.
Session Abstract:
This session demonstrates how to build and deploy a production-grade ADK agent on Cloud Run that converts free-form text into structured Markdown documentation. By leveraging small language models (SLMs) and focusing on deployment patterns, attendees will learn how to operationalize lightweight AI agents built with Gemma in real-world developer environments. The workshop highlights service configuration, backend integration with ADK, validation via the ADK interface, and scaling under load.
What the Session Covers:
* Introduction to ADK and its role in building agents
* Overview of Small Language models and the Google's Gemma family
* Overview of Cloud Run as a serverless deployment platform
* Implementing an Intent-to-Docs agent that formats natural language into Markdown
* Deploying the agent to Cloud Run and Validating interactions with the ADK interface
* Running load tests and observing Cloud Run autoscaling behavior
Key Takeaways:
* Understand how to build and deploy agents using the Agent Development Kit (ADK)
* Learn how Cloud Run simplifies deploying and scaling AI-powered services
* See a practical application of an agent built with Gemma for documentation and developer productivity
* Gain insights into production deployment patterns such as autoscaling, environment configuration, and API testing
Mayur Madnani
Principal Engineer
Hyderābād, India
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