DEV Community: Aryan Irani

Chatting with your Data: Conversational Analytics in BigQuery

Aryan Irani — Sat, 20 Jun 2026 07:45:01 +0000

For the last decade, the workflow for Business Intelligence hasn't changed much: A business stakeholder asks a question, a Data Engineer writes the ad-hoc SQL, and a dashboard is built. But as data scales to the petabyte level, this reactive cycle creates massive bottlenecks.

What if business users could just chat directly with the database?

Enter BigQuery Conversational Analytics. Google Cloud has effectively turned the traditional data warehouse into an active participant. By leveraging Gemini, Conversational Analytics allows users to query massive datasets using natural language. It understands the intent, generates the complex SQL, and returns the data (or geographic visualizations) instantly.

The Problem with "Text-to-SQL" Toys

We've all seen the basic "Text-to-SQL" AI wrappers on Twitter. They look great in a controlled demo, but they fall apart in production. Why? Because raw LLMs don't understand your company's unique business logic. If an AI doesn't know that your definition of "Net Profit" excludes returned items, the data it returns is not just wrong - it's dangerous.

To deploy AI over enterprise data, you need strict governance.

You need to be able to explicitly teach the AI your database schema. You need Dataplex Glossaries to lock down business terminology so the AI never guesses a formula. You need Parameterized Verified Queries to ensure highly sensitive financial reports use pre-approved SQL. And crucially, you need Financial Controls (like Maximum Bytes Billed) so a business user asking a vague question doesn't trigger a $5,000 table scan.

BigQuery Conversational Analytics isn't just an AI wrapper; it's a governed enterprise agent.

The Playlist: Build It Yourself

I spent the last few weeks using this product. To show you exactly how you can get started, I recorded a 4-part vide playlist on YouTube.

If you are a Data Engineer, Cloud Architect, or BI Analyst, this series will show you exactly how to build and govern your own AI data agents from scratch:

📺 Part 1: The AI Reasoning Pipeline We dive into the BigQuery Studio UI and test Gemini's ability to perform comparative analysis on the Google Trends public dataset without writing a single line of SQL.

📺 Part 2: Building Custom Data Agents An AI can't magically understand your database schema. I show you how to connect your tables and write System Instructions to explicitly control the SQL that Gemini generates.

📺 Part 3: Enterprise Data Governance We tackle the hardest part of Enterprise AI. I show you how to lock down your agent using Column Metadata, Dataplex Glossaries, and strict financial controls to prevent petabyte-scale billing surprises.

📺 Part 4: Automating Multi-Table Relational Joins In the grand finale, we use everything we've built to force the agent to write a flawless, massive 3-table relational JOIN from a single natural language prompt.

The role of the Data Engineer is shifting from writing ad-hoc SQL to governing autonomous data pipelines. If you're building in Google Cloud, I highly recommend getting hands-on with this.

You can watch the full series here: https://youtube.com/playlist?list=PL_MCVBMm-9sogdOzjqIcbX-dAizXux91c&si=890s67FrqxYfZTeu

Feel free to reach out if you have any issues/feedback at aryanirani123@gmail.com.

Google Workspace Studio Tutorial: The New 'Notify by Email' Action

Aryan Irani — Tue, 16 Jun 2026 12:19:35 +0000

If you run a product or manage technical operations, you likely have a Google Sheet somewhere that acts as a dumping ground for unstructured data. Whether it's customer feedback, bug reports, or feature requests, that spreadsheet grows every single day.

Manually reading through hundreds of rows every Friday just to summarize the "vibe" and identify blockers for the executive team is tedious, repetitive work.

In this tutorial, we are going to completely automate that process using Google Workspace Studio.

We are going to build an event-driven pipeline that wakes up on a strict schedule, extracts the raw data from your Google Sheet, natively parses the tone and urgency, and uses Gemini to output a highly-structured executive summary directly into your inbox.

Here is the exact step-by-step architecture.

Step 1: The Scheduled Trigger

Instead of relying on a manual event—like a form submission or a file upload—we want this pipeline to run autonomously. In Workspace Studio, create a new flow and set the Starter to On a schedule. You can configure this to act exactly like a cron job.

Configure the following fields:

Start date and time: Set this to your desired starting Friday at 4:00 PM (or 8:00 AM, depending on when you want the report).
Repeat: Select Weekly.
Ends: Set to 1 year (or your preferred duration).
Time zone: Ensure this matches your local working hours (e.g., (GMT+05:30) India Time).

Step 2: Data Extraction & Structuring

Next, we need to pull the raw data into the pipeline runtime. Instead of just dumping a massive, unstructured spreadsheet directly into an LLM, we can use Workspace Studio's native Extract node to structure it first.

Add an Extract node.
In the "Content to analyze" field, paste the direct link to your target Google Sheet.
Under "What to extract", select the predefined option: Sentiment: tone and urgency.

By doing this, Workspace Studio automatically parses the massive spreadsheet behind the scenes and generates two distinct, structured variables for our next step: {{Tone}} and {{Urgency}}. This significantly reduces AI hallucinations.

Step 3: Data Analysis (Ask Gemini)

This is the core logic node where we take those extracted variables and format them into a readable report.

Add an Ask Gemini node.
Click the + Variables dropdown and insert the {{Tone}} and {{Urgency}} variables generated from Step 2.
Append strict system instructions to force a structured output.

Because the Extract node already did the heavy lifting of determining the sentiment, our runtime prompt can be incredibly simple and targeted:

You are an Ops Manager. I have automatically extracted the overall tone and urgency from our weekly customer feedback spreadsheet. Tone: {{Tone}}. Urgency: {{Urgency}}. Based on these extracted variables, generate a professional Executive Summary. Highlight the overall sentiment and summarize the urgency of the technical blockers. Format as a clean report using bullet points.

Step 4: Generating the Report (Google Docs)

Now we need to get the output out of the pipeline and into a readable document.

Add a Create a doc node.
Set the Title: Executive Summary: Feedback.
Set the Body to the output variable from the Gemini node in Step3.

Step 5: Distribution (Gmail)

Finally, we need to distribute the report so you don't have to go digging through your Drive to find it.

Add a Notify me by email node.
Set the Subject to: [Automated Report] Weekly Feedback Summary.
In the Message field, copy and paste the following template. Use the + Variables dropdown to insert the dynamic variables where indicated:

Here is your automated weekly feedback report.
Overall Tone: {{Tone}} Urgency Level: {{Urgency}}
You can review the full executive summary and the breakdown of technical blockers here: {{Document_Link}}
(You can forward this document to the leadership team).

(Note: The 'Notify me by email' node automatically sends the email directly to the account running the workflow, making it perfect for a personal executive summary.)

Step 6: The Test Run & Output

Before blindly turning this on, you always want to run a test to ensure your variables are mapping correctly. Click the Test run button at the bottom of the Workspace Studio editor.

If everything is wired up correctly, you will see a beautiful wall of green checkmarks confirming that the pipeline successfully extracted the data, generated the document, and sent the email.

Check your inbox. You should have an email waiting for you that looks like this:

Because we used the Extract node, the pipeline correctly identified the tone of our mock data as negative and the urgency as urgent.

When you click the generated document link in the email, you'll see the real magic. Gemini successfully parsed the unstructured customer feedback, bypassed the generic complaints, and accurately identified the critical technical blockers (like the timeout errors and scheduled trigger failures).

The Verdict: Moving from Manual to Event-Driven

If you are still manually reading spreadsheets, parsing user feedback, and writing Friday summary emails from scratch, you are wasting valuable engineering and operational hours.

By combining a Scheduled Trigger with the new Extract and Notify me by email nodes, we just built a highly-resilient, event-driven reporting pipeline in under 10 minutes.

The beauty of this architecture is the clean separation of concerns:

Google Sheets acts as your raw data lake.
Workspace Studio's Extract Node acts as your data parser (which severely reduces LLM hallucination).
Gemini acts as your dedicated logic and reasoning engine.
Google Docs & Gmail act as your automated distribution layer.

You set it up once, and every single Friday at 4:00 PM, a perfectly formatted executive summary lands in your inbox. No manual prompting required.

Work With Me

I run a specialized software consultancy focused on building custom tools, AI integrations, and automation pipelines that help engineering and ops teams move significantly faster.

We just launched our brand new website, and we are currently taking on new clients. My core services include:

AI & Workspace Automation: Building custom Gemini architectures (like the pipeline above) directly into your business infrastructure.
Custom Software Development: Architecting scalable web applications and internal tools from the ground up.
Cloud Architecture: Secure GCP and Firebase infrastructure design.
Developer Relations & Content: Partnering with tech brands to create high-quality developer tutorials and video series.

If your team is dealing with manual bottlenecks, or if you need an expert to help architect a complex solution, check out my new site and let's get on a call.

👉 Website
👉 LinkedIn

Connecting GCP Budget Alerts to AppSheet: A Step-by-Step Guide

Aryan Irani — Fri, 12 Jun 2026 13:57:22 +0000

Have you ever woken up to a massive Google Cloud bill because a developer accidentally left a cluster running, or an API got stuck in an infinite loop?

Cloud "bill shock" is a rite of passage for many builders, but it can be avoided to a large extent. While Google Cloud allows you to set budget alerts that send you an email when you cross a threshold, an email doesn't stop the bleeding. By the time you see the email, log into your laptop, authenticate, navigate the Google Cloud console, and find the offending resource, you could be out hundreds or thousands of dollars.

What if, instead of an email, you got a push notification on your phone with a big red "Kill Resources" button?

In this comprehensive tutorial, we are going to bridge the gap between enterprise Google Cloud infrastructure and Google Workspace. We will build a serverless architecture using Cloud Functions, Pub/Sub, Google Sheets, and AppSheet to create a custom mobile app that gives you absolute, instant control over your cloud spend.

Whether you are a beginner looking to understand Event-Driven Architecture, or a seasoned architect looking for a rapid Low-Code internal tool, this guide will walk you through every single click and line of code.

The Architecture: How It All Connects

Before we write code, let's understand the flow of data. Event-driven architecture means one system yells into the void, and another system is waiting to catch it.

Google Cloud Billing detects a budget anomaly and publishes a payload to a Pub/Sub topic. Think of Pub/Sub as a massive post office.
An Ingest Cloud Function (Python) is subscribed to that post office. It catches the payload, parses the metrics, and uses the Google Sheets API to write a row to a Google Sheet.
AppSheet (a low-code platform) reads the sheet and instantly generates a mobile UI, sending a Push Notification to your phone.
When you tap the "Kill Resources" button in AppSheet, an AppSheet Automation Bot fires a Webhook.
A Remediation Cloud Function receives the webhook and executes a secure shutdown command against the target resource using the Google Compute API.

