Google Brings Gemini Directly into Apps Script: Build Google Workspace Automations with AI

Google’s latest Apps Script update makes it possible to create, customize, and debug Google Workspace automations using natural language. Here’s what changed, how to use it, and why this matters for anyone working with Google Sheets, Docs, Gmail, and Drive.

Published: November 16, 2026

What If You Could Automate Google Workspace Just by Describing What You Want?

Imagine opening Google Sheets and typing:

“Create a weekly report that summarizes all completed tasks, identifies overdue items, and generates a formatted Google Doc.”

Instead of searching for code examples, learning every method from scratch, or manually writing the entire script, you describe your goal to Gemini.

Gemini generates the Apps Script code.

You review the proposed changes, test the automation, and refine the result through conversation.

This is no longer just an experimental workflow.

On November 16, 2026, Google announced the general availability of Gemini directly inside the Google Apps Script editor.

The update makes AI-assisted automation available to eligible Google Workspace users, including people with little or no programming experience.

For experienced developers, it introduces a faster way to create scripts, explore unfamiliar APIs, modify existing projects, and troubleshoot execution errors.

For organizations, it creates new opportunities to automate repetitive processes using tools employees already work with every day.

And for learners, it provides a practical environment for developing JavaScript and automation skills through experimentation.

This is an important development for the future of Google Workspace automation.

But the real opportunity isn’t simply generating code faster.

It’s making automation more accessible while helping people understand how their workflows operate.

Let’s explore what Google announced, how the new capabilities work, and how you can begin using them.


1. What Has Google Actually Announced?

Google has introduced Gemini directly into the Apps Script integrated development environment (IDE).

Apps Script is Google’s cloud-based JavaScript platform for automating and extending Google Workspace.

Traditionally, creating an Apps Script automation required writing JavaScript code, using Google Workspace service methods, and testing the results.

Developers might write code such as:

function createReport() {
  const sheet = SpreadsheetApp.getActiveSheet();

  const data = sheet.getDataRange().getValues();

  Logger.log(data);
}

This reads information from a spreadsheet and logs the results.

For someone familiar with JavaScript and Apps Script, the code is straightforward.

For someone who has never programmed, even a short example may seem intimidating.

Gemini changes the starting point.

Instead of beginning with syntax, you can begin with an instruction.

For example:

“Read the data in my spreadsheet and create a summary showing the number of tasks assigned to each person.”

Gemini can generate a proposed Apps Script implementation.

You can then review the code, accept or reject suggested changes, and continue refining the workflow.

Three Major Capabilities

The announcement highlights three especially useful features.

1. Natural-language script generation

Describe an automation in plain language and have Gemini propose code.

2. Block-by-block code review

Review individual suggested code blocks and choose whether to accept or reject them.

3. AI-assisted error troubleshooting

Use the Fix errors option in the execution log to get an explanation of a runtime error and a suggested correction.

Together, these features make the Apps Script editor a more interactive development environment.

Instead of switching between an AI assistant, documentation, and the code editor, users can work with Gemini directly inside the project.


2. Why This Update Matters

Google Apps Script has always been one of the most practical ways to customize Google Workspace.

It allows developers to connect services, automate tasks, and build lightweight applications.

But the biggest barrier has often been the programming knowledge required to get started.

Consider a typical office workflow.

A project coordinator maintains a spreadsheet containing:

  • Project names
  • Assigned employees
  • Due dates
  • Current status
  • Completion dates

Every Friday, the coordinator manually prepares a summary.

They count completed tasks, identify overdue work, copy information into a document, and prepare an email.

The process may take 30 minutes each week.

Over a year, that’s approximately 26 hours spent repeating essentially the same work.

A simple Apps Script could reduce much of that manual effort.

The challenge has been building it.

Now, users can describe the process and ask Gemini to help create the automation.

What Changes for Non-Developers?

Employees who understand their business processes but don’t know JavaScript can begin experimenting with automation.

They still need to verify the output, understand the permissions, and test the results.

But they no longer need to start from a blank editor.

What Changes for Developers?

Experienced Apps Script developers can use Gemini to accelerate repetitive implementation work.

Examples include:

  • Creating boilerplate functions
  • Exploring unfamiliar Workspace APIs
  • Adding validation
  • Improving error handling
  • Refactoring existing scripts
  • Generating test cases
  • Explaining code written by someone else

