AppSheet Custom Steps for Google Workspace Studio

Before we jump in a quick backstory, if nothing else to prove this entire post wasnโ€™t written with Gemini assistance. Just over a year ago I was fortunate to be a Workspace Studio tester (or Flows as was it called then). I was particularly excited by the ability of Extending Google Workspace Flows with Custom Steps using Google Apps Script. As Workspace Studio moved through the Gemini Alpha program to general availability, custom steps disappeared. This is very understandable given Workspace Studio was a new product and Google wanted to make sure users got to access a stable platform. The great news Google has now launched Automate workflows with custom starters and steps, third-party integrations, and webhooks in Workspace Studio.

With custom steps officially back I thought it was revisit an integration I had been experimenting with combining Workspace Studio with AppSheet. The code for this solution is published in the AppSheet Custom Steps for Google Workspace Studio repo and in this post, we’ll walk through:

  1. Why connect Workspace Studio to AppSheet?
  2. A Real-World Example: Intelligent IT Ticket Triage with Gemini & AppSheet
  3. How custom steps are structured in Apps Script (appsscript.json)
  4. The secret sauce: Dynamic schema discovery via Custom Resources
  5. Handling Single vs. Multiple Results: A Two-Tier Approach
  6. Testing & Deployment with Clasp (and the Admin Setting gotcha)
  7. How this project was built using AI coding agents with .agents/ skills

Why Connect Workspace Studio and AppSheet?

Google Workspace Studio is great for automations across Google Workspace allowing you to use Gemini assistance. AppSheet serves as a no-code application platform making it easy to create solutions for your business data. AppSheet Enterprise customers can already use Gemini AI automations to extract, categorise and summarize data, but getting data from a Workspace automation into AppSheet often required intermediary webhooks, custom API scripts, or relying on Google Workspace integrations to Sheets, Forms and Gmail.

With my custom Studio steps, powered by the AppSheet REST API, you have the ability to extend your apps capabilities using the growing list of Workspace Studio starter steps integrating with your AppSheet app to:

  • Add Rows: Directly push structured records into AppSheet tables.
  • Update Rows: Modify records and trigger AppSheet bot workflows in real time.
  • Find Rows: Run AppSheet formula expressions (such as FILTER("Technicians", [On Call] = TRUE)) and feed those records back into downstream Studio steps.

A Real-World Example: Intelligent IT Ticket Triage with Gemini & AppSheet

To see how this works in practice, let’s look at a common scenario, an automated IT helpdesk flow using a slightly modified version of the AppSheet standard IT Ticketing template.

In the IT Ticketing app the schema includes:

  • The Tickets table tracks issues (Issue ID, First Name, Last Name, Email, Description, Symptom, Assigned Tech, Date Created, Resolved).
  • The Technicians table tracks staff (Name, Department, IT Email, On Call boolean, and Can Cover skills: General Issues, Network, Website, Apps). The primary key for this table is IT Email.
  • The Symptoms table stores the allowed categories (Name, Department), used as an AppSheet Ref dropdown in the app.

Rather than forcing users to fill out a form manually or relying on rigid routing rules, we can combine Workspace Studio’s Gmail starter, Gemini steps, and our AppSheet custom steps into an autonomous triage pipeline:

[ Gmail Starter: New Support Email ]
                 โ”‚
                 โ–ผ
[ Step 2 : Find Rows (Fetch On-Call Technicians) ]
                 โ”‚
                 โ–ผ
[ Step 3: Find Rows (Fetch the apps Symptoms list) ]
                 โ”‚
                 โ–ผ
[ Step 4: Extract (Gemini extracts the required data for our app) ]
                 โ”‚
                 โ–ผ
[ Step 5: Add Rows (Create Ticket with Assigned Tech) ]

Step-by-Step Flow Breakdown

  1. Starter (Gmail): Studio listens for incoming emails sent to [email protected] or flagged with [IT Support] in the subject line.
  2. AppSheet Custom Step (Find Rows):
    • Studio queries the Technicians table with the selector:FILTER("Technicians", [On Call] = TRUE)
  3. AppSheet Custom Step (Find Rows):
    • Studio queries the Symptoms table for the current list
  4. Gemini Extract (Smart Triage):
    • Studio passes both the cleaned ticket details, the on-call technician records and our apps symptoms list to Gemini:
  1. AppSheet Custom Step (Add Rows):
    • Studio inserts the new record into Tickets.
    • The step outputs addedRow, immediately exposing newly generated fields (like Ticket ID or calculated dates) for the rest of the flow.
 [
   {
     "Name": "{{Step 1.Starter.Sender Display Name}}",
     "Email": "{{Step 1.Starter.Sender Email}}",
     "Description": "{{Step 4.Gemini.Description}}",
     "Symptom": "{{Step 4.Gemini.Symptom}}",
     "Assigned Tech": "{{Step 4.Gemini.IT Email}}"
   }
 ]