Let's build it step-by-step!

Step 1: Setting up the Database (Google Sheets)

Why Google Sheets? Because for rapid prototyping and internal tools, a spreadsheet is the easiest database to visually debug.

Open Google Sheets and create a new blank spreadsheet. Name it "Google Cloud Budget Alerts".
In the first row, create the following headers exactly as written: alert_id, budget_name, budget_amount, current_spend, threshold_percent, timestamp, status, project_id

Keep this tab open, we will need the Sheet ID from the URL later.

Step 2: The Ingest Pipeline (Pub/Sub & Cloud Functions)

Now we need Google Cloud to send data to our sheet whenever you spend too much money.

1. Create the Pub/Sub Topic

Open the Google Cloud Console and search for Pub/Sub.
Click Create Topic and name it budget-alerts. Uncheck "Add a default subscription" (our Cloud Function will create one automatically).

2. Connect Google Cloud Billing to Pub/Sub

This is the most critical link in the chain. We have to tell the Google Cloud Billing system to actually use the post office we just built.

In the Google Cloud Console, navigate to Billing -> Budgets & alerts.
Click Create Budget. Name it "development-budget".
Under Amount, set your target budget (e.g., $100).
Under Actions (this is the secret sauce), scroll down to the Manage notifications section.
Check the box for "Connect a Pub/Sub topic to this budget".
Select your Google Cloud Project and choose the budget-alerts topic we just created from the dropdown. Save the budget.

3. Deploy the Ingest Cloud Function

This Python script is the "glue" between the Google Cloud Billing alerts and Google Sheets.

Search for Cloud Functions in the Google Cloud console and click Create Function.
Select Gen 2. Name it ingest-budget-alert.
In the Trigger section, select Cloud Pub/Sub and choose your budget-alerts topic.
Expand the Runtime, build, connections and security settings, and add an Environment Variable named SPREADSHEET_ID. Paste the ID found in your Google Sheet's URL.
Click Next. Change the Runtime to Python 3.11.

In your requirements.txt, add these libraries so GCP knows what packages to install:

functions-framework==3.*
google-api-python-client==2.*
google-auth==2.*

In your main.py, paste this code.

import base64
import json
import os
import datetime
import uuid
import functions_framework
from googleapiclient.discovery import build
import google.auth

# 1. Initialize Google Sheets client securely
credentials, project = google.auth.default(scopes=['https://www.googleapis.com/auth/spreadsheets'])
sheets_service = build('sheets', 'v4', credentials=credentials)

@functions_framework.cloud_event
def ingest_budget_alert(cloud_event):
    SPREADSHEET_ID = os.environ.get('SPREADSHEET_ID')

    # 2. Decode the incoming message from Pub/Sub
    pubsub_message = base64.b64decode(cloud_event.data['message']['data']).decode('utf-8')
    alert_data = json.loads(pubsub_message)

    # 3. Extract the exact metrics we care about
    cost_amount = float(alert_data.get('costAmount', 0.0))
    budget_amount = float(alert_data.get('budgetAmount', 1.0))
    budget_name = alert_data.get('budgetDisplayName', 'Unknown Budget')

    threshold_percent = cost_amount / budget_amount
    alert_id = str(uuid.uuid4())[:8]
    timestamp = datetime.datetime.utcnow().isoformat()
    project_id = os.environ.get('GCP_PROJECT', 'my-test-project')

    # 4. Format the row and push to Google Sheets
    row_data = [
        alert_id, budget_name, cost_amount, cost_amount, 
        threshold_percent, timestamp, "PENDING", project_id
    ]
    body = {'values': [row_data]}

    sheets_service.spreadsheets().values().append(
        spreadsheetId=SPREADSHEET_ID, range="Sheet1!A:H",
        valueInputOption="USER_ENTERED", body=body
    ).execute()

    print(f"✅ Appended alert to Google Sheet.")

Crucial Step: When the function deploys, go to its "Details" page and find the Service Account email it is using (usually looks like 123456789-compute@developer.gserviceaccount.com). You must go to your Google Sheet, click the "Share" button, and add this email as an Editor! Otherwise, the script will get a Permission Denied error.

Step 3: Building the Low-Code Mobile App

We have data flowing into a spreadsheet. Now let's turn that spreadsheet into a mobile app in under 60 seconds without writing a single line of iOS or Android code.

Go to AppSheet.com and log in with your Google account.
Click Create -> App -> Start with your own data.
Select the "Google Cloud Budget Alerts" Google Sheet.

AppSheet will analyze your columns and instantly generate a working mobile app on your screen!

Creating the "Kill Switch" Action

We need a giant red button to press when disaster strikes.

In the left-hand menu, click on the Actions icon (the lightning bolt).
Click + New Action.
Configure it exactly like this:

Action Name: Kill Resources
For a record of this table: alerts
Do this: Data: set the values of some columns in this row
Set these columns: Choose status from the dropdown, and type "SHUTDOWN_REQUESTED" in the formula box.

4.Go to Appearance, choose a stop sign icon.

Step 4: The Remediation Engine (The Webhook)

Pressing a button in an app doesn't magically turn off a server on Google Cloud. We need Google Cloud to listen to AppSheet. We will deploy a second Cloud Function, this time with an HTTP Trigger, that acts as our Remediation Engine.

Go back to Cloud Functions and Create a new Function.
Name it remediate-budget-alert.
For the trigger, select HTTPS and choose "Allow unauthenticated invocations" (for this tutorial).
Copy the Trigger URL shown on the screen! You will need this for AppSheet.

Here is the Python code for main.py. This script listens for the HTTP request, verifies you actually pressed the button, and uses the Compute API to forcefully stop a virtual machine.

import os
import functions_framework
from googleapiclient.discovery import build
from google.auth import default

credentials, project = default()
compute = build('compute', 'v1', credentials=credentials)

@functions_framework.http
def remediate_resource(request):
    # 1. Parse the JSON sent by AppSheet
    request_json = request.get_json(silent=True)
    status = request_json.get("status")
    project_id = request_json.get("project_id")

    # 2. Security Check: Ensure the button was actually pressed
    if status != "SHUTDOWN_REQUESTED":
        return 'Ignoring status', 200

    print(f"🚨 SHUTDOWN AUTHORIZED. Commencing remediation...")

    # 3. The Kill Command!
    # (Hardcoded for this tutorial, but can be dynamic based on the payload)
    ZONE = 'us-central1-a'
    INSTANCE_NAME = 'demo-kill-switch-vm'

    request = compute.instances().stop(
        project=project_id, zone=ZONE, instance=INSTANCE_NAME
    )
    request.execute()

    return 'Shutdown successful', 200

Step 5: Closing the Loop (The Automation Bot)

Finally, we tell AppSheet to hit that HTTP URL whenever you press the red Kill Switch button.

In AppSheet, go to the Automation tab (the robot icon).
Click Create my first Bot -> Create a new Bot. Name it "Trigger Kill Switch".
Event: Select Data Change -> Updates Only on the alerts table.
Condition: Type exactly [status] = "SHUTDOWN_REQUESTED".
Action Step: Select Call a webhook.
Paste your Cloud Function HTTP URL from Step 4. Set the HTTP Verb to POST.

In the JSON Body, paste this:

{
  "status": "<<[status]>>",
  "project_id": "<<YOUR_PROJECT_ID>>",
  "alert_id": "<<[alert_id]>>"
}

Step 6: Testing the End-to-End System (The Demo)

A tutorial isn't complete until we prove that it works! We don't want to actually wait for our cloud bill to skyrocket to test this, so we will simulate a mock billing alert.

1. Send a Mock Payload

Open your terminal or Google Cloud Shell and create a script named test_alert.sh. Paste the following code, replacing YOUR_PROJECT_ID with your actual Project ID:

#!/bin/bash
PROJECT_ID="YOUR_PROJECT_ID"
TOPIC_NAME="budget-alerts"

PAYLOAD='{
  "budgetDisplayName": "development-budget",
  "alertThresholdExceeded": 1.0,
  "costAmount": 150.00,
  "budgetAmount": 100.00
}'
ENCODED_PAYLOAD=$(echo -n "$PAYLOAD" | base64)

gcloud pubsub topics publish $TOPIC_NAME \
    --project=$PROJECT_ID \
    --message="$ENCODED_PAYLOAD"

Run the script. This instantly fires a "100% budget exceeded" alert into our architecture.

2. Watch the Data Flow

Immediately check your Google Sheet. You will see a brand new row pop up instantly with the alert data and a status of PENDING. Check your phone or browser where AppSheet is open. Within seconds, a Push Notification will arrive: "🚨 GCP Budget Alert!".

3. Hit the Kill Switch

Open the AppSheet app. You will see the new development-budget alert in the UI. Tap the alert, and smash that red Kill Resources button we built in Step 3.

4. Verify the Shutdown

The moment you press that button, AppSheet fires the webhook to our Remediation Cloud Function. Navigate to Compute Engine -> VM Instances in your Google Cloud Console. You will see your target test VM's status transition from RUNNING to TERMINATED.

Conclusion

You have successfully built an event-driven, zero-latency cloud control system.

By combining the robustness of Google Cloud Functions with the rapid UI generation of AppSheet and Google Sheets, you've created a powerful internal tool. This architecture is incredibly extensible: in the future, you could modify the Python code to dynamically revoke IAM permissions, disable billing accounts entirely, or integrate with Cloud Monitoring for sub-minute predictive alerting.

The next time your cloud bill starts to spike, you won't need to scramble for your laptop. You just need to reach into your pocket.

Building a Content Pipeline: A Guide to the Workspace Studio + Gems Integration

Aryan Irani — Wed, 10 Jun 2026 11:14:05 +0000

Google just rolled out a major quality-of-life update for developers and ops teams: Custom Gems are now officially live inside Google Workspace Studio.

If your day-to-day involves building automations or wiring up LLMs, you already know how tedious prompt wrangling can get. You spend half your time managing context windows and copying/pasting massive system prompts just to ensure the AI returns a consistent output. This integration essentially automates away that headache.

In this tutorial, I'll break down exactly what Custom Gems are, why they matter for your workflow, and how we can use them to build a fully automated "Content Engine"—a system that intercepts rough text, extracts the raw data, and feeds it directly into a custom Ghostwriter Gem to generate perfectly formatted social media posts.

Prefer to watch instead of read? Check out the video version of the guide here.

What are Custom Gems?