This doesn’t eliminate the need for development skills.

Instead, it changes where developers spend their time.

Less time can be spent writing routine code.

More time can be spent designing workflows, validating requirements, handling edge cases, and ensuring reliability.


3. How to Access Gemini in Google Apps Script

Google’s announcement describes several ways to open the Apps Script editor.

Option 1: From Google Sheets

  1. Open a Google Spreadsheet.
  2. Select Extensions → Apps Script.
  3. Wait for the Apps Script editor to open.
  4. Locate the Gemini side panel or the Ask Gemini spark icon in the upper-right corner.
  5. Open Gemini and describe the automation you want to build.

Option 2: Open Apps Script Directly

Visit:

https://script.google.com

Or use:

https://script.new

Create a new Apps Script project.

For eligible users, the Gemini side panel opens automatically in new scripts.

You can also open it using the Ask Gemini icon.

What If You Don’t See Gemini?

Google began the gradual rollout on November 12, 2026.

The company states that feature visibility may take up to 15 days.

Availability also depends on your Google Workspace edition, applicable AI add-ons, and organizational settings.

If you’re using a managed Workspace account, your administrator may control access to the feature.


4. Your First AI-Generated Apps Script Automation

Let’s walk through a practical example.

Imagine you have a Google Spreadsheet containing customer orders.

Your spreadsheet has these columns:

Order IDCustomerAmountStatus
1001Alex120Complete
1002Jordan85Pending
1003Taylor210Complete
1004Morgan75Pending

You want a report showing how many orders are complete and pending.

Step 1: Describe the Task to Gemini

Open the Apps Script editor and enter:

“Create a Google Apps Script that reads data from a sheet named Orders, counts the number of records for each status, and writes the results to a sheet named Order Summary. If the summary sheet already exists, update it instead of creating another one.”

Notice what makes this a useful instruction.

It identifies the source.

It describes the calculation.

It specifies the destination.

It explains what should happen when the script runs again.

These details reduce ambiguity.

Step 2: Review the Generated Code

Gemini should propose code implementing the workflow.

The exact output may vary.

A possible implementation is:

function generateOrderSummary() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();

  const source = ss.getSheetByName("Orders");

  if (!source) {
    throw new Error("Orders sheet not found.");
  }

  const values = source.getDataRange().getValues();

  if (values.length < 2) {
    Logger.log("No orders available.");
    return;
  }

  const headers = values[0];
  const statusIndex = headers.indexOf("Status");

  if (statusIndex === -1) {
    throw new Error("Status column not found.");
  }

  const counts = {};

  values.slice(1).forEach(row => {
    const status = String(
      row[statusIndex] || "Unknown"
    ).trim();

    counts[status] = (counts[status] || 0) + 1;
  });

  const output = [
    ["Status", "Count"],
    ...Object.entries(counts)
  ];

  let summary = ss.getSheetByName("Order Summary");

  if (!summary) {
    summary = ss.insertSheet("Order Summary");
  }

  summary.clearContents();

  summary.getRange(
    1,
    1,
    output.length,
    2
  ).setValues(output);
}

This example demonstrates several useful Apps Script concepts.

SpreadsheetApp accesses the spreadsheet.

getSheetByName() selects a specific tab.

getDataRange().getValues() reads the records.

JavaScript arrays and objects process the data.

setValues() writes the results efficiently.

Step 3: Review the Proposed Changes

Google’s new interface allows you to accept or reject suggested code blocks individually.

This is particularly valuable when working with existing scripts.

For example, Gemini might suggest changing the report-generation function while also modifying an unrelated helper function.

You can inspect the proposed changes and accept only those you want.

Step 4: Test the Automation

Run the script using a test spreadsheet.

Verify that the report contains the expected counts.

For the sample data, the result should be:

StatusCount
Complete2
Pending2

Step 5: Improve the Automation

Now ask Gemini:

“Update the script to add a timestamp showing when the report was generated. Also add error handling and explain what happens if the Orders sheet is empty.”

This creates an iterative development process.

Describe → Generate → Review → Test → Improve

Rather than trying to build everything in one request, you can progressively develop the automation.


5. Gemini Can Work with Existing Apps Script Projects

One of the most significant features in the announcement is Gemini’s ability to use the context of files in your open Apps Script project.