This pattern demonstrates the true power of combining Workspace Studio and AppSheet. Studio orchestrates Workspace events and AI reasoning, while AppSheet provides validated, related business data.


The Anatomy of a Workspace Studio Custom Step

Under the hood, a Workspace Studio custom step is an extension of the Google Workspace Add-on architecture defined in appsscript.json.

Each step declares its inputs, outputs, and two primary Apps Script callback functions:

  1. onConfigFunction: Renders the configuration card displayed in the Studio sidebar when a user selects your step.
  2. onExecuteFunction: Receives input variable bindings at runtime, executes the business logic, and returns output variables back to the flow.

Here is an extract from appsscript.json defining the “Add Rows” step, featuring both bulk JSON outputs and the Dynamic Custom Resource (addedRow):

{
  "id": "appsheet_add_rows",
  "state": "ACTIVE",
  "name": "Add Rows in AppSheet",
  "description": "Adds one or more rows to a specified AppSheet table.",
  "workflowAction": {
    "inputs": [
      { "id": "appId", "cardinality": "SINGLE", "dataType": { "basicType": "STRING" } },
      { "id": "accessKey", "cardinality": "SINGLE", "dataType": { "basicType": "STRING" } },
      { "id": "tableName", "cardinality": "SINGLE", "dataType": { "basicType": "STRING" } },
      { "id": "rowsData", "cardinality": "SINGLE", "dataType": { "basicType": "STRING" } }
    ],
    "outputs": [
      {
        "id": "addedRow",
        "description": "The first newly added row with individual column fields.",
        "cardinality": "SINGLE",
        "dataType": {
          "resourceType": {
            "workflowResourceDefinitionId": "appsheet_row_resource"
          }
        }
      },
      {
        "id": "addedRows",
        "description": "The full rows added, including server-computed values.",
        "cardinality": "SINGLE",
        "dataType": { "basicType": "STRING" }
      }
    ],
    "onConfigFunction": "onConfigAddRows",
    "onExecuteFunction": "onExecuteAddRows"
  }
}

Notice that addedRow has a dataType pointing to appsheet_row_resource. At the top level of addOns.flows, we declare this custom resource alongside a dynamic definition provider:

"workflowResourceDefinitions": [
  {
    "id": "appsheet_row_resource",
    "name": "AppSheet Row",
    "providerFunction": "onDynamicAppSheetRowProvider",
    "resourceType": "DYNAMIC"
  }
],
"dynamicResourceDefinitionProvider": "onDynamicAppSheetRowDefinition"

Dynamic Schema Discovery via Custom Resources

One challenge with database integrations in no-code flow builders is usability. Asking users to hand-write raw JSON payloads or use secondary “Extract” steps to parse out field names isn’t straightforward.

Initially, I tried adding interactive buttons in the configuration card (e.g. a “Fetch Columns” button). However, Google Workspace Studio does not currently display interactive CardService action buttons or in-place card replacement widgets.

Whilst it is not possible to dynamically add input fields to a step, you can dynamically expose the outputs using Dynamic Custom Resources. With Dynamic Custom Resources, you can dynamically update the schemas to define individual column variables automatically.

How it Works Behind the Scenes

  1. Design-Time Schema Introspection (onDynamicAppSheetRowDefinition):
    When the user configures the step in Studio (entering their App ID, Access Key, and Table Name), Studio calls onDynamicAppSheetRowDefinition(e). Apps Script queries AppSheet using TOP(FILTER("Table", TRUE), 1) to discover existing column headers, registering each as an individual ResourceField:
function onDynamicAppSheetRowDefinition(e) {
  const resourceDefinitions = AddOnsResponseService.newDynamicResourceDefinition()
    .setResourceId("appsheet_row_resource");

  const inputs = e.workflow?.resourceFieldsDefinitionRetrieval?.inputs || {};
  const appId = inputs.appId?.stringValues?.[0];
  const accessKey = inputs.accessKey?.stringValues?.[0];
  const tableName = inputs.tableName?.stringValues?.[0];

  if (appId && accessKey && tableName) {
    const AppSheet = new AppSheetApp(appId, accessKey);
    // Fetch schema sample (cached for 6 hours to keep editor fast)
    const sample = AppSheet.Find(tableName, [], { "Selector": `TOP(FILTER("${tableName}", TRUE), 1)` });
    if (sample && sample.length > 0) {
      Object.keys(sample[0]).forEach(colName => {
        resourceDefinitions.addResourceField(
          AddOnsResponseService.newResourceField()
            .setSelector(colName)
            .setDisplayText(colName)
        );
      });
    }
  }

  const workflowAction = AddOnsResponseService.newResourceFieldsDefinitionRetrievedAction()
    .addDynamicResourceDefinition(resourceDefinitions);

  return AddOnsResponseService.newRenderActionBuilder()
    .setHostAppAction(AddOnsResponseService.newHostAppAction().setWorkflowAction(workflowAction))
    .build();
}

  1. Step Execution & Caching (onExecuteFunction):
    When the step runs, it executes the AppSheet API operation, caches the row data in CacheService under a unique UUID ("row_find_" + Utilities.getUuid()), and returns a resource reference variable alongside the standard JSON output:
const variables = {
  "firstRow": AddOnsResponseService.newVariableData().addResourceReference(resourceId),
  "foundRows": AddOnsResponseService.newVariableData().addStringValue(JSON.stringify(foundRows)),
  "rowCount": AddOnsResponseService.newVariableData().addIntegerValue(foundRows.length)
};

  1. Runtime Value Resolution (onDynamicAppSheetRowProvider):
    When a downstream step references a chip like Step 2 > First row > IT Email, Studio calls onDynamicAppSheetRowProvider(e) with the resourceId. The provider grabs the cached row and returns the requested column values on the fly.

Handling Single vs. Multiple Results: A Two-Tier Approach

When building steps that interact with databases, you inevitably face a question: What happens if the query returns one row versus ten rows versus zero rows?

In Google Workspace Studio’s currently, custom resources strictly mandate "cardinality": "SINGLE":

“The output variable has a dataType with the property resourceType. The value of cardinality must be SINGLE.”

Because Studio does not yet support repeated arrays of custom resource chips, our custom steps implement a two-tier output design:

StepOutput VariableType & CardinalityBest ForBehavior
Find RowsfirstRowDynamic Custom Resource (SINGLE)Single result / First matchExposes individual column chips (Email, Name, ID, etc.) directly to downstream steps.
foundRowsString (JSON Array) (SINGLE)Multiple resultsContains the full JSON array [ {...}, {...} ] of all matching rows.
rowCountInteger (SINGLE)Conditionals & branchingThe total number of rows found (0, 1, 5, etc.).
Add RowsaddedRowDynamic Custom Resource (SINGLE)Single record addedExposes column chips of the newly created row (useful for generated IDs or computed columns).
addedRowsString (JSON Array) (SINGLE)Bulk additionsFull JSON array of all rows inserted.
Update RowsupdatedRowDynamic Custom Resource (SINGLE)Single record updatedExposes column chips of the updated record.
updatedRowsString (JSON Array) (SINGLE)Bulk updatesFull JSON array of all updated rows.

How Flows Use This in Practice:

  • Single Record Workflows: Use firstRow, addedRow, or updatedRow chips directly in downstream steps (Gmail, Google Docs, Slack, Chat) without any formula or extraction step. If 0 rows match, chips safely resolve to empty strings ("").
  • Multi-Record Collections: Pass foundRows (JSON string) directly into the rowsData input of another step or iterate over the collection using Studio list actions.
  • Conditional Logic: Add a Studio branch on rowCount > 0 to safeguard downstream actions when records might not exist.

Testing & Deployment with Clasp

Because Studio custom steps run on Google Workspace Add-on infrastructure, testing is fast:

  1. Either Copy with Apps Script project or follow the steps to clone the repo and push via clasp:
  2. Install the Test Deployment: Open the Apps Script project, go to Deploy > Test deployments, select Google Workspace Add-on, and click Install.
  3. Use in Studio: Head to studio.workspace.google.com, add a step to any flow, and search for “AppSheet Utilities for Studio”.

[!IMPORTANT] Admin Setting Required for Google Workspace Accounts:
As announced in the Google Workspace Updates, custom steps are OFF by default for Google Workspace accounts.

If you see a lock icon stating “๐Ÿ”’ Access to these steps is restricted by your Workspace admin”, have a domain admin navigate to:
Google Admin Console > Apps > Google Workspace > Settings for Workspace Studio > Custom steps settings
Turn custom steps ON and check “Allow unpublished (test) custom steps”.

AI-Assisted Development with .agents/