If you’ve used OpenAI’s Custom GPTs, you already understand the basic concept. A Custom Gem is a specialized, pre-configured version of Gemini. Instead of starting from a blank chat interface every time, you define the AI's behavior once and save it as a reusable expert.

When building a Gem, you configure three main elements:

Persona & Instructions: This is your foundational system prompt. You define exactly who the Gem is (e.g., "Technical SEO Copywriter" or "Senior Data Analyst"), the rules it must follow, and the strict structure of its output (like JSON, markdown tables, or specific code blocks).
Knowledge Grounding: You can upload static files (PDFs, codebases, style guides) or link the Gem directly to live Google Drive documents. This gives the AI a dedicated context window based only on your company's actual data.
Constraints: Hard boundaries on what the AI should and shouldn't do, which is critical for keeping automated outputs predictable.

Why this changes the automation stack

Having a custom chatbot in your browser is helpful, but the real power unlocks when you bring Gems into Google Workspace Studio.

Instead of treating the Gem as a chatbot you have to manually converse with, Workspace Studio allows you to plug that custom Gem directly into automated, background workflows as an agent.

Rather than manually pasting text into an AI window, you can now build event-driven architecture. For example:

A new rough draft gets dropped into a specific Google Drive folder.
Workspace Studio triggers automatically, intercepting the file.
The raw text is routed to your custom "Editor Gem."
The Gem processes the text based on its pre-saved rules and knowledge base.
The polished output is automatically routed into a new Google Doc, a Slack channel, or a content scheduler.

You set up the prompt architecture once, and the AI runs in the background. No manual tweaking, no babysitting.

Let's look at how to actually build this.

Building a Zero-Touch Content Engine

To show you how this actually works in practice, I built an automated pipeline that takes my messy, unformatted brain-dumps and turns them into ready-to-publish social posts.

Part 1: Creating and Configuring the Custom Gem

Before building the automation pipeline, we need to configure the specialized "brain" that will handle our text transformation. A Custom Gem allows us to define strict boundaries, formatting rules, and system instructions once, making them reusable across any workflow.

Step 1: Open the Gems Interface

Navigate to your Gemini interface and locate the Gems Manager panel. Click on New Gem to initialize a blank workspace.

Step 2: Name and Describe Your Gem

Once you reached the Gems dashboard, go ahead and click on New Gem.

In the configuration panel, give your Gem a clear name and a concise description. This helps identify the correct node later inside Workspace Studio.

Name: My Technical Ghostwriter
Description: Transforms raw transcripts and markdown brain-dumps into structured LinkedIn and Twitter posts.

Step 3: Insert the Technical System Instructions

In the Instructions box, paste the exact rules governance for your AI. To ensure the output remains highly professional, engineering-focused, and free of typical marketing clichés, use the following structured prompt:

You are an expert technical ghostwriter for a Google Developer Expert (GDE) who focuses on automation, cloud infrastructure, and AI engineering.
Your job is to take raw brain-dumps or video transcripts and turn them into highly engaging social media posts (LinkedIn and Twitter).
CRITICAL RULES FOR YOUR TONE:

Never use AI fluff: Do not use words like "delve", "tapestry", "unlocking potential", "supercharge", or "game-changer."

Keep it punchy: Use short, direct sentences. Write like an engineer explaining something cool to another engineer over coffee.

Focus on the "How" and "Why": Always highlight the exact technical architecture or the exact problem being solved.

No heavy emojis: Use a maximum of 1 or 2 emojis per post. Never use rocket ships or fire emojis. Use simple structural emojis like 1️⃣ or 💬 if explaining a pipeline.

Formatting: Always include a clear hook (the problem), the architecture (the solution), and a call to action at the bottom. When provided with a raw transcript, generate exactly ONE LinkedIn post and ONE Twitter thread based on the content.

Step 4: Save and Test the Gem

Click Save in the top right corner. Run a quick manual test by dropping a messy paragraph into the chat window to ensure it strictly follows the formatting constraints and outputs exactly one LinkedIn post and one Twitter thread.

Part 2: Building the Workspace Studio Automation Pipeline

With the Gem ready, open Google Workspace Studio to build the event-driven architecture. The pipeline will contain 5 distinct blocks.

[Drive Trigger] ➔ [Extract Text] ➔ [Ask a Gem] ➔ [Create Doc] ➔ [Google Chat Notification]

Step 1: Set Up the Google Drive Trigger

We want the automation to watch a specific folder for incoming raw materials.

Add a new Trigger node to the canvas.
Select Google Drive as the app and choose When an item is added to a folder as the event.
Select or create a folder in your Drive named Raw Transcripts.

Step 2: Add the File Extraction Block

Workspace Studio needs to read the contents of the uploaded file rather than just passing the file object itself.

Go ahead and click on Choose a step, and select Extract under AI Actions.

2.Map the file ID from Step 1 into this block and define the output variable name as Raw Text.

Step 3: Integrate the Custom Gem Node

This is where we call our pre-configured expert.

Add a new action block and select Ask a Gem.

2.In the configuration settings, locate the Gem dropdown menu and select My Technical Ghostwriter.

3.In the Prompt field, map the dynamic text variable from your extraction block. Use a clean, direct instruction:

Please process the following transcript and generate the social media posts exactly as instructed in your system prompt. Here is the raw transcript text: {{Step 2: Raw Text}}

Step 4: Generate the Finalized Google Document

Instead of leaving the output in a log, we route it directly into a clean document for review.

Go ahead and click on Add step, followed by adding the Create a Doc action block to the workflow.

2.Set the Document Title to Social Draft - {{Step1: Name of item}}.

3.Map the body/content text field to the output generated by the Ask a Gem block in Step 3.

Step 5: Configure the Google Chat Notification

To eliminate the need to check Google Drive constantly, the final step pings your workspace chat when the task is complete.

1.Add a Google Chat action block. Select Notify me in Chat.

2.Construct a clean notification payload that passes the direct URL of the freshly created document:

💬 Content Engine update: A new social media draft is ready for review.
🔗 Edit Document: {{Step 4: Link to doc}}

Part 3: The Test Run

Before pushing this live, Workspace Studio has a built-in Test run feature.

When you click "Test run", it lets you select an existing file that is currently sitting in your target Google Drive folder. It will execute the entire pipeline against that specific file—extracting the text, prompting the Gem, and generating the Doc—without actually enabling the background listener.

Once you verify the output formatting is exactly how you want it, you just click "Turn on" to set the automation live.

Once the workflow finishes executing, open the newly created document inside Google Drive or click the link delivered to your Google Chat workspace.

The output is split exactly into the two requested formats—one comprehensive LinkedIn post and one structured Twitter thread—while strictly respecting our anti-fluff boundaries:

Why This Test Success Matters

Looking closely at the output, the Custom Gem followed every single negative constraint and structural guardrail perfectly:

Zero Marketing Fluff: There are no instances of generic buzzwords like "delve," "tapestry," or "game-changer."
Engineering Tone: The language is conversational but technically grounded, describing the setup as a "3-step architecture" and an "event-driven flow."
Emoji Discipline: The post uses exactly two structural numbering emojis (1️⃣, 2️⃣) instead of being cluttered with unnecessary fire or rocket graphics.
Perfect Formatting: Both formats lead with a distinct problem-focused hook, detail the underlying pipeline mechanics, and close with a clear call to action.

Conclusion

By moving away from manual chat interfaces and embedding Custom Gems directly into Google Workspace Studio, you transform an LLM from a passive assistant into an active, automated node in your development stack.

You write the architecture rules once, and the engine runs seamlessly in the background whenever new data enters your pipeline.

Building an AI Sales RFP Assistant with Google Workspace Studio & NotebookLM

Aryan Irani — Mon, 08 Jun 2026 08:08:51 +0000

If you are a Sales Engineer or Account Executive, you know that responding to a Request for Proposal (RFP) is a massive time sink. When a potential client asks, "Can you prove you've done this before?", you have to dig through Google Drive, read half a dozen old case studies, and manually copy-paste metrics to draft a response.

In this tutorial, we are going to automate the hardest part of RFP writing: the research.

Using Google Workspace Studio and NotebookLM, we are going to build an AI Research Assistant. When a salesperson drops an RFP into a Google Form, the workflow will instantly search your company's past case studies, map the client's requirements to your proven metrics, and generate a customized Google Doc draft for the sales team to review.

Prefer to watch instead of read? Check out the video version of the guide here.

The Traditional Workflow:

Receive an RFP.
Search Google Drive for "Cloud Migration Case Study".
Read through three old PDFs to find the one that mentions "cost savings."
Copy the metrics into a new Google Doc.
Spend an hour drafting the executive summary.

The New AI Workflow:

Submit the RFP requirements via a Google Form.
Workspace Studio asks NotebookLM to cross-reference the client's needs against your uploaded case studies.
Workspace Studio instantly creates a new Google Doc with a customized, metric-driven draft and pings the sales team in Google Chat.

The Step-by-Step Build Guide

Prerequisites: Setting up NotebookLM

Before building the automation, we need to build the brain.

Go to NotebookLM.
Create a new Notebook named "Past Proposals & Case Studies".
Upload your company's best marketing materials, case studies, and winning RFPs.

Step 1: Configure the Starter (Google Forms)

Open Google Workspace Studio. We want to trigger this flow whenever the sales team has a new lead.

Choose a starter.
Select When a form response comes in

3.Select the specific Google Form your team uses for RFP Intake. (Your form should ask for things like Client Name, Industry, and Core Requirements).

Step 2: The Reasoning Engine (NotebookLM)

This is where we map the incoming form data to our internal docs.

Click on Choose a step: NotebookLM -> Ask NotebookLM.

2.Point it to the notebook you created in Step 0.
3.Click the + Variables button to inject the form responses into your prompt.

Here is the exact prompt I used:

You are an RFP drafter. Review the client requirements below.
Search our past case studies and map our existing capabilities to these requirements. Pull the exact ROI metrics from our past work. Draft a 3-paragraph executive summary addressing their specific needs.
Client Name: {{Step1: Client Name}}
Client Industry: {{Step1: Client Industry}}
Core Requirements: {{Step1: Core RFP Requirements}}

Step 3: Generating the Output (Google Docs)

We want a collaborative document, not just a block of text in an email.

Click on Add a step: Google Docs -> Create Document.

2.New doc name: RFP Draft - {{Step1: Client Name}}
3.Content to add: Map the {{NotebookLM Output}} variable here.
4.Location for new doc: Select a specific Drive folder.

Step 4: The Alert (Google Chat)

Finally, let’s send a chat message when the draft is ready.

Click on Add step: Google Chat -> Notify me in Chat.

