BFFs could be your new Best Friends Forever

An introduction to Backend for Frontend pattern and how we are trying to move to a better architecture using the same at Prezzee. The talk explains about the common problem that many organisations face when trying to move from monoliths to micro-services and how having BFFs could be helpful. I also talk about when not to use BFFs and can give a brief overview and demo of how we might implement it in Google Cloud.

Setting Up CloudFront for Active-Active Global Architecture with Latency-Based Routing

In this advanced session, we'll dive into the intricacies of setting up an active-active global infrastructure to enhance your company's global services.
We'll start by exploring what is active-active architecture and different routing policies, followed by a detailed example of a global service deployed across three regions with latency-based routing.
We'll then introduce AWS CloudFront and demonstrate how integrating it with Route 53 can provide both low latency and robust performance.
We'll also discuss potential risks and mitigation strategies. We will also touch on caching mechanisms and WAF, and conclude with a fully operational global service setup along with multiple demos!
This talk is designed for professionals aiming to implement multi-region architectures and optimize service accessibility worldwide.

API Destinations for Private Endpoints: From Oversight to Insight

In this talk, we'll go through a real-world design challenge I faced while syncing data from a monolith to a microservice. I'll share the different approaches I explored and highlight how EventBridge API Destinations simplify event-driven integrations. However, API Destinations were historically limited to public endpoints—until AWS re:Invent changed that!

You'll learn how to leverage VPC Lattice to securely route events to private/internal endpoints, eliminating the need for complex setups like SQS + Lambda when they aren't necessary. By the end, you'll have a clear understanding of how to streamline your architecture for internal API connectivity with AWS-native solutions.

Here's the article I published in AWSTip on the same topic:
https://awstip.com/api-destinations-for-private-endpoints-from-oversight-to-insight-777f41230743

From Spec to Chat: Build an OpenAPI AI Agent with ADK

Ever wished your APIs could just tell you what they do? In this workshop, we will use ADK (Agent Development Kit) with OpenAPI toolset which will make your static API specs to a dynamic chatty assistant!
You’ll connect an AI agent to your own APIs so it can explain endpoints, answer questions, and even call the APIs live. Walk away with a working agent (deployed to Cloud Run) that makes your API instantly more interactive, discoverable, and user-friendly.

From Hype to Hands-On: Building Smarter Apps with the Agent Development Kit

AI agents are more than hype — they’re a new way to design applications. In this talk, we’ll take a practical look at the Agent Development Kit (ADK) and how developers can use it to orchestrate multi-agent workflows. We’ll explore agent types, chaining strategies, and how to integrate tools and context effectively.
The session includes a demo of a point-based buying agent that showcases how agents can interact, make decisions, and deliver value in a real-world scenario. Expect less buzzword, more code, and practical lessons you can apply in your own projects.
Agenda:
- Introduction: What is ADK?
- Types of Agents & Patterns
- Tools, Context, Authentication
- Live Code: Create your own! How and where to start
- Demo: Point-Based Buying Agent
- Key learnings and takeaways

Build Your Own Tech News TL;DR App: Grounding, Cloud Run & No-Code Email Automation

Want to stay up-to-date with the latest tech news without spending hours reading articles?
In this workshop, you'll learn to build your own personalized "Too Long; Didn't Read" (TL;DR) tech news application!
We'll start by creating a powerful API using Node.js and Google Cloud's Grounding with Google Search. This API will automatically fetch and summarize the most recent tech news, providing you with concise and relevant updates. We'll then deploy this API on Cloud Run, making it accessible from anywhere.
But we won't stop there! We'll also explore the power of low-code/no-code solutions using Google Cloud's Application Integration. You'll learn how to create an automated workflow that sends you a daily email digest of your curated tech news.
By the end of this workshop, you'll have a fully functional TL;DR tech news application that you can customize to your specific interests, all while gaining hands-on experience with Grounding, Cloud Run, and low-code/no-code automation.

Postcards from the Cloud: Chaining MCP Servers with Gemini ADK

Let’s build something nostalgic — powered by modern AI.
In this hands-on workshop, we’ll create a cloud-deployed AI agent that:

- Fetches live weather from coordinates
- Transforms it into a poetic summary
- Generates a postcard image
- With a single prompt, chains multiple MCP tools to deliver the final postcard via email