An interesting aspect of developing for newly released or evolving APIs like Workspace Studio is that public LLMs often have knowledge cutoffs or hallucinate manifest formats and Card Service specifications.

To build this project efficiently, the repository includes a curated .agents/ directory containing specialized runbooks, rules, and reference specs:

  • Contract Parity: Enforces that input/output IDs in appsscript.json match Code.js execution handlers.
  • Real-time API Adaptation: When testing revealed that Studio sidebar cards don’t render interactive card buttons, the agent used the reference docs to quickly pivot to native Dynamic Custom Resources (dynamicResourceDefinitionProvider).
  • Platform Constraints: Encodes crucial platform invariantsโ€”like the requirement that dataType.resourceType outputs mandate "cardinality": "SINGLE"โ€”saving hours of trial and error.
  • AppSheet Selectors: Pre-validated AppSheet formula expressions (FILTER, SELECT, TOP) for REST API calls.

When working with tools like Gemini Code Assist or AI coding agents, these in-repo skills guide the model to write accurate, production-ready code on the first attempt and navigate rapid API evolutions.

Summary and Next Steps

Having custom steps and starters back in Workspace Studio opens up huge possibilities for developers. Google Apps Script acts as the glue code, letting you build custom integrations for internal systems, specialized SaaS platforms, or databases like AppSheet.

You can find the complete source code and clasp setup instructions on GitHub: ๐Ÿ‘‰ mhawksey/appsheet-custom-studio-step-example

From AppSheet to Agents: Exploring Antigravity SDK, A2A and A2UI for Agent generation

Today marks the finish line of an intense coding sprint. I am excited to share my project: AppSheet2Agent (available at github.com/mhawksey/appsheet2agent).

If you are an AppSheet creator, you have already built amazing, structured databases and workflows. But what if your users want to interact with that same data conversationally, without leaving their chat?

Usually, connecting business applications to large language models is a massive headache:

  • You lose security context, often forcing you to rely on a single, risky service account.
  • You get flat, uninspiring text dumps that make structured data hard to read.
  • You waste hours writing manual boilerplate code.

AppSheet2Agent is an experimental solution designed specifically for existing AppSheet app creators. It allows them to rapidly create brand-new, highly interactive custom agents to interact with their existing apps. This makes it possible to use your AppSheet app directly inside platforms likeย Gemini Enterprise.

Here is what the MVP delivers:

  1. ๐Ÿค– Powered by Google Antigravity SDK Under the hood, it uses Google’s new Antigravity SDK to build the agent based on a conversation with the AppSheet creator. As part of this the user can provide the existing Application Definition and OpenAPI spec for their app, so Antigravity has the context if their app.
  2. ๐ŸŽจ Rich Interactive Layouts (A2UI v0.8) Nobody wants walls of boring markdown text. The agent automatically renders search results and forms as beautiful, structured visual cards directly in the Gemini Enterprise chat window. It automatically reorders columns to put primary labels first, hides messy system rows, and maps data types to native elements like checklists and date pickers.
  3. ๐Ÿ” True User Identity Delegation (RunAsUserEmail) Security is paramount. The agent uses OAuth to request and access the users email address which is used directly in the AppSheet API. Every single query and update runs strictly under the identity of the person chatting with the model. No shared credentials. No security compromises.

Where the Project Stands (The Reality Check) Because this was a sprint, it is a work in progress! I have successfully compiled, registered, and deployed custom AppSheet agents to Gemini Enterprise. Right now, I am still ironing out the automated “Creator Studio” wizard workflow that compiles the packaging on the fly.

I would love to hear your thoughts! If you are an AppSheet creator, how would your users benefit from interacting with your apps inside Gemini Enterprise?

Google Cloud credits are provided for this project.

AppSheet Training YouTube Channel – Keep Up to Date with NOCODE NEWS

No-Code Business Automation – Made Simple. This channel is here to help you learn the basics of AppSheet so that you can make your business more efficient.

Many AppSheet creators are likely familiar with the AppSheet Training YouTube channel and its associated materials. Managed by QREW Technologies, a business specialising in AppSheet consulting from the early days of the platform, the channel offers hundreds of videos covering all aspects of building and managing applications.

A particularly useful addition is a “NOCODE NEWS” segment, where the QREW team highlights the latest platform updates and community contributions. Given that founder Stefan Quartemont and several team members, including Cam Lupton, hold Google Developer Expert status, this segment offers an authoritative view. This segment is also included in their wider regular live broadcasts, so hit like and subscribe to stay informed.