2.Map it to your channel and use this payload:

🎉 New RFP Draft Generated!
The initial research for {{Step1: Client Name}} is done.
Review and edit the draft here: {{Step3: Link to doc}}

The Test Run

Workspace Studio has a built-in test runner at the bottom of the canvas. To test it, I submitted a mock RFP for a fictional bank asking for a cloud migration with a strict 99.99% SLA and a 25% cost reduction.

I hit Test run. 15 seconds later, my Google Chat pinged with a link to a newly generated Google Doc.

Here is the exact output NotebookLM generated and dumped into the Doc:

Look closely at how NotebookLM structured that response. It didn't just summarize a document; it actively reasoned against the prompt. The mock RFP asked for a 25% cost reduction and a 99.99% SLA. NotebookLM searched the knowledge base, ignored the irrelevant cybersecurity and data analytics case studies, and extracted the exact metrics from our cloud migration case study.

It confidently stated: "we stabilized the client's environment to a guaranteed 99.999% SLA" and "yielded a verified 42.4% reduction in TCO." It even included citation markers (e.g., [1], [3]) so you can trace exactly which source document it pulled the data from.

By using Workspace Studio as the orchestration layer and NotebookLM as the grounded reasoning engine, we bypassed the biggest issue with LLMs in enterprise environments: hallucination.

Beyond RFPs: Scaling This Pattern

The architecture we just built is essentially a "Form-Triggered Research Agent," and you can apply this exact same template to dozens of other use cases across your organization:

HR Onboarding: Trigger a flow when a new hire submits their role and department via a form. NotebookLM reads your massive employee handbook and auto-generates a customized 30-day onboarding checklist in a Google Doc.
Customer Support: When a complex technical ticket is logged, Workspace Studio asks NotebookLM to search your internal troubleshooting wikis and drafts a technical response directly in Chat for the support engineer to review.
Legal Contract Drafting: Intake a vendor's basic details via a form, and have NotebookLM query your standard legal templates to generate an initial MSA draft.

The days of writing boilerplate Python scripts to string together basic RAG (Retrieval-Augmented Generation) pipelines are fading. With native integration inside Workspace Studio, you can build, test, and deploy grounded enterprise workflows in minutes.

(Standard disclaimer: As impressive as this is, NotebookLM explicitly warns in the UI that it can be inaccurate. Always have a human review the metrics before sending a proposal to a client!)

Automating Document Review with Google Workspace Studio and NotebookLM

Aryan Irani — Thu, 04 Jun 2026 08:53:08 +0000

If you work in IT, Legal, or Procurement, you know the pain of the Vendor Security Review. A vendor emails you a 50-page PDF outlining their privacy terms, and you have to manually cross-reference their document against your company’s internal Standard Operating Procedures (SOPs).

It is tedious, time-consuming, and highly prone to human error. What if they sneaked in a clause about 72-hour breach notifications when your policy strictly mandates 24 hours?

In this tutorial, we are going to fix that. We will build a fully automated workflow using Google Workspace Studio and NotebookLM that intercepts these documents, reads them, reasons against your internal rules, and instantly alerts you of any violations in Google Chat.

Check out the official update around the NotebookLM and Google Workspace Studio Integration.

The Traditional Workflow:

Receive an email with a vendor PDF.
Download the PDF.
Open your 30-page internal compliance rulebook.
Spend 45 minutes using Ctrl+F and reading legalese to find discrepancies.
Write up a summary email of the risks and send it to the team.

The New AI Workflow:

Receive an email with a vendor PDF.
Workspace Studio automatically saves the file, extracts the text, and asks NotebookLM to grade the vendor against your rulebook.
10 seconds later, you receive a bulleted risk summary in Google Chat.

Why Workspace Studio & NotebookLM?

This architecture is incredibly powerful because it separates the automation from the reasoning.

Workspace Studio acts as the connective tissue (the hands). It handles the Gmail triggers, Drive storage, text extraction, and Chat messaging.
NotebookLM acts as the grounded reasoning engine (the brain). By uploading your company SOPs directly into a Notebook, you ensure the AI's analysis is strictly grounded in your unique corporate rules, eliminating hallucinations.

Beyond Vendor Compliance: Make it Your Own!

While we are building a Vendor Compliance checker today, you can tweak this exact architecture to automate dozens of other workflows simply by changing the source document in NotebookLM and adjusting the prompt:

HR / Recruiting: Upload your ideal Job Description to NotebookLM. Have Studio intercept emails with resumes, and output a candidate grading summary to Chat.

Legal / Contract Review: Upload your standard Master Services Agreement (MSA). Have Studio intercept third-party redlines and flag unapproved changes.

Sales / RFP Responses: Upload your product documentation. Have Studio intercept incoming RFPs and draft the initial technical responses.

The Step-by-Step Build Guide

Let's build the workflow!

Prerequisites: Setting up NotebookLM

Before building the automation, we need to create the "brain."

Head over to NotebookLM.
Create a new Notebook and name it "Compliance & SOPs".
Upload your company's baseline rulebooks (e.g., your Data Privacy Standards, ISO 27001 requirements, etc.).

Pro Tip: You can manage up to 300 sources per notebook, with each source containing up to 500,000 words. You can dump all your governance documents here!

Step 1: Configure the Starter (Gmail)

Open Google Workspace Studio and create a new flow. We need to trigger this automation whenever a new document arrives.

Click Choose a starter.
Select Gmail -> New Email.
Configure the trigger conditions to catch vendor emails:
- Subject includes: "Vendor Assessment"
- Has Attachment: Yes

Step 2: Save to Drive

We need a place to securely store the raw PDF for record-keeping.

Click + Choose a step.
Select Google Drive -> Save Attachment.
Destination Folder: Select a specific, private folder in your Drive.

Important Security Note: Ensure the destination folder is restricted to your team. Currently, this Studio step cannot save attachments directly to Shared Drives.

Step 3: Extract Text (Gemini)

NotebookLM operates in a secure sandbox and cannot click external Drive links passed to it. We need to extract the raw text from the file first. Studio makes this easy with Gemini.

Click + Add step and choose the Extract action (powered by Gemini).
Content to analyze: Click "Variables" and map the {{Saved File URL}} (from the Google Drive step). The Extract step natively supports reading URLs!
What to extract: Scroll down to the Custom content name section.
- Custom content name: Document Text
- Description for Gemini: Extract the entire text content of this document exactly as it is.

Step 4: Ask NotebookLM

This is where the magic happens. We pass the extracted text to NotebookLM and ask it to find discrepancies against our SOP.

Click + Add step and choose NotebookLM -> Ask NotebookLM.
Select a notebook: Choose the Notebook you created earlier.
Enter a prompt: Construct your prompt like this:

You are an expert IT Compliance Auditor. Analyze the vendor terms provided below against our company compliance guidelines (your source document).
Identify any missing clauses or violations regarding data privacy, security certifications, breach notifications, and data residency.
Do not include conversational filler. Output ONLY a Markdown formatted list. For each violation, use a 🔴 emoji, state the vendor's policy, and state what our SOP requires instead.
Vendor Terms Context: {{Step3: Document Text}}

Step 5: Send to Google Chat

Finally, we deliver this risk assessment directly to the team so they can review it without leaving their chat window.

Click + Add step and choose Notify me in Chat.
Message Payload: Format it nicely using markdown and variables:

🚨 New Vendor Compliance Assessment 🚨
Received From: {{Step1: Sender email address}}
Document Reviewed: {{Step1: Full list-Email Attachments file name}}
NotebookLM Risk Summary:
{{Step4: Content created by NotebookLM}}
Review the raw document here:
{{Step2: Links to the files}}

Running a Test (The Moment of Truth)

Before you fully turn the workflow on for your entire organization, Google Workspace Studio gives you a powerful way to test it using real data.

Send a Test Email: First, send yourself an email with a sample vendor PDF attached. Use the subject line we defined earlier (e.g., "New Vendor Assessment: CloudService Inc").
Open the Test Panel: At the bottom of your Studio canvas, click the Test run button.
Select Your Email: A side panel will appear. Studio will automatically scan your Gmail inbox and let you select the test email you just sent from a dropdown.
Hit Start: Click the blue Start button. Note: A test run takes real actions! It will actually save the file to Drive and post the message in Chat.

The Result

Within seconds, my Google Chat space lit up. Instead of having to read a 50-page vendor PDF manually, NotebookLM instantly output this incredibly detailed risk assessment:

Conclusion

And just like that, we’ve bridged the gap between basic "if-this-then-that" automation and actual cognitive reasoning.

By combining the automation engine of Google Workspace Studio with the grounded, hallucination-free reasoning of NotebookLM, we didn't just automate a task—we automated a decision-making process. This architecture is highly scalable and can fundamentally change how enterprise teams handle documents, contracts, resumes, and RFPs.

What will you build? Once you have the foundation set up, the possibilities are endless. If you end up tweaking this workflow for your own HR, Legal, or Sales team, let me know in the comments below!

I Built an Autonomous AI Agent with Google ADK + Gemini That Spots Trends and Drafts Dev.to Articles for Me

Aryan Irani — Tue, 02 Jun 2026 09:43:33 +0000

Keeping up with trending technical topics and new tools on developer forums can be time-consuming. To save time, I wanted to automate the process of finding popular articles, reading the comments to understand community sentiment, and drafting a summary.

While I could write a standard Python script to scrape the dev.to API, simple scripts tend to be brittle. If an article doesn't have comments yet, a basic script will likely crash unless you write extensive error-handling logic.

Instead of a rigid script, I built an Agent—a program that can dynamically reason about errors and adjust its approach. If one task fails, it can figure out the next best step.

In this tutorial, I'll show you how to build a Trend-Spotting Agent using Python, the Google Agent Development Kit (ADK), and Gemini 2.5 Flash.

What We're Building

We are going to write a Python application that acts as an autonomous agent. We'll give it three abilities:

Search the dev.to API for rising technical articles based on specific tags.
Dynamically fetch the top comments of those articles to read real community sentiment.
Automatically draft a newsletter-style article on your DEV.to account summarizing its findings.

Prerequisites

Python 3.9+ installed on your machine.
Google ADK. (Check out the Google ADK Docs if you need help installing).
A DEV API Key. Grab this from your DEV.to account settings under "Extensions" and throw it in a .env file.

Step 1: Giving the Agent its "Hands" (API Tools)

Large Language Models (LLMs) are incredibly smart, but out of the box, they can't actually do anything on your computer.

The coolest part about Google ADK is that we can write standard Python functions, hand them to the LLM as "tools", and let the AI decide how and when to use them.