This matters because real projects rarely consist of a single function.

An Apps Script project might contain:

Code.gs
Config.gs
Reports.gs
Utilities.gs
Sidebar.html
appsscript.json

Each file may have a different responsibility.

For example:

Code.gs might contain the main entry points.

Reports.gs might generate spreadsheet summaries.

Utilities.gs might provide shared helper functions.

Sidebar.html might contain a custom user interface.

When an AI assistant understands the surrounding project, it can make more relevant suggestions.

Example: Adding a Feature

Suppose you already have a script that generates reports.

You could ask:

“Review the existing report-generation code. Add a function that exports the report as a PDF and saves it in a designated Google Drive folder. Preserve the current spreadsheet reporting behavior.”

Gemini can inspect the project context and propose changes.

But you should still review the implementation carefully.

Questions worth asking include:

  • Does the script use the correct spreadsheet?
  • Does it create duplicate files?
  • Does it overwrite existing documents?
  • Are Drive permissions appropriate?
  • What happens if the folder doesn’t exist?
  • What happens if the script runs twice?

AI-generated code should be treated as a proposed implementation, not an automatically verified solution.


6. Debugging Apps Script with Gemini

Anyone who has worked with Apps Script knows that debugging can be frustrating.

Common problems include:

  • Incorrect spreadsheet names
  • Missing permissions
  • Invalid range dimensions
  • Unexpected empty values
  • Trigger-related errors
  • API failures
  • Exceeded execution limits

Previously, users often had to copy an error message, search documentation, or ask an external AI assistant for help.

Google’s update introduces a more direct workflow.

When an execution fails, users can select Fix errors from the Apps Script execution log.

Gemini can explain the issue and propose a correction.

Example: Missing Spreadsheet Tab

Consider:

function readCustomers() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();

  const sheet = ss.getSheetByName("Customers");

  const data = sheet.getDataRange().getValues();

  Logger.log(data);
}

If the spreadsheet doesn’t contain a tab named Customers, the variable sheet will be null.

The next line attempts to call a method on that null value.

This produces an error.

Gemini could suggest adding validation:

function readCustomers() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();

  const sheet = ss.getSheetByName("Customers");

  if (!sheet) {
    throw new Error(
      "The Customers sheet does not exist."
    );
  }

  const data = sheet.getDataRange().getValues();

  Logger.log(data);
}

The revised version produces a more meaningful error.

Why Error Explanations Matter

For beginners, an error message can seem like a dead end.

An explanation helps turn the error into a learning opportunity.

Instead of simply fixing the problem, ask:

“Explain why the error occurred, what the correction changes, and how I can prevent similar errors in future scripts.”

This encourages deeper understanding.


7. Five Practical Automations to Try with Gemini

The best way to understand the new capabilities is to build something useful.

Here are five practical projects, with prompts you can adapt directly in the Apps Script editor.

Project 1: Automated Weekly Project Report

Goal: Turn spreadsheet records into a weekly status report.

Prompt:

“Create an Apps Script that reads project tasks from a sheet named Tasks. Calculate completed, pending, and overdue tasks. Generate a summary in a sheet named Weekly Report. Include a timestamp, avoid duplicate report sheets, and handle missing or empty data.”

What you’ll learn:

  • Spreadsheet data processing
  • Date comparisons
  • Report generation
  • Error handling
  • Repeatable workflows

Project 2: Generate Google Docs from Spreadsheet Records

Goal: Create personalized documents automatically.

Prompt:

“Create an Apps Script that reads employee names, departments, and onboarding dates from a sheet named Employees. Generate a Google Doc for each new employee using the spreadsheet data. Record the document URL in the sheet and skip records that already have a document. Do not send emails.”

What you’ll learn:

  • Google Docs automation
  • Spreadsheet integration
  • Document creation
  • Duplicate prevention
  • Workflow tracking

Project 3: Organize Google Drive Files

Goal: Categorize files according to naming conventions.

Prompt:

“Create an Apps Script that scans a specific Google Drive folder and identifies files containing Invoice, Report, or Contract in their names. First generate a preview report showing how each file would be categorized. Do not move or delete any files until I explicitly enable those actions.”

What you’ll learn:

  • Google Drive APIs
  • File metadata
  • Conditional logic
  • Safe automation design
  • Dry-run workflows