To get a flavour of what is included, I have picked out a few recent highlights:

  • Shift to Platform Stabilityย [2 July 2026] – The QREW team highlights a recent community update where the AppSheet team openly acknowledged developer frustration and announced they are pausing new feature releases, including the highly anticipated Gantt chart view, and cancelling upcoming office hours. This hard choice is their way of finally tackling the bug backlog and system stability issues that creators have been pushing for.
  • User Limits Surfacingย [2 July 2026] – The hosts discuss a wave of anxiety on the AppSheet community forum as Google actively enforces the 10-user limit on free-tier and prototype accounts, which includes guest users. They walk through how this sudden enforcement is temporarily blocking application access, leaving creators scrambling to either clean up user lists or upgrade to a paid licence.
  • Domain Authenticated Email Betaย [18 June 2026] – The team shares details on a new “Bring Your Own Email” closed beta for Google Workspace customers. This is a massive relief for developers after AppSheet blocked external emails from the defaultย [email protected]ย address to combat phishing, which broke many existing workflows. This new beta uses Google OAuth to let developers send automated emails directly from their own authenticated domains.

The QREW team does an excellent job of translating policy updates into practical developer steps, saving you the time of digging through the forums yourself. For all of these updates check out the video descriptions for additional links and resources.

Source: AppSheet Training – YouTube

 

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

Have you ever woken up to a massive Google Cloud bill because a developer accidentally left a cluster… Tagged with googlecloud, appsheet, finops, cloudbilling.

Weโ€™ve probably all been there, creating and forgetting a test Google Cloud project. Here is a nice solution published by Google Developer Expert Aryan Irani knitting together various Google Cloud / Workspace services. In a guide Aryan walks through how to set up an event-driven workflow, using Cloud Pub/Sub to help prevent unwanted Google Cloud spend right from your phone. Instead of waiting for an email notification, this system uses Google Sheets, AppSheet and Google Cloud Functions to monitor your budget and give you a push notification and easy way to shut down a project.

If you want to simplify this architecture further you can replace the webhook target with a Google Apps Script function. By using the auto-generated Cloud Resource Manager client library from the Google API Client Library Generator for Apps Script, you can programmatically shut down the entire target project directly from your app. Configuring the single cloud-platform OAuth scope in your script manifest allows you to delegate security control directly to Google Cloud IAM roles. Moving the project to a soft-delete state instantly stops all active billing across all services, databases and compute instances, providing a complete emergency stop-switch.

This project is a fantastic example of using low-code tools to solve real infrastructure problems. You can read the full step-by-step tutorial and learn how to configure this for your own projects.

Source: Connecting GCP Budget Alerts to AppSheet: A Step-by-Step Guide – DEV Community

Beyond the Grid: First Look at Google Sheets Gemini Canvas and AppSheet

Google recently introduced the Sheets canvas feature to the Gemini Alpha.

Sheets canvas allows users to conversationally build interactive, read-write mini-apps directly from their spreadsheet data. At this time, Sheets canvas is limited to supporting only single-table and single-header tables.

The new Sheets canvas is undeniably a powerful tool for creating interactive applications directly from spreadsheet data. It removes a lot of friction for rapid app creation and allows the building of visual interfaces through simple conversation beyond the current tools in Google Sheets. It is an impressive leap forward.

One question I had was how Sheets Canvas compares to other no-code tools like AppSheet. To help explore this, I thought it would be useful to run a practical comparison. In this post, we will build a Kanban board using the same project management dataset, allowing us to evaluate the new Sheets canvas against Google AppSheet.

The Kanban Board Test: Relational vs Flat Data

We will use the official AppSheet Kanban dashboard template as our starter.

Because we are using a template, there is zero setup required. A look at the underlying data structure and youโ€™ll see this app has five distinct tables connecting projects to tasks and workstreams, while mapping people to specific notes. Whilst it still uses a standard Google Sheet as a data source, AppSheet allows us to use true relational data. For example, projects can have related tasks, assigned team members, and detailed histories.

Sheets canvas takes a different approach. Inside your spreadsheet, you open the Gemini side panel, enable the canvas tool, and provide an instruction like โ€œCan you turn this data into a kanban board app?โ€, which you can view (readonly) here.

This experience is similar to the existing AppSheet โ€˜Gemini for App Creationโ€™ with two key differences: in the Sheet canvas we are starting with existing data and the development process is iterative; and if you do continue to ask Gemini to update the canvas, for example, to pull sub-tasks and user avatars from other tabs, something to be aware of is that the result is a clever illusion. Because canvas only ingests the active sheet, you cannot dynamically query other tabs. This is a known current limitation:

Currently, canvases only use data from a single Sheet tab. The canvas provides a read-write interface for your spreadsheet data. If you have edit access, you can edit, delete, or add data directly within the canvas as an alternative to the grid view. If you have comment or view access, you canโ€™t modify the canvas.

Under the Hood: Actions vs Bespoke Code

Comparing how these tools actually generate the interface provides another stark contrast. Asking Gemini to build the board generated hundreds of lines of custom React code. It imported standard web development libraries to render a bespoke interface directly over the spreadsheet cells. You are quite literally prompting an AI front-end developer to build a miniature web application that sits on top of your grid.

Data Integrity: Strict Rules vs Surface Forms

AppSheet enforces data integrity at the system level. You can configure deep initial value formulas that populate fields dynamically based on user context or timestamps. You can deploy strict validation rules that prevent a user from selecting a date in the past or entering a mismatched email address. The application simply will not save the record until the conditions are met.

Sheets canvas handles data entry through surface-level web forms. Looking at the generated code for our Kanban board reveals that the AI used standard HTML form attributes to require certain fields and injected fallback text into the React state to mimic initial values. It is functional. It works well for simple applications; however, the canvas interface does not natively inherit the data validation rules you build into the underlying spreadsheet cells. If you want strict input controls, you must explicitly prompt the AI to write custom JavaScript to catch those errors in the browser.

Security, Governance, and Shadow IT

The biggest difference between Sheets canvas and AppSheet emerges when you look at it at an enterprise level. A Sheets canvas is simply a file formatting layer. Its security model relies entirely on standard Google Drive permissions. If a user has edit access to the spreadsheet, they have edit access to the canvas.

AppSheet operates as a true enterprise platform. It lives behind a dedicated Admin Console where IT teams maintain oversight over every application built across the organisation. For teams using AppSheet Enterprise Plus licences, administrators can define governance policies that automatically enforce corporate compliance across hundreds of independent projects. An administrator might create a rule that instantly blocks deployment if a user attempts to connect an unapproved external database or fails to mandate strict domain authentication.

The Feature Comparison

To help you decide which tool fits your current project, here is a breakdown of their core capabilities.

Feature Sheets Canvas (Alpha) AppSheet
Primary Purpose Building custom interfaces to visualise and update single-sheet data. Building robust business applications with a dedicated desktop mode.
Data Source A single Google Sheet tab. Multiple sources including Sheets, SQL, and external APIs.
Data Structure Flat. Cannot access other tabs dynamically. AI relies on faking relationships with hardcoded static data. Relational.
Data Validation Basic HTML/React form rules. Requires custom JavaScript for complex logic. Deep system-level validation and computed initial values.
Read/Write Access Editors can edit, delete, or add data. Viewers cannot. Granular, role-based database access.
Complexity Level Low. Prompt-driven visualisations generating React code. High. Requires structured logic and intentional design.
Security & Governance Relies on standard Google Drive file permissions. Centralised admin console with strict policy-driven enterprise governance.

The Verdict

If you need a quick dashboard to track your team’s weekly tasks, use Sheets canvas. It is fast, intuitive, and keeps everyone working within a familiar spreadsheet environment while the AI handles the complex front-end code.

If your workflows are growing, if you need to connect multiple data sources like mapping notes and users to specific projects reliably, or if your IT department requires strict visibility over internal tools, AppSheet remains the undisputed choice.

Delegated Power: Showcasing a Google Workspace Admin Toolbox Concept in AppSheet and Apps Script

The Google Admin Console is a powerful engine, but it often becomes a bottleneck for delegated tasks. IT teams frequently find themselves trapped in “Admin Debt,” repeating manual steps because granting full administrative access to others is a security risk.

At the Google for Education IT Admin Summit in London, I shared a session on how to move from a static interface to a dynamic, automated engine. The goal is to build an “Admin Toolbox” that showcases how some Admin SDK and other Workspace API capabilities can be integrated into secure, self-service applications using AppSheet and Google Apps Script.

For those who couldn’t attend, or for those who want to dig into the code, Iโ€™ve made the session guide available below.

“We are building a data bridge that turns raw directory records into a functional database that understands who people are and, more importantly, who they report to.” โ€” Session Guide: The Automated IT Toolbox

Practical Builds in the Toolbox

The session guide covers four distinct areas where these technologies intersect to solve common IT headaches:

  1. Hierarchical Directory Apps: Building a connection to the Admin SDK to create a searchable directory with security filters based on reporting lines.
  2. Automated Shared Drive Provisioning: A workflow where AppSheet handles the request and Apps Script acts as the administrator to create and name drives automatically upon approval.
  3. ChromeOS Management: Using the Reports API to create a live activity feed of login events and issuing remote commands like “Lock Device.”
  4. AI-Powered Damage Reports: Utilising the Gemini API to analyse photos of damaged hardware. Users can snap a photo, and the AI provides a structured analysis of the severity and required parts.