Let's write our API functions.

Tool 1: Finding Rising Articles

Here is our function to fetch rising articles. Pay close attention to the docstring ("""Fetches the top..."""). We aren't writing this for other developers; the ADK actually passes this docstring directly to the LLM so it understands exactly what the tool does.

import os
import requests

DEV_API_KEY = os.getenv("DEV_API_KEY")

def get_rising_articles(tag: str, limit: int = 5) -> str:
    """
    Fetches the top rising articles for a specific tag on DEV.to.
    Returns a formatted string of the articles with their ID, title, and URL.
    """
    url = f"https://dev.to/api/articles?tag={tag}&state=rising&per_page={limit}"
    response = requests.get(url, timeout=10)

    if response.status_code == 200:
        articles = response.json()
        summary = f"Top {limit} rising articles for '{tag}':\n"
        for i, article in enumerate(articles):
            summary += f"{i+1}. {article['title']} (ID: {article['id']})\n"
        return summary
    else:
        return f"Error fetching articles: {response.status_code}"

Tool 2: Fetching Community Comments

We don't just want our agent to read article titles; we want it to know what the community thinks. This function fetches the comments for a given article.

def fetch_comments(article_id: int) -> str:
    """
    Fetches the top comments for a specific DEV.to article by ID to gauge community sentiment.
    """
    url = f"https://dev.to/api/comments?a_id={article_id}"
    response = requests.get(url, timeout=10)
    comments = response.json()

    if not comments:
        return "No comments found on this article."

    summary_blocks = []
    # Grab up to the top 5 comments
    for i, c in enumerate(comments[:5]):
        user = c.get('user', {}).get('name', 'Anonymous')
        body = c.get('body_html', '').replace('<p>', '').replace('</p>', '').strip()
        summary_blocks.append(f"Comment {i+1} by {user}: {body}")

    return "Top Comments:\n" + "\n".join(summary_blocks)

Tool 3: The Ghostwriter

Finally, we need a way for the agent to report back. This function takes the agent's research and POSTs it directly to your Dev.to dashboard as an unpublished draft.