Project 4: Create Calendar Events from Spreadsheet Data

Goal: Turn a spreadsheet schedule into Calendar events.

Prompt:

“Create an Apps Script that reads event names, start dates, end dates, and descriptions from a sheet named Schedule. Validate the dates and prepare a preview of Calendar events to be created. Add a separate function that creates events only after confirmation and records event IDs to prevent duplicates.”

What you’ll learn:

  • Google Calendar automation
  • Date handling
  • Validation
  • Event creation
  • Duplicate prevention

Project 5: Build an Automated Data Cleanup Tool

Goal: Improve spreadsheet data quality.

Prompt:

“Create an Apps Script that reads a sheet named Raw Data and writes cleaned results to a separate sheet named Clean Data. Trim extra whitespace, standardize email addresses to lowercase, identify duplicate rows, and flag missing required fields. Preserve the original data and generate a summary of changes.”

What you’ll learn:

  • Data transformation
  • JavaScript arrays
  • Validation rules
  • Reporting
  • Non-destructive processing

These projects demonstrate an important principle.

The best automation starts with a clearly defined problem, not with the technology itself.


8. Better Prompts Produce Better Automations

One of the biggest opportunities with Gemini in Apps Script is learning how to describe a workflow effectively.

Consider this prompt:

“Automate my spreadsheet.”

It’s too vague.

What spreadsheet?

What should be automated?

What should happen to the data?

Where should the results go?

A more useful prompt is:

“Read all rows from the Tasks sheet. Identify records with a due date before today and a status other than Complete. Write those records to an Overdue Tasks sheet, including the task name, owner, due date, and number of days overdue. Preserve the original data and avoid creating duplicate output sheets.”

This is much more specific.

A Reusable Automation Prompt Framework

Use this structure when creating Apps Script automations:

Task: What should the automation accomplish?

Source: Where does the information come from?

Processing: What rules should be applied?

Output: Where should the results go?

Constraints: What must the script avoid doing?

Errors: What should happen when something goes wrong?

Testing: How will you verify the result?

Copy-and-Use Master Prompt

Act as an experienced Google Apps Script developer.

Help me create a reliable Google Workspace automation.

GOAL:
[Describe the task]

SOURCE:
[Spreadsheet, document, form, or other source]

DATA STRUCTURE:
[List relevant columns or fields]

PROCESSING RULES:
[Describe the required logic]

OUTPUT:
[Describe the expected result]

REQUIREMENTS:
- Preserve original data unless explicitly instructed.
- Validate required inputs.
- Avoid duplicate processing.
- Use efficient batch operations where appropriate.
- Include meaningful error handling.
- Add logging for troubleshooting.
- Use clear function and variable names.
- Avoid unnecessary permissions.
- Do not send emails or modify external files
  without explicit instructions.

Provide:
1. The proposed implementation
2. An explanation of the code
3. Required permissions
4. Setup instructions
5. A test plan
6. Known limitations
7. Suggestions for future improvements

Start with the smallest working version.

This approach works especially well when you’re learning Apps Script.

It encourages Gemini to generate code that is easier to inspect, test, and maintain.


9. What About Security and Administrative Control?

Making automation easier also introduces important responsibilities.

An AI-generated script can potentially modify spreadsheets, access files, create documents, or send emails—depending on the permissions granted to it.

That’s why Google’s announcement emphasizes that Apps Script continues to operate within existing Workspace permission and administrative frameworks.

Scripts still run using the user’s authorized permissions and applicable OAuth consent.

Workspace administrators retain controls over Apps Script availability, generative AI access, and related security settings.

Google also identifies controls for external URL access and audit visibility.

Why This Matters

Imagine an employee asks Gemini to create a script that processes customer records.

The generated code might be technically correct but still require careful review.

Does it access the right spreadsheet?

Does it expose information unnecessarily?

Does it send data to an external service?

Does it modify records that should remain unchanged?

Does it request more permissions than necessary?

These questions remain important regardless of whether code was written manually or generated by AI.

A Practical Safety Checklist

Before running an AI-generated Apps Script:

  1. Review what the code reads and changes.
  2. Understand the requested permissions.
  3. Test with sample data.
  4. Verify external URLs and API calls.
  5. Check for destructive operations.
  6. Confirm whether emails or notifications will be sent.
  7. Inspect triggers and recurring executions.
  8. Review the execution logs.
  9. Confirm that repeated runs won’t create duplicates.
  10. Keep a known working version of the project.