Along the way, you’ll learn how to design and deploy composable AI systems using MCP and Gemini ADK. We’ll build and deploy custom MCP servers, connect to remote tools like Google Maps, experiment with generative media tools such as Imagen, store outputs in Cloud Storage, and orchestrate everything inside a production-ready agent deployed on Cloud Run.
Rather than jumping straight to complexity, we’ll progressively layer features — starting simple and adding advanced capabilities like image generation and email delivery as optional extensions. This approach ensures you walk away with a working system, whether you stop at the core agent or build the full multi-service pipeline.
By the end, you won’t just have built a postcard agent — you’ll understand how to chain MCP servers, deploy polyglot tool services, and evolve an agent into a reusable backend service.

Getting Started with MCP, ADK and A2A

Let’s build a Currency Agent - and along the way learn how to create and deploy MCP servers with authentication, integrate them into an agent built using the Agent Development Kit (ADK) via Cloud Proxy, and finally expose the agent using the Agent-to-Agent (A2A) protocol so other agents can discover and interact with it! 🚀

Yes - MCP, ADK, A2A, Cloud Proxy… all the buzzwords and jargon, demystified in one hands-on workshop 😄

The workshop: https://codelabs.developers.google.com/codelabs/currency-agent#0

AI Agents are Distributed Systems

AI agents aren't magic. They're distributed systems — with better marketing.

I built a simple multi-tool agent with MCP and Google ADK. Then I pushed it into production, and every "simple" step became a reliability problem: tools as independently deployed services, stdio meeting HTTP, side effects that worked fine on localhost failing in new ways.

Managed platforms have absorbed some of this since. The problems underneath haven't moved: protocol versions still drift, side effects still fail halfway, auth contexts still multiply with every tool.

This isn't a code walkthrough. It's a systems story — about what changed when the agent left localhost, and what's still true no matter what platform it's on.

If you're building agents meant to survive outside a notebook, this talk is about the parts no one shows in the demo.

AI Agents are "Still" Distributed Systems

The hard part didn't go away. It moved up a layer — with better marketing.

Last time, I told this crowd my agent forgot who I am. Distributed state problem — didn't know how to fix it yet.

I fixed it. Sort of. I gave it memory. It works — and it now rewrites system instructions on every turn to inject that memory back in. Prompt caching, gone. Latency, up. Still no clean answer.

Meanwhile the ground moved. What I hand-built last time — sessions, memory, early observability — managed platforms now do out of the box. The hard part didn't get solved. It moved: from inside the agent to the layer between the agent and everyone trying to reach it. A BFF standing in as security. CORS pretending to be auth.

I'll cover what solving memory actually cost, what's still unsolved (the side-effect problem is still a problem — ask me about a corrupted postcard), and the layer I didn't know existed until I went looking: gateways, policy enforcement, and the gap between "I deployed an agent" and "I deployed one I'd trust with someone else's traffic."

Still not perfect. But I know exactly which parts are engineering problems I've solved — and I can see the shape of the next one.

The hard part didn't go away. It moved up a layer — with better marketing.

Deploy, Proxy, Ship: Build a Full-Stack Agent That Remembers You

Everyone can vibecode a chatbot in an afternoon. Almost nobody can tell you what happens when it needs to talk to a real frontend, remember who you are, and not fall over when someone other than you tries to use it.

In this hands-on workshop, you'll build and deploy a complete agent stack from scratch: an agent on Google's Agent Platform using agents-cli, a FastAPI BFF that proxies requests to it securely, and a vibecoded React chat interface that talks to it through that BFF. By the end, your agent will remember things about you across sessions — and you'll watch it happen live, in a UI built to show exactly what it's storing and recalling.

Along the way, we'll hit the same walls I hit writing the guide this workshop is based on: why CORS isn't a security boundary, what breaks when you swap the agent underneath your BFF, and where the architecture still has gaps — auth, Agent Gateway, Model Armor — that we'll name honestly rather than pretend are solved.

You'll leave with a working, deployed, memory-enabled agent stack of your own, and a clear map of what production-grade would still require beyond it.

Bring: a laptop, a Google Cloud project, and patience for at least one live demo gremlin.