Gemini as a Development Partner

A key takeaway from the session was that I didn’t write any of this code from scratch. Instead, I used the Gemini App as a pair programmer. While Gemini was excellent for standard data tasks, it reached its limits when handling more obscure or less documented API calls. In these areas, my existing knowledge of the Workspace platform was essential. I had to refine my prompts and provide specific technical context to guide the model toward a reliable solution. It highlights that while AI is a powerful assistant, it still needs a knowledgeable pilot to navigate the complexities of advanced APIs.

The full session guide includes code snippets as well as some of the advanced โ€˜watchโ€™ and Gemini API structured output.

Source: Google Doc | GitHub Repo

Supercharging AppSheet API development with Gemini and OpenAPI specs

We know that to get the most out of generative AI tools like Gemini (gemini.google.com), you need to provide them with high-quality context. For AppSheet creators, there is a “hidden gem” within the platform that generates automatic documentation for your app. By navigating toย Settings > Information > App documentation, you can access a comprehensive PDF that details your app’s definition; this is an excellent resource for human review and archiving.

However, when working with tools like the Gemini to generate code or API calls, a flattened PDF isn’t always the most efficient format for the model to parse. For creators looking for a more machine-friendly alternative,ย QREW Apps recently suggestedย a clever method to access the OpenAPI specification of your app directly.

App owners can retrieve this structured data by appending their app’s UUID to the AppSheet API v2 URL: https://www.appsheet.com/api/v2/apps/{app-guid}/openapi.json

This OpenAPI JSON export provides a structured blueprint of your app’s API capabilities. Unlike the PDF documentation, this JSON format is highly digestible for an AI. For creators beginning to experiment with the AppSheet API, uploading this JSON file into gemini.google.com allows the model to understand the exact schema and capabilities of your specific application.

With this context loaded, Gemini can assist in constructing accurate API calls. For example, if you are looking toย Call a webhook from an automation, Gemini can generate valid payloads, enable batch updates, or script complex data interactions that would typically require significant manual trial and error.

For those of you working with Google Apps Script, you can pair this technique with myย AppSheetApp library. With the OpenAPI spec providing the schema, providing the library code which handles the API communication, you can prompt Gemini to write a script for your AppSheet automation.

I am keen to hear how you get on with this workflow. If you discover other interesting ways to combine OpenAPI specs with Gemini to accelerate your Google Workspace development, feel free to share them in the comments. As always, happy scripting!

Build Apps Without Coding: Guide to Google AppSheet With Gemini AI

Gartner has predicted that by 2025, 70% of new applications developed by enterprises will utilise low-code or no-code technologies. Furthermore, the global no-code AI platforms market is expected to grow to $24.8 billion by 2029. These numbers are no surprise, knowing that no-code solutions bring significant cost reductions and speed up development processes. The best news? If you are using Google Workspace, you probably already have access to a powerful no-code tool โ€“ Google AppSheet.

I recently co-authored a guide at Devoteam on building no-code apps with Google AppSheet and Gemini.

The guide hopefully provides a clear overview of AppSheet’s capabilities, highlighting its ability to connect to existing data sources like Google Sheets and SQL databases. It also delves into how the new Gemini integration allows anyone to generate an application’s structure simply by describing their idea in plain English. The guide includes some real-world use casesโ€”from inventory management to streamlining hotel auditsโ€”demonstrating the tangible impact of empowering “citizen developers” within an organisation.

For the Google Workspace Developer community, hopefully this guide offers a useful lens through which to view the no-code landscape. Understanding these platformsโ€”their capabilities, their audience, and their limitationsโ€”can be useful when deciding whether to build a full custom solution or to empower a team with a no-code tool.

Source: Build Apps Without Coding: Guide to Google AppSheet With Gemini AI

New Feature for the AppSheetApp Library: Run API Calls in Parallel

A Google Apps Script wrapper for the Google AppSheet API – bienlim/AppSheetApp

Recently I had a nice ping into my LinkedIn feed from App Developer Bien Lim. Bien has enhanced my originalย AppSheetAppย library for Apps Script with a powerful new feature:ย fetchAll(). This addition lets you run multiple AppSheet API calls at the same time, significantly boosting the performance of your Apps Script integrations.