AI can make writing code easier. It doesn’t eliminate the need to understand what the code will do.


10. Why This Is Particularly Important for Google Workspace Developers

For developers who already use Apps Script, Gemini creates opportunities to improve the development workflow.

Faster Prototyping

You can describe a new feature and quickly generate an initial implementation.

Better Code Exploration

You can ask Gemini to explain unfamiliar functions or project structure.

Incremental Refactoring

You can request focused improvements rather than rewriting entire applications.

Troubleshooting Support

You can investigate errors directly inside the editor.

Easier Learning

You can experiment with new Workspace services and ask questions as you go.

However, experienced developers should continue to evaluate code quality.

A script that runs successfully may still have problems with performance, security, maintainability, or edge cases.

For example, consider this pattern:

for (let row = 1; row <= 1000; row++) {
  const value = sheet.getRange(row, 1).getValue();

  sheet.getRange(row, 2).setValue(value);
}

This repeatedly calls spreadsheet services inside a loop.

A more efficient implementation uses batch operations:

const values = sheet
  .getRange(1, 1, 1000, 1)
  .getValues();

sheet
  .getRange(1, 2, 1000, 1)
  .setValues(values);

Both approaches may produce the same result.

But the second approach generally reduces service calls.

This illustrates why developer judgment still matters.

The goal should be to use Gemini to accelerate development while continuing to apply good engineering practices.


11. How Gemini in Apps Script Fits into Vibe Learning

One of the most interesting aspects of this update is its potential for learning.

Traditional programming instruction often begins with syntax.

Learn variables.

Learn functions.

Learn loops.

Learn objects.

Then eventually build something useful.

AI-assisted development creates another possible starting point.

Begin with a meaningful problem.

Describe the desired outcome.

Generate a first implementation.

Run the code.

Observe what happens.

Then investigate how it works.

This approach aligns with the principles of Vibe Learning.

A Practical Learning Cycle

1. Identify a problem

Choose a repetitive task that would benefit from automation.

2. Describe the outcome

Explain the workflow to Gemini using natural language.

3. Review the generated code

Identify the Apps Script services, functions, and data structures.

4. Predict the result

Before running the script, explain what you expect it to do.

5. Test the automation

Use sample data and inspect the results.

6. Investigate problems

Ask Gemini to explain errors or unexpected behavior.

7. Improve the workflow

Add validation, reporting, or additional functionality.

8. Explain what you learned

Describe the process in your own words.

This final step is especially important.

Being able to generate code is useful.

Being able to explain, test, modify, and maintain that code is far more valuable.


12. A Seven-Day Gemini + Apps Script Learning Challenge

Want to try the new capabilities?

Here’s a practical seven-day learning plan.

Day 1 — Explore Gemini in the Editor

Open Apps Script.

Find the Gemini side panel.

Ask Gemini to create a simple function that logs a message.

Review the code and run it.

Challenge: Explain what each line does.

Day 2 — Read Google Sheets Data

Create a spreadsheet with sample records.

Ask Gemini to generate a function that reads the data.

Inspect the returned arrays.

Challenge: Modify the code to read only specific columns.

Day 3 — Generate a Report

Ask Gemini to summarize the spreadsheet records.

Write the results to a separate tab.

Challenge: Make the script safe to run repeatedly.

Day 4 — Automate Google Docs

Generate a document from spreadsheet data.

Add formatting and a meaningful title.

Challenge: Record the document URL in the source sheet.

Day 5 — Practice Debugging

Create a controlled error in a test project.

Use the execution log and Gemini’s error assistance.

Challenge: Explain why the error occurred before accepting the proposed fix.

Day 6 — Improve Reliability

Ask Gemini to add:

  • Input validation
  • Error handling
  • Logging
  • Duplicate prevention
  • Clear function names

Challenge: Test the script with empty or invalid data.

Day 7 — Build a Complete Automation

Choose a real task.

Create a workflow that connects at least two Google Workspace services.

Test the result.

Document the setup.

Explain what the script does and what permissions it requires.

Final Challenge: Identify one limitation and improve the automation.

By the end of the week, you’ll have more than a collection of generated scripts.