def create_article_draft(title: "str, body_markdown: str, tags: list[str]) -> str:"
    """
    Creates a new, unpublished article Draft on the user's DEV.to account.
    """
    url = "https://dev.to/api/articles"
    headers = {
        "api-key": DEV_API_KEY,
        "Content-Type": "application/json"
    }
    payload = {
        "article": {
            "title": title,
            "published": False,  # Keeps it as a safe draft!
            "body_markdown": body_markdown,
            "tags": tags[:4]
        }
    }

    response = requests.post(url, json=payload, headers=headers)
    if response.status_code == 201:
        data = response.json()
        return f"Successfully created draft! URL: {data.get('url')}"
    return "Failed to create draft."

Step 2: Wiring up the Agent

With our tools ready, we just need to initialize the Google ADK Agent. We give it a persona, drop in our functions, and let it go to work.

from google.adk.agents import Agent
from google.genai import types

agent_instruction = """
You are a Trend-Spotting Research Agent.
Every morning, or when requested, you monitor specific tags on DEV (Forem) to find the most interesting emerging technologies or topics.

Your workflow:
1. Use the 'get_rising_articles' tool to fetch the top rising articles.
2. Use the 'fetch_comments' tool on the most popular articles to evaluate the community's sentiment.
3. Synthesize the articles and the sentiment into an insightful trend report.
4. Use the 'create_article_draft' tool to automatically generate an unpublished DEV.to article containing your full synthesized report.
"""

root_agent = Agent(
    model="gemini-2.5-flash",
    name="trend_spotting_agent",
    description="Spots rising trends on DEV community and automatically drafts digest articles.",
    instruction=agent_instruction,
    # Here is where we hand over our Python functions!
    tools=[get_rising_articles, fetch_comments, create_article_draft],

    # Optional: configure automatic HTTP retries just in case the API drops
    generate_content_config=types.GenerateContentConfig(
        http_options=types.HttpOptions(
            retry_options=types.HttpRetryOptions(initial_delay=10, attempts=3)
        )
    )
)

And that is literally all the setup we need.

The "Aha!" Moment

To test this out, I spun up the ADK interface in my terminal (adk web) and gave the agent a fairly complex prompt:

"I need a complete trend analysis for the 'machinelearning' tag. Fetch the top 5 rising articles. Read the comments on the top article to gauge what the community actually thinks. Synthesize this research and draft a new DEV.to article for me titled 'The Community Pulse'."

I watched the terminal logs, and this is where the power of an Agentic workflow really clicked for me.

The agent easily retrieved the list of articles. It then grabbed the ID of the #1 article and called our fetch_comments(id) tool.

But there was a problem. Because it was a rapidly rising article, nobody had actually commented on it yet.

If this was a traditional scripted loop, the program would have just returned an empty array, moved on to the writing phase, and published a broken, empty newsletter.

But because this is an Agent, it analyzed the tool's response ("No comments found on this article.") and realized it couldn't complete my request. Without any prompting from me, the logs showed the agent dynamically pivoting:

"Okay, no comments on that one. Let's try the next most interesting one, 'Chapter 1: The Value Class'."
(Calls tool)
"Okay, no comments there either. Let's try 'Building a GPT From Scratch'."
(Calls tool)
"Still no comments. Last try, let's check 'Prove You're 18 Without Showing Who You Are'."

It iterated through the list, dynamically feeding the output of our tool back into its own reasoning loop until it successfully found a lively debate! It then analyzed the sentiment and proceeded to the final step.

With the research complete, the agent executed its final tool: create_article_draft().

When I opened my DEV.to dashboard, I had a fully formatted Markdown article sitting as an unpublished draft, ready for me to review.

Final Thoughts

Connecting normal REST APIs to the Google ADK framework completely changes how you think about automation. You don't need to write exhaustive edge-case logic or endless try/except blocks anymore.

You just build reliable, single-purpose tools, hand them over, and let the LLM figure out how to navigate the road bumps.

If you want to see the full source code for this project, you can check it out on my GitHub here: Link to Repo.

Let me know in the comments if you've built any interesting agents lately, and I'll see you in the next one!

Google Workspace Studio Tutorial: Turn Google Forms into a Full CRM - Auto Lead Capture, Personalized Emails & Team Notifications

Aryan Irani — Tue, 07 Apr 2026 16:53:56 +0000

As a consultant, I've learned one universal truth, The speed of your response determines the quality of your client relationships.

When a potential lead fills out a Get in Touch form on your website, they are at their peak level of interest. If you wait 24 hours to email them back, that interest cools down. If you don't log their details in a CRM immediately, they become a lost lead in your inbox.

In this tutorial, we are going to build a Lead Capture CRM Workflow in Google Workspace Studio. This agent doesn't just collect data - it manages the relationship, logs the lead, drafts the perfect welcome email, and alerts your team, all while you're doing something else.

The Workflow Logic: The Lead-to-Call Pipeline

Using Google Workspace Studio, the agent that we will build will do the following:

Automatically adds every new form submission to a professional Google Sheet
Uses Gemini to write a warm, personalized welcome email
Draft a personalized welcome email
Send you an instant alert in Google Chat.

If you missed the previous AI Email Labeller tutorial, start there for the basics. Prefer video? Click here.

Prefer to watch instead of read? Check out the video version of the guide here.

Prerequisites

Google Workspace Business, Enterprise, or Education plan with Gemini enabled
A Google Form ready (I used Consulting Business Inquiry Form)

A Google Sheet set up as your CRM (we'll map it live)

Step 1: Create the Flow & Add the Starter

Go to studio.workspace.google.com
Click + New flow and name it Lead Capture Agent: Forms to CRM, Email, and Chat
Click Choose a starter → Select When a form response comes in

Choose your form (in my case: Consulting Business Inquiry Form)

Step 2: Building the Ledger (Add a Row)

We need a single source of truth for our leads. Use the Add a row action to point to your Lead CRM Google Sheet.

Set Add row to After last data row. This instantly turns every submission into a clean, searchable CRM row. Map every form field to the correct column:

Timestamp → Step 1: Response time
Full Name → Step 1: Full Name
Work Email → Step 1: Work Email
Company → Step 1: Company (and so on for all fields)

Step 3: Ask Gemini to Write the Personalized Welcome Email

Click + Add step → Ask Gemini
Use this prompt:

Write a warm, professional, and personalized welcome email for a new lead based on the following form response. Make it friendly and mention that we've received their message and will get back to them soon. Use any available details like their name or company to make it feel unique.
Form Response: {{Step 1: Form response}}

Use the + Variables button to insert the specific Form response chip into your prompt. This is what grounds Gemini in your lead's actual data. This is where we go beyond simple data entry. Gemini turns raw form data into a human-sounding email.

Step 4: The Handoff (Gmail & Google Chat)

Finally, we put the agent to work:

Draft an Email: Use the Draft an email action to create a Gmail draft using the content Gemini just generated in Step 3.

Update Rows: Use the Update rows action to change the Lead Status to Draft Created and Welcome Email Sent to Yes. This gives you a bird's-eye view of your sales pipeline right inside your Sheet.

Pro-Tip: Ensure these columns exist in your Sheet first

Notify in Chat: Use the Notify me in Chat action to send an instant alert:

🚀 New Lead Captured:
Details: [Step 1: Form Response]
Email Draft: [Step 4: Email Body]
ID: [Step 4: Email ID]

Testing & Activation

Before you hand the keys of your lead intake over to an AI agent, you need to verify that it's connecting all the dots. Workspace Studio's Test Run feature is your best friend here. I tested with real leads (including the Project Quantum style inquiry and a general business inquiry). Once selected, go ahead and click on Start.

The agent:

Added the row instantly to the Sheet
Drafted a natural, personalized welcome email
Sent the email
Updated the status
Posted a clean notification in Chat

Once your test confirms that every step is green and the data is flowing correctly, it's time to go live. Go ahead and click the blue Turn on button. The agent is now live and will run on every new form submission.

Why this changes everything

By the time you open your laptop, your new lead is already in your CRM, a personalized email is drafted and waiting for your review, and your team is already celebrating the new opportunity in Google Chat.

You haven't just saved time - you've created a scalable sales process.

Conclusion

By the time you open your laptop, your new lead is already logged in your CRM, a personalized welcome email is drafted and waiting in Gmail, and your team has been notified in Chat.

You haven't just saved time - you've created a scalable, professional first-impression system that makes every potential client feel valued from the very first second.

This is the true power of Google Workspace Studio: turning simple forms into intelligent business processes that run 24/7 while you focus on what you do best.

What's Next?

This is the fourth tutorial of the Google Workspace Studio tutorial series. We've built Meeting Assistants, Inbox Gatekeepers, and now CRM Agents. But the possibilities are endless.

📺 Watch the full build: If you want to see exactly how I configured the logic gates for the CRM updates, check out the video in my Google Workspace Studio YouTube Playlist.

🚀 Join the Journey: Subscribe to my channel to see how we build more agents to solve real-world business problems.

💼 Consultation: Looking to deploy these AI agents across your entire team? Reach out via my website for a custom consultation.

Feel free to reach out if you have any issues/feedback at aryanirani123@gmail.com.

Google Workspace Studio Tutorial: Auto-Organize Your Inbox with Smart Labels & Priority Notifications

Aryan Irani — Thu, 02 Apr 2026 13:42:40 +0000

The average professional spends 28% of their workday reading and answering emails. But here's the problem, not all emails are created equal. A Pizza Discount doesn't deserve the same mental space as a Project Delay notification from a CEO.

So, I decided to fix it. I used Google Workspace Studio to build what I call an Email Organiser. It's an AI agent that actually reads my mail, labels it correctly, and - most importantly - only pings my Google Chat when something is actually on fire.

Here is how I built it (and how you can too, without writing a single line of code).

If you missed my previous tutorial on the Meeting Prep Agent, start there for the basics. Prefer to watch instead of read? Check out the video version of that guide here.

Prefer to watch instead of read? Check out the video version of the guide here.

What Is Google Workspace Studio? (Quick Recap)

Google Workspace Studio is Google's no-code AI agent builder (launched December 2025). It lets anyone describe a workflow in natural language, and Gemini builds the entire automation using your Gmail, Drive, Chat, Sheets, and more.

Key Features Used Here:

New email starter
Gemini-powered classification
Conditional actions (Decide step)
Add labels + Send Chat message

Prerequisites

Google Workspace Business, Enterprise, or Education plan with Gemini enabled
Access to studio.workspace.google.com
(Optional) Pre-create these Gmail labels: Urgent, Client, Internal, Marketing/Promo, Low Priority, Spam

Step 1: Add the Starter (Trigger)

Open studio.workspace.google.com and start a new flow. Name it something like AI Email Labeller + Priority Sorter.

Starter: Select When I get an email.
Settings: Keep it on All emails. We want this agent to act as our first line of defense for every message.

Step 2: The Logic Breakdown (The Extract Action)

After adding the When I get an email starter, the next crucial step is to let Gemini analyze the incoming email. In Workspace Studio, we use the Extract step (powered by Gemini) to intelligently process the email content.

In this step, we aren't just asking Gemini a question; we are using the Extract tool to pull specific metadata out of the raw email body. To make this reliable, we need to provide a rubric so the AI knows exactly how to judge your mail.

I've pointed it at the Email Body from Step 1 and created two custom fields. Think of this as giving Gemini a Rubric to follow. Instead of guessing, the AI is now acting as a professional assistant following a strict set of rules.

Here is how I configured the two custom content fields to make them Production-Ready:

1. Custom Field: Is High Priority

The Goal: A simple true/false result that we can use later to trigger a notification.
Description for Gemini:

Analyze the sentiment and urgency. Return 'true' ONLY if the email indicates a project-blocking issue, an immediate deadline (today/tomorrow), or a direct request for a deliverable from a known client. If it is a general update, a newsletter, or a 'thank you' note, return 'false'. Do not add any punctuation or extra text.

2. Custom Field: Classification

The Goal: This will be used to apply actual labels in your Gmail sidebar.
Description for Gemini:

Classify the email into exactly one of these categories: urgent, client, internal, marketing, newsletter or other.

Step 3: The Organization (Physical Labelling)

Now that Gemini has categorized our email in its mind, we need it to physically label the email in our Gmail inbox. This is where Step 3 comes in: the Add labels action.

Mapping the ID: First, we point the agent to the right email. In the Email to label field, use the + Variables **button to insert the[Step 1: Email ID]**. This ensures the agent is acting on the exact message that triggered the flow.
The AI-Powered Toggle: Notice the AI-powered labels switch. When you turn this on, you aren't just picking a static folder; you are giving Gemini permission to apply labels based on a description.

While Google provides great templates like Receipts or Meeting updates, the real power lies in the New AI-powered label button. This is where you can create a label that perfectly matches your workflow.

For example, I created a custom label called To Respond. Instead of a simple keyword search, I gave it this description:

Prioritize emails that require my direct action. This includes messages that ask a question, request a deliverable, need my review or approval, or are pending my response.
Crucially, exclude the following:

All automated notifications and system-generated emails (e.g., Drive file access requests, comment threads, or changes to shared documents).

All Google Calendar updates (accepted, declined, rescheduled, canceled) and meeting confirmations.

Broad announcements, newsletters, marketing, or promotional emails.

Informational notes that do not require a response, such as "thank you" messages.

By using custom descriptions, your labels become much more accurate than traditional Gmail filters. You aren't just looking for "Meeting" - you're looking for the intent to meet.

Step 4: Add the Decide Step (High Priority Check)

After classifying the email and applying the label, we need to decide whether this email is important enough to notify us in Google Chat.

This is where the Decide step comes in.

Click + Add step → Select Decide.
In the prompt field, paste the following: Is this email high priority?
Click the + Variables button and insert Step 2: Is High Priority.

The full prompt should now read something like:

Step 5: Check if the Decision is True

The Decide step only makes a decision - it doesn't automatically route the flow. We need a Check if step to act on that decision.

Click on Step 5: Check if
Set the condition as follows:

If → Select Step 4: Decision
is → true

This creates two paths:

True branch: High-priority emails (Urgent or Client) → We will send a Chat notification.
False branch: Normal emails → No notification (they only get labeled).

This branching logic is what makes the agent smart - it only bothers you for important emails.

Step 6: Add Notify Me in Chat

Now we add the final action that only runs for high-priority emails.

How to Configure Step 6:

Make sure you are on Check if step (Step 5).
Click Add substep → Select Notify me in Chat.
In the Message field, create a clean and useful notification using variables. You can add or remove variables as needed.

Testing and Activation

Now that the full flow is built, it's time to test it with real emails. I sent two very different emails to my inbox. I wanted to see if Gemini could distinguish between an important email and a casual request.

Case 1: High Priority

I sent an email regarding Project Quantum - Final Contract Feedback & Signature Required.

Back in the studio, go ahead and click on Test run and select the email you would like to work on, which in this case is the Project Quantum email. Once selected, click on Start.

The Content: It mentioned a London hub deployment and a deadline of today.
The Result: Gemini nailed it. In the Test Run, it identified that a signature was needed (Step 2 extraction: true) and classified it as a client request.

The Action: Because the priority was true, the Check if logic passed. My phone immediately pinged with a Google Chat notification: 🚨 High Priority Email Received.

Case 2: The Important but Quiet (Low Priority)

Next, I sent a follow-up: Question regarding the API Documentation.

Back in the studio, follow the same steps as we did previously to test the second email.

The Content: Sarah had a few questions but explicitly said, No rush at all.
The Result: Gemini recognized that Sarah was asking a question, so it applied the To respond and Support label in my Gmail sidebar . However, it also read the No rush sentiment and set priority to false.

The Action: The Check if logic stopped the flow. No Chat notification. My focus remained unbroken, but the email was waiting for me in the right folder when I was ready for it.

Going Live (Turn On)
Once you are happy with the test results, click the blue Turn on button. Within a few seconds, you'll see a confirmation snackbar at the bottom left:

Your flow is on and ready to work!

From this point forward, the AI agent is my primary filter. It organizes the chaos in the background and only interrupts me when the work truly demands it.

Note: The agent only acts on new emails received after it is turned on. Existing emails in your inbox will not be processed retroactively.

Conclusion

You now have a fully functional AI Email Labeler + Priority Sorter running in your Gmail.

It intelligently classifies every incoming email, applies the right label, and only notifies you when something genuinely requires your attention - giving you back hours of focus every week.

This is the real power of Google Workspace Studio: turning repetitive manual work into intelligent, automatic systems.

What's Next?

This is only the beginning of our journey with Google Workspace Studio. I have a full roadmap of content coming your way to help you master every corner of this platform:

🚀 More Workflows: Stay tuned as we build dedicated AI agents for HR Onboarding, Sales Lead Management, and Automated Expense Tracking.
🧠 Deep-Dive Tutorials: I'll be releasing specific guides on mastering Variables, optimizing your Starter triggers, and advanced Prompt Engineering to make Gemini even smarter.
📺 Follow the Youtube Playlist: You can catch every click-by-click build and all upcoming tutorials in my Google Workspace Studio Tutorial Series Playlist on YouTube.

Feel free to reach out if you have any issues/feedback at aryanirani123@gmail.com.

Google Workspace Studio Tutorial: Building an AI Meeting Prep Agent

Aryan Irani — Mon, 30 Mar 2026 08:48:00 +0000

We've all been there, where you have 60 seconds before your next meeting starts. You're searching your inbox for that one PDF a client sent three days ago, or trying to remember what was discussed in last week's thread.

In the past, you needed a human Chief of Staff or a complex web of Python scripts to solve this. Today, you just need Google Workspace Studio.

In this tutorial, we are going to build a Meeting Prep Agent. This AI agent will automatically wake up 15 minutes before any meeting on your calendar, scan your recent emails and documents for context, and send a concise Google Doc directly to your Google Chat.

If you haven't read my previous tutorial on building your first AI agent in Workspace Studio, start there for the basics. Prefer to watch instead of read? Check out the video version of that guide here.

Prefer to watch instead of read? Check out the video version of the guide here.

What Is Google Workspace Studio? (Quick Recap)

Google Workspace Studio is a no-code AI agent builder launched in December 2025. It lets anyone describe a workflow in plain English, and Gemini builds the automation flow for you.

Agents run securely inside your Google Workspace, respecting all your organization's permissions and data policies. No Apps Script, no third-party tools - just natural language and seamless integration with Calendar, Gmail, Drive, and Chat.

Key Features Relevant Here:

Based on a meeting starter - triggers relative to calendar events (e.g., 15 minutes before)
Powerful Gemini AI steps for summarization and reasoning
Variables that automatically pull meeting title, attendees, description, and more
Actions like creating Docs, sharing files, and sending Chat messages

Prerequisites

A Google Workspace Business, Enterprise, or Education plan with Gemini enabled
Access to Google Workspace Studio at studio.workspace.google.com
Make sure your admin has turned on the necessary features if you don't see Studio

The Workflow Logic

To build this, we'll use a specific four-part logic within the Workspace Studio editor:

The Starter: Triggered by a Calendar event (15 minutes before start).
The Research: Gemini scans your Workspace (Emails/Docs) for the meeting's participants and topic.
The Synthesis: Gemini summarizes the Latest State of Play.
The Delivery: The briefing is sent to you via Google Chat and saved as a Google Doc for your notes.

Step 1: Setting the Meeting Starter

Navigate to studio.workspace.google.com and create a new flow. Instead of using the Describe to Design box, we'll build this manually to ensure precision.

Click on Choose a Starter and select Based on a meeting.

You can always select a specific meeting, but for this case go ahead and select Every meeting.
Timing: Set this to 15 minutes before.
Start: You have the option to select Before and After meeting. Since the user needs to prepare for an upcoming meeting we are selecting Before meeting.

Once done, go ahead and click on Choose a step.

Step 2: Adding the Research Step

Now we need the agent to find the context. Add a new step and select Ask Gemini.

This opens the configuration window where you can talk to the AI in natural language. This is where you tell Gemini exactly what to look for. Because this agent is grounded in your Workspace, it can read your history to prepare you.

In the Enter a prompt box, copy and paste this structure:

I have an upcoming meeting. Here are the details:
Title: [Step 1: Meeting title]
Description: [Step 1: Event description]
Attendees: [Step 1: All guest full names]
Please search my recent emails with these attendees and any related Drive files to create a concise meeting briefing. Include key objectives, recent discussion points, and any action items I should be aware of.

Don't just type the bracketed text! Click the + Variables button in the bottom right of the prompt box. This allows you to select the Blue Chips from Step 1.

By mapping the Meeting Title, Description, and Attendee Names, you are giving Gemini the specific search terms it needs to scan your history.

Look at the bottom of the Ask Gemini panel. Under Sources Gemini can use, ensure All sources is selected.

Web Search: This allows Gemini to look up recent public news about the attendees or their companies.
Workspace: This is the magic part - it allows Gemini to securely read your internal emails and Drive files to find those specific action items mentioned in the prompt.

Step 3: Generating the Permanent Record (Create a Doc)

Once Gemini has finished its research, we want that information saved somewhere accessible. We'll use the Create a doc action to generate a dedicated briefing file in Google Drive.

Dynamic Naming: In the New doc name field, type Meeting Brief: and then use the + Variables button to insert the [Step 1: Meeting title] chip. This ensures every doc is perfectly organized and searchable in your Drive.
Populating Content: In the Content to add field, we don't want the raw meeting description; we want the intelligence Gemini just gathered. Insert the variable [Step 2: Content created by Gemini].
Location: : By default, your file will be saved in your My Drive root folder. However, if you want to choose a custom location, you can click on the Drive button to launch the Drive Picker.

Step 4: The Final Push (Notify me in Chat)

The last step is the delivery. Since you're likely on the move or prepping between calls, a Google Chat notification is the fastest way to get your briefing.

In the Message box, we are going to combine text with variables from all three previous steps to create a high-value notification:

The Header: Type Ready for your meeting: and insert [Step 1: Meeting title].
The Summary: Add a header for Briefing Summary: and insert [Step 2: Content created by Gemini]. This gives you the TL;DR right inside the chat app.
The Deep Dive: Add Full Briefing Doc: and insert [Step 3: Link to doc].

By including the link from Step 3, you can jump from your Chat app directly into the formatted Google Doc if you need more details during the meeting.

Step 5: Testing and Activation

With your logic built, it's time to move from Design to Deployment. Google Workspace Studio offers a powerful way to verify your agent before it goes live.

The Test Run (Verification)
Before you commit to the automation, click the Test run button at the bottom of the editor. This opens a configuration panel on the right.

Select a Meeting: In the Meeting dropdown, select an actual upcoming event from your calendar.
Execute: Click Start.
Important Note: A test run takes real actions. It will actually create the Google Doc in your Drive and send the message to your Google Chat. Use this to verify that the Gemini summary looks exactly how you want it.

Workspace Studio provides real-time feedback. As the agent runs, you'll see green checkmarks appear next to each step.

Step 1 & 2: Gemini immediately identifies the attendees, extracts the key objectives (server migration, budget gaps, GDPR compliance), and - most impressively - performs a Related File Search. It finds training scripts and meeting note folders related to Project Quantum inside your Drive.

Completion: Once you see the green Run Completed banner, the flow has successfully traversed from your calendar to your inbox, through Gemini's brain, and out to your productivity tools.

Going Live (Turn On)
Once you are happy with the test results, click the blue Turn on button. Within a few seconds, you'll see a confirmation snackbar at the bottom left:

Your flow is on and ready to work!

Your AI Meeting Assistant is now officially on duty. It will sit silently in the background and trigger automatically 15 minutes before every meeting on your calendar.

The true power of this agent is visible in the output it creates for you. Within seconds of the trigger, two things happen:

1. The Google Chat Briefing

You receive a notification from the AI Meeting Assistant app. It's not just a reminder; it's a full executive summary. It lists the date, time, attendees with their email links, and the core purpose of the meeting. It even includes a Note on Action Items - even if none were found, it gives you the peace of mind that it actually checked.

2. The Professional Briefing Doc

Simultaneously, a new document titled Meeting Brief: Project Quantum - EMEA Infrastructure Pivot Review is created in your Drive. This is a perfectly formatted document containing all the context Gemini gathered. You can open this doc during your call to take notes, knowing your background research is already done and documented.

Conclusion

By building this Meeting Prep Agent, you've done more than just automate a few clicks; you've fundamentally changed your relationship with your calendar. Instead of spending your day searching for context, you are now spending your day acting on it.

This workflow is a Force Multiplier. While you are focused on your current task, your AI agent is already working 15 minutes into the future, ensuring you walk into your next conversation with total confidence.

What will you build next?

The "Meeting Prep" agent is just the beginning. You can now take these same principles - Starters, Variables, and Actions - and apply them to every corner of your work.

Ready to dive deeper?

📺 Watch the Video: If you prefer a click-by-click walkthrough of this build, check out the video version in my Google Workspace Studio YouTube Playlist.
🚀 Master the Basics: If you're just starting out, read my previous deep-dive on Datcamp's Blog, to learn about different starters and logic flows.
💼 Custom Solutions: Looking to deploy these AI agents across your entire organization? Feel free to reach out via my website for a custom consultation.

Reflections on my Trainings: Gemini for Google Workspace

Aryan Irani — Sat, 28 Mar 2026 02:42:46 +0000

It's always an incredibly rewarding experience to engage with professionals eager to embrace new technology, and my recent live training sessions on Gemini for Google Workspace were no exception.
I recently conducted live trainings on Gemini for Google Workspace with O'Reilly Media Inc. - and one thing became very clear very quickly:

Most people aren't struggling with AI tools.
They're struggling with how to think with them.

These weren't passive sessions. Over the course of 4 hours, professionals jumped in, experimented live, built prompts, refined outputs, and saw immediate results. The turnout and energy were incredible - but what stood out more than anything was how differently people approached the exact same tool. Some were instantly building workflows. Others were still testing one-off prompts.

That gap - that difference in approach - is what this post is really about.

The "Why": More Than Just a Tool, It's a New Way of Working

In today's world, efficiency isn't just a nice-to-have; it's essential. From my years working with businesses and developers using Google Workspace, I've seen the daily grind firsthand. The hours spent wrestling with spreadsheet formulas, agonizing over the perfect email tone, or just facing that daunting blank page to start a new document. Gemini isn't just another feature; it's a fundamental shift. It's about augmenting our human capabilities, not replacing them.

The Secret Sauce: Mastering Prompts with the CRISP Method (My Personal Take)

When I first started playing around with Gemini, I quickly realized that the real magic wasn't just in the AI itself, but in how we talk to it. This is where prompt engineering comes in. My personal journey into mastering prompts using the CRISP method, really came from a place of wanting consistent, high-quality results. I found that by consciously applying Context, Role, Instruction, Specifics, and Purpose, I could transform those vague requests into exactly what I needed.

It was only when I started to improve my prompts that I saw Gemini truly perform as a powerful analyst, writer, or assistant. Sharing that learning curve and giving others a shortcut to getting those great results was what I was looking at.

Gemini in Action across Google Workspace

We explored Gemini's capabilities across the core Google Workspace apps, and I loved seeing the immediate impact.

Google Docs

What We Did: Overcame writer's block, drafted content from outlines, summarized long documents, and even refined text for different tones.
My Observation: Seeing participants go from a blank page to a draft proposal summary in minutes was incredible. The Content Multiplier demo, where we took one piece of content and transformed it into a LinkedIn post, a YouTube script, and a senior executive email, always gets the biggest reaction. It highlights how Gemini can truly adapt to our communication needs and save hours of manual work.

Google Sheets

What We Did: Cleaned messy data with natural language, generated formulas without syntax, analyzed data, created pivot tables, and visualized insights with charts.
My Observation: The "aha!" moments here are always around data analysis and formula generation. Watching someone who admitted to dreading VLOOKUPs confidently ask Gemini to find the email for Employee ID 105 and get it instantly, or seeing them create a complex pivot table just by describing it - that's incredibly powerful. It democratizes data insight, making analysis accessible to everyone.

Google Slides

What We Did: Generated slides individually, created custom AI images, refined text, and produced speaker notes.
My Observation: The AI image generation is always a showstopper! It's amazing to see participants realize they don't need to be graphic designers to create stunning, unique visuals for their presentations. The Micro Pitch Deck exercise really showed how quickly you can build a professional presentation and speaker notes, making the process much more efficient.

Gmail

What We Did: Summarized long threads, used conversational search, drafted and refined emails.
My Observation: Taming the inbox is a universal challenge. The immediate relief participants feel when they see how quickly Gemini can summarize long threads or draft professional emails with the right tone is palpable. It's about giving back valuable time and boosting confidence in communication.

Automation (Apps Script)

We've covered Gemini's power within Docs, Sheets, Slides, and Gmail, focusing on immediate productivity gains. Now, let's look ahead to the next frontier: AI-Powered Automation.

While Gemini offers incredible built-in features, its true potential is unlocked when we integrate its intelligence into custom workflows. This is where Google Apps Script becomes invaluable. It's the bridge that allows us to automate repetitive tasks and build intelligent agents that can work for us in the background.

During the training, I had the opportunity to showcase some of the tools I've been developing:

Comment AI: Your AI Commenting Assistant for Google Docs

What it is: I demonstrated a prototype Apps Script add-on called Comment AI. This tool leverages Gemini to analyze the text of a Google Doc and then suggest relevant, context-aware comments or feedback directly within the document. It can help users identify areas for improvement, suggest alternative phrasing, or even flag potential compliance issues, all based on intelligent AI analysis.
The Potential: Imagine the time saved in review cycles! Instead of manually adding notes, Gemini can pre-analyze and suggest improvements, allowing reviewers to focus on strategic feedback.

You can find a step-by-step guide for this project here:

Gemini-Powered Google Drive File Labelling & Filling:

What it is: I also showcased another Apps Script project focused on Google Drive. This tool uses Gemini to understand the content of files stored in Drive. Based on that understanding, it can automatically apply consistent labels, extract key metadata, and even auto-fill relevant properties.
The Potential: Think about organizing your entire Drive! Gemini can help tag documents by project, client, or topic, making file retrieval exponentially faster and more efficient. This is a game-changer for knowledge management and team collaboration.

These projects are early-stage, but they exemplify the power of combining Google Apps Script with Gemini's AI. It's about creating custom solutions for specific business needs, turning logic and intent into automated, intelligent workflows. While we didn't build these live, seeing them in action provides a tangible glimpse into what's possible when you integrate AI into your specific operational processes.

You can learn more about this project and how to set it up in my tutorial here:

https://aryanirani123.medium.com/automating-google-drive-labels-with-google-apps-script-a-step-by-step-guide-f5dd1a5b20d8

https://medium.com/google-cloud/automating-google-drive-labels-with-gemini-and-apps-script-9acb7beab6f8

The Key Takeaway: The future isn't just about using AI tools; it's about building AI into your workflows. As these technologies evolve, your ability to harness them through custom solutions will become an increasingly valuable skill.

My Experience: From Preparation to Connection

Crafting this training wasn't just about listing features; it was about deeply understanding the challenges professionals face daily and then showing them a practical, actionable path forward with Gemini. My background as a Google Developer Expert means I'm constantly exploring these tools, so my focus was on bringing real-world scenarios and genuine business value to every demo and exercise.

Building those hands-on activities to simulate real business tasks - like creating that executive briefing or analyzing messy data - is critical for making the learning stick. It's incredibly rewarding to see participants engage, ask those insightful questions, and achieve those tangible results in just a few hours.

What's Next

The response to these live sessions has been overwhelmingly positive, and it truly energizes me to see so many professionals eager to adopt AI.

We're moving toward a world where AI literacy is a core skill - and the ability to integrate tools like Gemini into real workflows will be a major differentiator.

I'm currently working on turning this training into a structured, self-paced course so more people can learn and apply these concepts at their own pace.

If you're exploring Gemini for Google Workspace - whether individually or for your team - I'd love to hear how you're approaching it.

Stay Tuned: Keep an eye out for the upcoming video course version of this training - it will offer even more depth and flexibility for self-paced learning!

Thank you for reading and for your interest in harnessing the power of AI and Google Workspace.

Feel free to reach out if you have any issues/feedback at aryaniran123@gmail.com

Building & Deploying a Google Cloud Storage MCP Server to Cloud Run

Aryan Irani — Sat, 07 Feb 2026 07:25:41 +0000

Model Context Protocol (MCP) is changing how we connect LLMs to external data. While running MCP locally via stdio is great for testing, the real power comes when you deploy these servers to the cloud, making your tools available to any agent, anywhere.

In this guide, I'm going to walk you through building a Google Cloud Storage (GCS) MCP Server, containerizing it, and deploying it to Google Cloud Run.

We will cover:

The Server Logic: Writing our own custom MCP server.
Containerization: Docker setup for Cloud Run.
Deployment: Permissions and Cloud Build commands.
Verification: Testing with the MCP Inspector.

So let's get started.

The Server Logic (server.py)

The biggest challenge with deploying MCP servers is the transport. Locally, we usually use Stdio (standard input/output). In the cloud, we need SSE (Server-Sent Events) over HTTP.

I didn't want to maintain two separate scripts, so I wrote a single server.py that detects where it's running. If it sees a PORT environment variable (which Cloud Run injects), it spins up a web server.

Here is the implementation using FastMCP:

# server.py
import os
import logging
from mcp.server.fastmcp import FastMCP
from google.cloud import storage

# Initialize FastMCP
mcp = FastMCP("gcs-mcp-server")

# Initialize GCS Client
storage_client = storage.Client()

@mcp.tool()
def list_buckets() -> str:
    """Lists all Google Cloud Storage buckets in the project."""
    buckets = list(storage_client.list_buckets())
    return "\n".join([bucket.name for bucket in buckets])

@mcp.tool()
def create_bucket(bucket_name: str, location: str = "US") -> str:
    """Creates a new GCS bucket."""
    bucket = storage_client.bucket(bucket_name)
    bucket.storage_class = "STANDARD"
    new_bucket = storage_client.create_bucket(bucket, location=location)
    return f"Created bucket {new_bucket.name} in {location}"

@mcp.tool()
def delete_bucket(bucket_name: str) -> str:
    """
    Deletes a GCS bucket. 
    WARNING: This forces deletion of all objects and versions inside.
    """
    bucket = storage_client.bucket(bucket_name)

    # Robust cleanup: List and delete all blob versions to avoid "Bucket not empty" errors
    blobs = list(storage_client.list_blobs(bucket_name, versions=True))
    for blob in blobs:
        blob.delete()

    bucket.delete(force=True)
    return f"Deleted bucket {bucket_name}"

if __name__ == "__main__":
    # DUAL MODE LOGIC
    if "PORT" in os.environ:
        # We are in Cloud Run -> Start an SSE Server
        import uvicorn
        port = int(os.environ["PORT"])
        print(f"Starting SSE server on port {port}...")

        # Critical for Cloud Run: Allow proxy headers and bind to 0.0.0.0
        uvicorn.run(
            mcp._sse_app, 
            host="0.0.0.0", 
            port=port, 
            proxy_headers=True, 
            forwarded_allow_ips='*',
            timeout_keep_alive=300 # Prevent SSE connection drops
        )
    else:
        # We are local -> Start Stdio Server
        mcp.run()

You'll notice I added some extra logic in delete_bucket. GCS is very protective; it won't let you delete a bucket if there's anything inside it. If you have Object Versioning turned on, a bucket might look empty but still have hidden archived files. My implementation explicitly hunts down every version and deletes it first.

Dockerizing (Keep It Simple)

We don't need a complex multi-stage build here. A simple Python slim image works perfectly.

The requirements.txt is minimal:

mcp[cli]
google-cloud-storage
uvicorn

And the Dockerfile:

FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "server.py"]

Infrastructure Setup

Before we deploy, we need to make sure your CLI is pointing to the right place and your project has permissions.

Step 2.1: Initialize gcloud

Open your terminal. If you haven't logged in recently, run:

gcloud auth login
gcloud config set project <YOUR_PROJECT_ID>

Step 2.2: Grant Permissions

By default, Cloud Run cannot manage Storage buckets. We need to find the Service Account that Cloud Run uses and give it the Storage Admin role.

Run these commands in your terminal:

# 1. Get your Project ID and Number
export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')

# 2. Grant the permission
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
    --role="roles/storage.admin"

Expected Output: You should see a YAML list of bindings updated with "Updated IAM policy for project [your-project-id]."

Deploying to Cloud Run

Instead of typing long commands every time, we use a deployment script. Save this as deploy.sh in your project folder.

#!/bin/bash
set -e

# Configuration
PROJECT_ID=$(gcloud config get-value project)
SERVICE_NAME="gcs-mcp-server"
REGION="us-central1"
IMAGE_NAME="gcr.io/${PROJECT_ID}/${SERVICE_NAME}"

if [ -z "$PROJECT_ID" ]; then
    echo "Error: No Google Cloud project selected. Run 'gcloud config set project <PROJECT_ID>' first."
    exit 1
fi

echo "Deploying ${SERVICE_NAME} to Project: ${PROJECT_ID}..."

# 1. Build the container image
echo "Building container image..."
gcloud builds submit --tag $IMAGE_NAME

# 2. Deploy to Cloud Run
echo "Deploying to Cloud Run..."
# Note: --allow-unauthenticated is used here for simplicity to allow easy testing.
# For production, remove this flag and configure IAM authentication.
gcloud run deploy $SERVICE_NAME \
    --image $IMAGE_NAME \
    --platform managed \
    --region $REGION \
    --allow-unauthenticated

echo "Deployment complete!"
echo "Service URL:"
gcloud run services describe $SERVICE_NAME --platform managed --region $REGION --format 'value(status.url)'

Running the Deployment

Now, make the script executable and run it:

chmod +x deploy.sh
./deploy.sh

What You Will See (Terminal Output)
Build Step: You will see a stream of logs starting with Creating temporary tarball... followed by Docker build steps (Step 1/5, Step 2/5). This ends with SUCCESS.
Deploy Step: You will see Deploying container to Cloud Run service [gcs-mcp-server] in project...

Success:


Service [gcs-mcp-server] has been deployed and is serving 100 percent of traffic.
Service URL: https://gcs-mcp-server-xyz-uc.a.run.app

Copy that Service URL. You need it.

Verification

Go to the Google Cloud Console and navigate to Cloud Run.

1. The Service Dashboard

Click on gcs-mcp-server. You should see a green checkmark indicating the service is healthy.

Revisions Tab: Ensure the latest revision is receiving 100% traffic.

Logs Tab: This is crucial. If your code crashes, this is where you look. You should see a log entry: Starting SSE server on port 8080.... If you see that, your code successfully detected the environment and started Uvicorn.

2. Testing with MCP Inspector

You don't need to write Python code to verify the server is working. Use the MCP Inspector from your terminal.
The Command:

npx @modelcontextprotocol/inspector \
  --transport sse \
  --server-url https://<YOUR-SERVICE-URL>/sse

Note: You MUST append /sse to the URL. The root URL / will likely give you a 404 or Method Not Allowed.

What You Will See: A web interface will open in your browser.

1.Start by establishing connection by clicking Connect.

2.On the left sidebar, click Tools and List Tools. You should see
list_buckets, create_bucket, and delete_bucket listed.

3.Click list_buckets and hit Run.

4.You should see a JSON response with your bucket names.

Conclusion

That's it! You've gone from a local script to a deployed, scalable microservice that acts as a tool for your AI agents.

By moving your tools to Cloud Run, you decouple them from your agent's runtime. Your agent can be a script on your laptop, a service in Vertex AI, or a workflow in a completely different environment - it doesn't matter. As long as it can hit that URL, it has access to your Google Cloud Storage tools.