Building on the libraryโ€™s existing methods like Add, Delete, Edit, and Find, this new function allows developers to execute these calls in parallel. This can drastically reduce execution time, which is a big improvement for applications that rely on multiple API operations.

You can find the updated library on the code repository to start using this new feature today.

Example Code

Here is a snippet showing how you can use the new fetchAll() method:

/**
 * Executes multiple AppSheet API requests in parallel.
 * This example shows how to perform Add, Delete, Edit, and Find operations simultaneously.
 */
function parallelRequest(){
  // Replace with your actual App ID and Access Key
  const AppSheet = new AppSheetApp('YOUR_APP_ID', 'YOUR_ACCESS_KEY');

  // Placeholder data for demonstration
  const properties = { "Locale": "en-US" };

  // Sample data for adding a new record. The key field is usually omitted if it's auto-generated.
  const dataToAdd = [{"Name": "John Doe", "Age": 30}];

  // Sample data for editing an existing record. The key field is required to identify the row.
  const dataToEdit = [{"ID": "unique-id-123", "Age": 31}];

  // Sample data for deleting an existing record. The key field is required.
  const dataToDelete = [{"ID": "unique-id-456"}];

  // The FetchAll method takes multiple API calls as arguments.
  // The 'true' argument tells each method to return a parameter object instead of
  // making an immediate API call. These parameter objects are then passed to fetchAll().
  const responses = AppSheet.fetchAll(
    AppSheet.Add('People', dataToAdd, properties, true),
    AppSheet.Delete('People', dataToDelete, properties, true),
    AppSheet.Edit('People', dataToEdit, properties, true),
    AppSheet.Find('People', [], properties, true)
  );

  // The responses are returned in an array, in the same order as the requests.
  const [ respFromAdd, respFromDelete, respFromEdit, respFromFind ] = responses;

  // You can now handle each response individually
  console.log('Add Response:', respFromAdd);
  console.log('Delete Response:', respFromDelete);
  console.log('Edit Response:', respFromEdit);
  console.log('Find Response:', respFromFind);
}

Source: GitHub – bienlim/AppSheetApp: A Google Apps Script wrapper for the Google AppSheet API

It’s Official: Gemini in AppSheet is Now Generally Available for Enterprise Users


We’re very excited to announce that Gemini in AppSheet Solutions is now Generally Available (GA)! This powerful capability allows AppSheet Enterprise Plus users to integrate Google’s Gemini directly into their automation workflows.

Following ourย previous postย announcing the public preview, we are excited to share that Gemini in AppSheet Solutions is now generally available (GA) for all AppSheet Enterprise Plus users. This update allows creators to directly integrate Google’s Gemini models into their automation workflows, making AI-powered automation more accessible than ever.

What This Means for Creators

This move to general availability solidifies the simplified AI integration within AppSheet. Instead of complex setups involving API keys and external scripts, creators can now use a native “AI Task” step within their AppSheet automations. This new task can handle jobs like extracting specific data from uploaded photos or PDFs, and categorising text directly within AppSheet.

The GA release also brings enhanced confidence in building AI-powered solutions. The in-editor task testing feature allows creators to test and refine AI prompts and configurations with sample data before deployment. This is a crucial step for ensuring reliable AI, and it allows for much quicker iteration.

For administrators, the AppSheet admin dashboard now provides visibility into Gemini usage within the organisation, and allows for control over which creators can use these new features.

Key updates since Public Preview

For creators, the GA release includes a number of improvements:

  • AI tasks now support more column types, including REF types, allowing you to use information in linked tables.
  • The quality of AI responses has been improved for certain data types.

For admins, the AppSheet admin console now shows your organisation’s credit entitlement and consumption, providing insights into how your users and applications are using Gemini.

The Power of the Underlying Model

It’s also worth noting that the underlying Gemini models are market leaders and are continuously improving. New tools on the horizon, such asย ‘URL context’ย and the ability to also ground results with Google Search, will hopefully filter through to AI Tasks in AppSheet enabling creators to build even more powerful solutions. These advancements will allow for the creation of sophisticated AI assistants that can use real-time information, all without the need for fine-tuned models or complex custom integrations.

Getting Started: Example Template

The announcement post includes links to the relevant documentation for creators and admins. For those looking for a practical example, the AppSheet team has provided a “Book tracking with Gemini” template. This app showcases how you can upload a picture of a book cover, and then use two different AI tasks to automatically extract book-related information and categorise it by genre. I found this to be an excellent starting point for understanding how to implement these new features in your own projects.

Source: Gemini in AppSheet now Generally Available for Enterprise users!