You’ll have practical experience using AI to design, understand, and improve Google Workspace automations.


13. Who Can Use Gemini in Apps Script?

According to Google’s November 16 announcement, the feature is available to eligible users in the following editions and add-ons:

CategoryEligible editions
Google Workspace BusinessBusiness Standard, Business Plus
Google Workspace EnterpriseEnterprise Standard, Enterprise Plus
AI add-onAI Expanded Access
Education add-onGoogle AI Pro for Education
Consumer subscriptionsGoogle AI Pro, Google AI Ultra

The rollout began November 12, 2026, for Rapid Release and Scheduled Release domains.

Google indicates that feature visibility may take up to 15 days.

Organizational access settings may also affect availability.

If Gemini isn’t visible in your Apps Script editor yet, check your subscription, rollout status, and administrator settings.


14. The Bigger Picture: From Writing Scripts to Designing Automations

This update reflects a broader change in software development.

AI is making it easier to translate natural-language requirements into working code.

But that doesn’t mean technical understanding becomes irrelevant.

In many ways, it becomes more important.

When code generation becomes faster, the challenge shifts toward questions such as:

What should the application do?

How should the workflow handle errors?

What information should it access?

What happens when the process runs twice?

How can we verify the result?

How do we maintain the automation over time?

These are design and engineering questions.

And they’re central to building reliable software.

For Google Workspace users, the opportunity is significant.

A spreadsheet can become a reporting application.

A form can become an automated registration system.

A document template can become a document-generation workflow.

A set of repetitive tasks can become a coordinated process.

Gemini can help create the code.

But the value comes from solving the right problem.


15. Continue Learning Google Apps Script with DiscoveryVIP

If you’re interested in exploring Apps Script automation beyond this announcement, I’ve created practical learning resources at DiscoveryVIP.

These resources are designed to help learners understand JavaScript, Google Workspace services, automation design, and real-world application development.

Apps Script Automation Academy

Explore Google Workspace automation concepts and develop practical scripting skills.

https://discoveryvip.com/apps-script-automation-academy

Apps Script Automation Lab

Practice automation through hands-on exercises and workflow examples.

https://discoveryvip.com/apps-script-automation-lab

Google Apps Script Build Studio

Explore building applications and automations using Google Apps Script.

https://discoveryvip.com/apps-script-build-studio

More Free Learning Resources

https://discoveryvip.com/guides.php

Explore the Vibe Learning Framework

https://vibelearning.ca

These resources can help you move from AI-generated examples toward understanding, adapting, and building your own solutions.


Final Thoughts: Gemini Makes Automation More Accessible, but Understanding Still Matters

Google’s integration of Gemini into Apps Script is an important step toward making Google Workspace automation accessible to more people.

Users can now describe a task, generate code, review suggested changes, and troubleshoot errors without leaving the Apps Script editor.

For beginners, this reduces the difficulty of getting started.

For experienced developers, it can accelerate routine work.

For organizations, it opens opportunities to automate processes that previously required more specialized development support.

But the most important change isn’t that AI can write Apps Script code.

It’s that more people can begin turning their ideas into working solutions.

The best results will come from combining AI assistance with clear requirements, practical testing, and a willingness to understand the generated code.

Start with a problem. Describe the workflow. Review the code. Test the result. Learn from what happens.

That’s how AI-assisted automation becomes a useful skill rather than simply another way to generate code.

About the Author

Laurence Svekis is a Google Developer Expert (Google Workspace), Google Champion, author, developer, and educator who has taught 3 million+ students through online courses and practical learning resources.

He is the creator of Vibe Learning and Vibe Teaching, approaches focused on active learning, practical experimentation, AI-assisted development, and meaningful understanding.

Through DiscoveryVIP.com and VibeLearning.ca, Laurence creates interactive learning tools, educational guides, and hands-on resources covering Google Apps Script, JavaScript, artificial intelligence, automation, and modern software development.

Sources and Further Reading

Official Google announcement — November 16, 2026:
https://workspaceupdates.googleblog.com/2026/11/customize-and-extend-workspace-with-apps-script.html

Google Apps Script documentation:
https://developers.google.com/apps-script

Google Apps Script release notes:
https://developers.google.com/apps-script/release-notes

Google Workspace developer resources:
https://developers.google.com/workspace