Unlock the Full Potential of Google Workspace with Coding with Google Apps Script A Step-by-Step Journey Full Chapter One Free

Unlock the Full Potential of Google Workspace with “Coding with Google Apps Script: A Step-by-Step Journey” – Free on Kindle for a Limited Time!

Read the first 2 chapters Free at Amazon – Get your free Kindle version of the book today

US https://www.amazon.com/dp/B0CXXLMMHQ

Can https://www.amazon.ca/dp/B0CXXLMMHQ

Over 200 Apps Script Coding Exercises here https://github.com/lsvekis/Coding-with-Google-Apps-Script/

In an ever-evolving digital workspace, mastering the art of automation and customization is not just a skill but a necessity. For those looking to elevate their Google Workspace experience, the new book “Coding with Google Apps Script: A Step-by-Step Journey” has arrived as a beacon of knowledge, and for the next two days, it’s available for free on Kindle!

This comprehensive guide is not your average programming manual. It’s a journey through the intricacies of Google Apps Script, designed to take you from a curious novice to a confident scriptwriter. By focusing on practical, real-world applications, the book demystifies the process of coding within Google Workspace, making it accessible, engaging, and, most importantly, effective.

Whether you’re looking to automate tasks in Google Sheets, create custom Gmail responses, or build dynamic reports in Google Docs, this book covers it all. With step-by-step instructions, readers are not just shown the path but are guided through it with detailed examples that illuminate the common challenges and questions that arise when working with Google Apps Script.

For beginners, the book lays a solid foundation of scripting basics. But it doesn’t stop there – advanced users will find themselves challenged and engaged by the exploration of complex projects and advanced techniques, including creating custom menus and integrating with external APIs.

What sets “Coding with Google Apps Script: A Step-by-Step Journey” apart is its commitment to active learning. Each chapter builds upon the last, encouraging readers to experiment, customize, and refine their scripts. It’s not just about learning; it’s about applying what you learn to solve real problems and streamline your workflows.

Don’t miss this opportunity to download your free copy and start transforming your Google Workspace experience with the power of Apps Script automation. Whether you’re looking to automate your daily tasks, enhance your productivity, or develop innovative applications, this book is your gateway to unlocking the full potential of Google Apps Script.

First 2 Chapters

Coding with Google Apps Script: A Step-by-Step Journey

With an emphasis on best practices, performance optimization, and real-world applications, this comprehensive guide serves as an invaluable resource for beginners and experienced users alike, empowering them to streamline workflows, increase productivity, and unlock the full potential of Google Workspace through automation with Google Apps Script. Backed by a collection of over 100 practical code examples


“Coding with Google Apps Script: A Step-by-Step Journey” is a comprehensive guide designed to help users harness the full potential of automation and scripting within the Google Workspace environment. With over 100 practical examples spread across various chapters, it covers fundamental concepts to advanced techniques, making it suitable for beginners and experienced users alike.

The teaching style of “Coding with Google Apps Script” eschews a traditional question-and-answer format, instead drawing from common coding questions encountered by students throughout courses covering Google Apps Script. Each chapter features coding examples accompanied by step-by-step walkthroughs, allowing readers to grasp concepts through real-world applications. This immersive approach not only enhances understanding but also prepares users to tackle real-world challenges confidently. In essence, “Coding with Google Apps Script” stands as an indispensable asset for individuals aspiring to optimize workflows, bolster productivity, and unlock the untapped potential of Google Workspace through the adept utilization of Google Apps Script’s automation capabilities.

Starting with the basics, readers are introduced to the fundamentals of Google Apps Script, including its applications and the basics of scripting and automation. “Coding with Google Apps Script” then progresses to cover essential topics such as working with Google Sheets, Docs, Forms, Slides, Gmail, and Drive, providing step-by-step guidance on automating tasks and workflows within these applications.

Readers learn how to manipulate data, generate reports, automate document creation, manage files and folders, integrate with Gmail, and leverage advanced features of Google Apps Script. Each chapter is structured to provide clear explanations of concepts along with practical examples that readers can follow to implement automation solutions tailored to their needs.

Advanced topics such as custom menus, web apps, external API integration, and error handling are also covered in detail, ensuring that readers gain a comprehensive understanding of Google Apps Script capabilities. Case studies and real-world applications provide insights into how Google Apps Script can be applied in various scenarios, from automating invoice generation to streamlining project management workflows.

Additionally, the book emphasizes best practices, performance optimization techniques, and tips for collaborative development, ensuring that readers not only learn how to automate tasks effectively but also maintain scalable, efficient, and secure solutions.

Overall, the book serves as an indispensable resource for anyone looking to streamline workflows, increase productivity, and unlock the full potential of Google Workspace through automation with Google Apps Script.

Chapter 1: Getting Started with Google Apps Script

  • Introduction to scripting and automation
  • Setting up your Google Apps Script environment
  • Understanding the script editor
  • Learning Resources for Google Apps Script
  • Creating Your First Google Apps Script
  • Differences Between Bound and Standalone Scripts
  • Limitations of Google Apps Script
  • Running and debugging scripts

Introduction to Google Apps Script

Google Apps Script is a powerful scripting platform developed by Google for light-weight application development in the Google Workspace platform. It allows you to automate tasks across Google products like Sheets, Docs, Drive, and Gmail with simple JavaScript code. This chapter will introduce you to the basics of Google Apps Script, from setting up your environment to writing your first script.

Are you tired of repetitive tasks eating up your valuable time? Do you wish there was a way to streamline your workflow and focus on what truly matters? Look no further than Google Apps Script—a powerful tool that allows you to automate tasks, customize workflows, and integrate Google Workspace applications seamlessly.

What is Google Apps Script?

Google Apps Script is a cloud-based scripting language developed by Google that allows users to extend the functionality of various Google Workspace applications, including Google Sheets, Google Docs, Gmail, Google Calendar, and more. With Apps Script, you can write code to automate tasks, create custom functions, build add-ons, and interact with external APIs—all within the familiar environment of Google Workspace.

Why Use Google Apps Script?

  • Automation: Save time and reduce errors by automating repetitive tasks such as data entry, report generation, and email notifications.
  • Customization: Tailor Google Workspace applications to fit your specific needs with custom functions, menus, and dialogs.
  • Integration: Seamlessly integrate data and processes across different Google Workspace apps, as well as external services and APIs.
  • Scalability: Scale your solutions from simple scripts to complex applications, depending on your requirements and expertise.

Setting Up Your Google Apps Script Environment

  • Access Google Apps Script: Navigate to Google Apps Script website and sign in with your Google account. Click “New Project” to start scripting.
  • The Script Editor: Familiarize yourself with the Google Apps Script editor interface, which includes the code editor, the log area, and the project settings.

Understanding the Script Editor

  • Code.gs File: This is where you write your JavaScript code. The “.gs” extension stands for Google Script.
  • Logs and Executions: Understand how to view logs and past executions to debug your script.
  • Project Settings: Learn about project properties, script properties, and user properties.

Apps Script Examples

I’ve provided 4 examples of using Google Apps Script, please note more explanation of the code and how they work will be provided throughout the book, these are examples to illustrate some of the powerful functionally of real world uses for Apps Script. 

Let’s write a simple script to get you started:

function sayHello() {

 Logger.log(‘Hello, Google Apps Script!’);


This script uses the Logger.log() method to print a message to the log. Here’s how you can run it:

  • Type the code into the Code.gs file.
  • Select the sayHello function in the dropdown menu near the run button.
  • Click the run button (play icon).
  • View the output by clicking View > Logs.

Running and Debugging Scripts

  • Executing Functions: Learn how to select and run individual functions within your script.
  • Authorization Requests: Understand why and how Google requires authorization for scripts to run.
  • Using Logs for Debugging: Use Logger.log() to print out variable values or debug messages.

Learning Resources for Google Apps Script

  • Official Documentation: Visit the Google Apps Script Documentation for comprehensive resources.
  • Tutorials and Guides: Look for tutorials on YouTube, Coursera, or free blogs to get different perspectives and use-cases.

Creating Your First Google Apps Script

Follow the step-by-step process above to create and run a simple script. Experiment by modifying the message in Logger.log() to see different outputs.

Differences Between Bound and Standalone Scripts

  • Bound Scripts: Created within and bound to a specific Google Workspace document (like a Google Sheet or Doc).
  • Standalone Scripts: Independent scripts that you create in the Google Apps Script dashboard.

Limitations of Google Apps Script

  • Quota Limits: Google Apps Script has daily quota limits (like the number of emails you can send); check the current limits in the documentation.
  • Execution Time: Scripts cannot run longer than a set maximum execution time.

Tips for Getting Started:

  • Start Small: Begin with simple scripts to understand the basics before moving to complex projects.
  • Read and Modify Examples: Learn from examples provided in the documentation or community forums.
  • Consistent Practice: The best way to learn is by doing; try to write and run small scripts regularly.

By the end of this chapter, you should be comfortable with setting up Google Apps Script, writing basic scripts, and understanding the environment. Continue experimenting with simple scripts, and utilize the vast array of learning resources available to deepen your understanding.

Sending Email Notifications from Google Sheets

Let’s say you have a Google Sheets spreadsheet containing a list of tasks, and you want to send email notifications to team members when a task is assigned to them.

Table data:

Task DescriptionAssigned ToEmail Address
Review ReportJohnjohn@example.com
Update WebsiteSarahsarah@example.com
Data AnalysisMichaelmichael@example.com
Prepare PresentationEmilyemily@example.com
Code RefactoringDaviddavid@example.com

Step 1: Open Google Sheets and Navigate to “Extensions” > “Apps Script”

Step 2: Write the Script

function sendEmailNotification() {

  const sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();

  const lastRow = sheet.getLastRow();

  for (let i = 2; i <= lastRow; i++) {

    const assignedTo = sheet.getRange(i, 2).getValue(); // Assuming assignedTo column is B

    const taskDescription = sheet.getRange(i, 1).getValue(); // Assuming taskDescription column is A

    const emailAddress = sheet.getRange(i, 3).getValue(); // Assuming emailAddress column is C

    if (assignedTo !== “” && emailAddress !== “”) {

      const subject = “Task Assigned: ” + taskDescription;

      const message = “You have been assigned a new task: ” + taskDescription;

      MailApp.sendEmail(emailAddress, subject, message);




Step 3: Save and Run the Script

After writing the script, save it and run the sendEmailNotification function. You may need to authorize the script to send emails on your behalf.


  • Use Triggers: Set up triggers to run your scripts automatically at specified times or in response to certain events, such as when a form is submitted or a spreadsheet is edited.
  • Leverage Google APIs: Explore the wide range of Google APIs available in Apps Script to interact with Google services and external APIs, such as Google Drive, Calendar, Maps, and more.
  • Learn from Examples: Take advantage of the extensive documentation and community resources available for Google Apps Script. Experiment with sample scripts, read tutorials, and join online forums to learn from others and troubleshoot issues.

Google Apps Script is a valuable tool for automating tasks, customizing workflows, and enhancing productivity within the Google Workspace ecosystem. Whether you’re a beginner or an experienced developer, Apps Script offers a user-friendly platform to unleash your creativity and streamline your workflow.

Capabilities of Google Apps Script:

  • Automation: One of the primary capabilities of Google Apps Script is automation. Users can create scripts to automate repetitive tasks, such as data entry, sending emails, generating reports, and updating information in Google Sheets or Docs.

Automatically send emails to new form respondents

Table data:

Respondent Email


function sendEmails() {

 const formResponses = FormApp.openById(‘FORM_ID’).getResponses();

 const template = HtmlService.createHtmlOutputFromFile(’emailTemplate’).getContent();

  formResponses.forEach(function(response) {

 const respondentEmail = response.getRespondentEmail();

 const emailSubject = “Thank you for your response!”;

 const emailBody = “Here is the email content…”;

  //Send email

 MailApp.sendEmail(respondentEmail, emailSubject, emailBody, {htmlBody: template});



Integration with Google Products: Google Apps Script seamlessly integrates with various Google products. This allows users to manipulate data, create custom functions, and build applications within the Google ecosystem.

Automatically create Google Calendar events from Google Sheets data

Table Data:

Event TitleEvent DateEvent Description
Team Meeting2024-03-10Weekly team meeting
Project Deadline2024-03-15Submit project report by EOD
Training Session2024-03-20Sales training session
Client Meeting2024-03-25Meeting with ABC Corp
Presentation2024-03-28Deliver presentation to stakeholders


function createCalendarEvents() {

 const sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();

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

  data.forEach(function(row) {

 const eventTitle = row[0];

 const eventDate = row[1];

 const eventDescription = row[2];

  //Create Calendar Event

 const calendar = CalendarApp.getDefaultCalendar();

 calendar.createEvent(eventTitle, new Date(eventDate), new Date(eventDate), {description: eventDescription});



Web App Development: With Google Apps Script, users can create web applications hosted on Google’s servers. These applications can interact with Google services and external APIs, making them powerful tools for various purposes such as surveys, quizzes, and data collection.

Create a web app to collect user feedback

Collaboration and Sharing: Google Apps Script facilitates collaboration by allowing users to share and run scripts with others. This enables teams to work together on automation tasks, custom functions, and web applications within the Google Workspace environment.

Tips for Using Google Apps Script:

  • Start Small: If you’re new to Google Apps Script, start with simple tasks and gradually increase complexity. This will help you familiarize yourself with the platform and build confidence in your scripting abilities.
  • Utilize Resources: Google provides extensive documentation, tutorials, and a supportive community for Apps Script users. Take advantage of these resources to learn new techniques, troubleshoot issues, and stay updated on best practices.
  • Test and Debug: Always test your scripts thoroughly before deploying them in a production environment. Use the built-in debugger and logging features to identify and fix any errors or unexpected behavior.
  • Follow Security Best Practices: Be mindful of security considerations when working with sensitive data or integrating with external services. Follow Google’s guidelines for securing Apps Script projects and avoid sharing sensitive information in your scripts.
  • Stay Updated: Google frequently updates Apps Script with new features and improvements. Stay informed about these updates to leverage the latest capabilities and optimize your workflow.

HTML webapp code:

<!DOCTYPE html>



  <base target=”_top”>


    function submitForm() {

      var feedback = document.getElementById(“feedback”).value;

      google.script.run.withSuccessHandler(onSuccess).submitFeedback({feedback: feedback});

      document.getElementById(“feedback”).value = “”; // Clear the input field after submission

      document.getElementById(“submitMessage”).innerHTML = “Feedback submitted successfully!”;


    function onSuccess(mes) {






  <h1>Feedback Form</h1>


    <label for=”feedback”>Enter your feedback:</label><br>

    <textarea id=”feedback” name=”feedback” rows=”4″ cols=”50″></textarea><br><br>

    <input type=”button” value=”Submit” onclick=”submitForm()”>


  <p id=”submitMessage”></p>



apps Script Code:

const SHEET_ID = ‘1lOM’;

function doGet() {

 return HtmlService.createHtmlOutputFromFile(‘index’);


function submitFeedback(form) {

 const timestamp = new Date();

 const feedback = form.feedback;

  //Store feedback in Google Sheet

 const sheet = SpreadsheetApp.openById(SHEET_ID).getSheetByName(‘data’);

 sheet.appendRow([timestamp, feedback]);

  return “Feedback submitted successfully!”;


Image: Sample of web app output.

Data Table:

2024-03-07 10:00:00Great job on the project!
2024-03-07 11:30:00The website needs improvement in design.
2024-03-07 14:45:00The customer service was excellent.

In conclusion, Google Apps Script offers a versatile platform for automating tasks, extending the functionality of Google products, and building custom solutions within the Google Workspace environment. By leveraging its capabilities and following best practices, users can streamline workflows, increase productivity, and unlock new possibilities for collaboration and innovation.

Introduction to Scripting and Automation

In the realm of digital technology, scripting and automation are pivotal in enhancing efficiency, reducing manual labor, and improving the accuracy of repetitive tasks. This section will introduce you to the concepts of scripting and automation, providing examples and tips to kickstart your journey.

What is Scripting?

Scripting involves writing short programs, known as scripts, to automate tasks within software applications. Scripts are usually written in scripting languages like JavaScript, Python, or Bash. Unlike full-fledged programming, scripting focuses on small, task-oriented programs that interact with other software.

Example: Automating the process of data formatting in a spreadsheet could involve writing a script that automatically converts dates into a standard format, sums up values in certain columns, or highlights specific data points based on predefined criteria.

What is Automation?

Automation refers to the process of making systems operate automatically without human intervention. In the context of IT and business processes, automation can range from simple tasks, like scheduling reminders, to complex operations, like running data analysis reports on a regular basis.

Example: A business might automate its monthly reporting process by using scripts that pull data from various sources, compile it into a report format, and then email this report to the relevant stakeholders.

Scripting Languages and Tools

  • JavaScript: Widely used in web development and for Google Apps Script.
  • Python: Known for its readability and versatility in data analysis, web development, and automation.
  • Shell Scripts (Bash): Used for automating tasks in Linux and Unix environments.
  • PowerShell: A task automation and configuration management framework from Microsoft, consisting of a command-line shell and associated scripting language.

Benefits of Scripting and Automation

  • Efficiency: Automates repetitive tasks, saving time and reducing errors.
  • Consistency: Ensures tasks are performed in the same way every time, maintaining standardization.
  • Scalability: Enables handling of increasing workloads without a proportional increase in effort or time.
  • Empowerment: Allows users with non-programming backgrounds to create custom solutions.

Examples of Scripting and Automation

  • Automating Emails: Writing a script that sends out weekly status reports to a team.
  • Data Backup: Creating a script that regularly backs up data from your computer to the cloud.
  • Web Scraping: Writing a script to extract information from websites and compile it into a database or spreadsheet.

Tips for Getting Started with Scripting and Automation

  • Identify Repetitive Tasks: Start with automating small, repetitive tasks that consume unnecessary time.
  • Learn by Doing: Begin with simple scripts to understand the basics. Use online resources, forums, and documentation for learning.
  • Test in Segments: Test your scripts in small segments to ensure each part works correctly before moving on.
  • Use Comments: Comment your code to remember your thought process and to make it understandable to others.
  • Keep Learning: Technology and scripting languages evolve rapidly. Stay updated with the latest trends and practices.

Understanding the basics of scripting and automation can significantly enhance your productivity and operational efficiency. By learning how to write scripts, you can automate mundane tasks, allowing you to focus on more complex and creative aspects of your work or life.

Start exploring the possibilities of scripting in your daily tasks, whether it’s through automating data entry in spreadsheets, organizing files on your computer, or managing your emails more effectively. Remember, the goal of automation is to make your life easier, so start small and gradually increase the complexity of your scripts as you become more comfortable with the concepts and languages.

Understanding the Script Editor

The script editor is an essential tool for anyone working with Google Apps Script or similar scripting environments. It’s where you write, debug, and manage your scripts. This section will introduce you to the script editor, its features, and how to effectively use it for your scripting projects.

Image: Google Apps Script IDE

Introduction to the Script Editor

The script editor is an integrated development environment (IDE) that allows you to write and manage your code. In the context of Google Apps Script, the script editor is built into Google Workspace, enabling you to automate tasks across Google products like Sheets, Docs, and Forms.

Key Features of the Script Editor

  • Code Writing Area: This is the main part of the editor where you write your script. It supports syntax highlighting, which helps differentiate elements such as comments, variables, and strings.
  • Log and Execution Transcript: The script editor provides a logging area where you can view output messages and errors. This is crucial for debugging your scripts.
  • File Management: You can manage multiple script files and HTML/CSS files within the same project, allowing for organized and modular code.
  • Triggers: The editor allows you to set up triggers that run your script automatically based on specific events, such as time-based triggers or event-driven triggers (e.g., on form submit).
  • Authorization and Permissions: Before running scripts that interact with Google services, you will need to authorize them. The script editor guides you through this process.
  • Versioning: You can save different versions of your script to keep track of changes and revert to earlier versions if necessary.

Navigating the Script Editor

  • Menu Options: Explore the menu options like File, Edit, View, Run, and Help for various functionalities like creating new files, accessing project settings, and finding script documentation.
  • Toolbar: Use the toolbar for common actions such as running, debugging, or deploying your script.
  • Script Files: On the left pane, you can switch between different script and HTML files within your project.
  • Logging Console: Access this through View > Logs to debug your script by reviewing printed messages or errors.

Examples of Using the Script Editor

  • Creating a Simple Script: Write a basic script, such as one that logs a custom message or modifies a document, to get familiar with typing and executing code in the editor.
  • Setting a Trigger: Try setting up a time-driven trigger that executes a function daily or when a specific condition in a Google Sheet is met.
  • Debugging: Use Logger.log() statements to debug your script, printing out variable values or checkpoints to understand the script’s flow and identify issues.

Tips for Using the Script Editor

  • Use Keyboard Shortcuts: Learn and use keyboard shortcuts for common actions like running a script (Ctrl + R) or opening the log (Ctrl + Enter) to save time.
  • Format Your Code: Make your code more readable by using proper indentation and spacing. The script editor has an auto-formatting feature (Format > Format document).
  • Document Your Code: Use comments to explain what your code does, making it easier for others (or yourself in the future) to understand.
  • Test Frequently: Run your script after adding a few lines of code to catch errors early and understand how changes affect the outcome.
  • Back Up Your Work: Utilize the versioning feature to save snapshots of your script at different stages.

The script editor is a powerful tool for scripting and automation within Google Workspace. Familiarizing yourself with its features and best practices can greatly enhance your productivity and effectiveness in writing, debugging, and managing scripts. Start with simple scripts to get a feel for the environment and gradually move on to more complex projects as you become more comfortable.

Learning Resources for Google Apps Script

Google Apps Script is a versatile scripting language for automating and enhancing workflows across Google Workspace applications. Whether you’re a beginner looking to automate simple tasks or an advanced user aiming to create complex integrations, numerous resources can help you improve your skills. This section covers essential learning resources, including official documentation, online courses, communities, and more.

Official Google Apps Script Documentation

  • Overview and Guides: Start with the official Google Apps Script Documentation for a comprehensive introduction, including quickstarts, guides, and reference materials.
  • Codelabs: Google Codelabs provide hands-on coding experiences, guiding you through various tasks and projects specific to Google Apps Script.

Online Courses and Tutorials

  • Udemy: Search for Google Apps Script courses on platforms like Coursera and Udemy. These courses range from beginner to advanced levels and often include video lectures, quizzes, and hands-on projects.
  • YouTube: Platforms like YouTube host numerous tutorial channels dedicated to Google Apps Script, such as “Learn Google Spreadsheets” and “The Coding Train.” These channels offer visual and practical learning experiences.

Community Forums and Support

  • Stack Overflow: The google-apps-script tag on Stack Overflow is a valuable resource for finding answers to specific coding questions and troubleshooting issues.
  • Google Apps Script Google Group: Join the Google Apps Script Community to ask questions, share knowledge, and connect with other Apps Script developers.

Blogs and Websites

  • Apps Script : Laurence Svekis regularly posts coding examples and Google Apps Script content https://basescripts.com/ 
  • Google Developers Blog: Keep an eye on the Google Developers Blog for announcements, updates, and best practices.

Examples of Learning Projects

  • Automating Google Sheets: Create a script that automates data entry, formatting, and analysis in Google Sheets.
  • Building Custom Functions: Develop custom functions for Google Sheets that can be used directly in spreadsheet formulas.
  • Email Automation: Write a script that automates sending personalized emails from a Gmail account.
  • Web App Development: Use Google Apps Script to create and deploy a simple web application.

Tips for Learning Google Apps Script

  • Start Small: Begin with small, manageable projects to grasp the basics before attempting more complex tasks.
  • Practice Regularly: The best way to learn is by doing. Try to incorporate Google Apps Script into your daily workflows.
  • Read and Modify Existing Scripts: Look at scripts written by others to learn different approaches and best practices.
  • Utilize Debugging Tools: Familiarize yourself with the debugging tools in the Google Apps Script editor to troubleshoot and refine your code.
  • Join the Community: Engage with the Google Apps Script community by participating in forums, attending webinars, and collaborating on projects.

By leveraging these resources and following these tips, you can progressively build your proficiency in Google Apps Script, enabling you to automate tasks, streamline workflows, and create custom integrations within the Google Workspace ecosystem.

Creating Your First Google Apps Script

Welcome to the world of automation with Google Apps Script! This powerful tool allows you to extend the functionality of Google Workspace apps like Sheets, Docs, and Gmail. This section will guide you through creating your first script, from setting up your environment to writing and running your code.

Setting Up Your Environment

Before you start scripting, you need access to Google Apps Script:

  • Open Google Apps Script: Navigate to the Google Apps Script website. If you’re logged into your Google account, you’ll be directed to the script dashboard.
  • Create a New Project: Click on “New Project.” You’ll be taken to the script editor, where you can write and manage your scripts.

Writing Your First Script

Let’s start with a simple script. You’ll create a function that writes “Hello, world!” to the log.

Write the Script:

  • In the Code.gs file, erase any preexisting code and type the following:

function helloWorld() {

 Logger.log(‘Hello, world!’);


Save Your Script:

  • Click the disk icon or go to File > Save, and give your project a name, like “My First Script.”

Running Your Script

Now that you’ve written your script, it’s time to run it:

  • Select the Function: In the dropdown menu near the play button (Run), select helloWorld.
  • Run the Script: Click the play button. The first time you run a script, Google will ask for authorization. Follow the prompts to allow your script to run.
  • View the Logs: Once the script has executed, go to View > Logs. You should see “Hello, world!” in the output.

Understanding What Happened

  • Logger.log(): This command prints a message to the Google Apps Script log, a helpful tool for debugging.
  • Authorization: Google Apps Script requires authorization to ensure that scripts have permission to access your data and perform actions.

Tips for Creating Google Apps Script

  • Start Simple: Begin with simple scripts to understand the basics of Google Apps Script.
  • Use Comments: Add comments to your code (using // or /* */) to explain what your script does, making it easier to understand and maintain.
  • Regular Testing: Test your script regularly as you write it to catch errors early and understand how your code is working.
  • Explore Google Services: Google Apps Script can interact with most Google services. Explore the documentation to see what’s possible.

Expanding Your Script

Once you’re comfortable with the basics, try expanding your script. For example, modify your helloWorld function to interact with Google Sheets:

Write To a Sheet

function writeToSheet() {

 const sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();

 sheet.getRange(‘A1’).setValue(‘Hello, world!’);


This script gets the active sheet and writes “Hello, world!” in cell A1. Experiment with different Google services and functionalities to see what you can automate.

Remember to start small, test often, and consult the Google Apps Script documentation to learn more about what you can achieve. Happy scripting!

Differences Between Bound and Standalone Scripts

Google Apps Script offers two distinct environments for developing and running scripts: bound scripts and standalone scripts. Understanding the differences between these two types can help you choose the best approach for your project. This section will explore those differences, with examples and tips for using each type effectively.

What are Bound Scripts?

Bound scripts are directly associated with a specific Google Workspace document, such as a Google Sheet, Doc, or Form. They are created within and tied to that document, making them ideal for tasks that interact closely with the document’s content.

Characteristics of Bound Scripts:

  • Access: They can be accessed from the Google Workspace document by clicking on Extensions > Apps Script.
  • Permissions: They automatically operate with the permissions of the user interacting with the Google Workspace document.
  • Sharing: When you share the document, the script is shared along with it, but the script’s code remains invisible to those without edit access.

Example of Bound Script add menu Item

Creating a custom menu in Google Sheets to perform functions like clearing specific ranges or inserting templated content.

function onOpen() {

 const ui = SpreadsheetApp.getUi();

 ui.createMenu(‘Custom Menu’)

 .addItem(‘Clear Range’, ‘clearRange’)



function clearRange() {

 const sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();



Image: Example of menu item added with onOpen apps script.

What are Standalone Scripts?

Standalone scripts are independent of any Google Workspace document. They are created from the Google Apps Script dashboard and can be used to interact with multiple Google services or perform tasks unrelated to a specific document.

Characteristics of Standalone Scripts:

  • Access: Accessed and managed through the Google Apps Script dashboard.
  • Permissions: Users are prompted to authorize permissions when the script is run, based on the script’s requirements.
  • Sharing: They can be shared independently of Google Workspace documents, making them more flexible for widespread use.

Example of Standalone Script Check emails

A script that checks your Gmail for unread messages and logs the count:

function checkUnreadEmails() {

 const unread = GmailApp.getInboxUnreadCount();

 Logger.log(‘You have ‘ + unread + ‘ unread emails.’);


Image: Example of Logger output for above script 

Choosing Between Bound and Standalone Scripts

  • Use bound scripts when your tasks are closely tied to a specific Google Workspace document, such as custom spreadsheet functions or document formatting.
  • Use standalone scripts for tasks that span multiple documents or when you need a central script to manage various functions across your Google Workspace.

Tips for Using Bound and Standalone Scripts

  • Bound Scripts: Keep them focused on the specific document’s needs. Be mindful of the script’s impact on shared documents.
  • Standalone Scripts: Use them for broader applications, such as web apps, add-ons, or scripts that interact with multiple services.
  • Authorization and Permissions: Understand the scope of permissions required by your script, especially with standalone scripts that might need broader access.
  • Testing and Debugging: Test scripts thoroughly in their respective environments. Bound scripts may behave differently depending on the user and document, while standalone scripts need testing across different services and use cases.

Understanding the differences between bound and standalone scripts is crucial for effective Google Apps Script development. By choosing the right type for your needs, you can create efficient, secure, and user-friendly scripts that enhance your productivity and extend the functionality of Google Workspace.

Limitations of Google Apps Script

Google Apps Script is a powerful tool for automating and extending Google Workspace applications and other web services. However, like any platform, it has certain limitations that developers need to be aware of when designing and implementing their scripts. Understanding these limitations will help you create more efficient scripts and plan for alternative solutions when necessary.

Execution Time Limits

One of the primary limitations of Google Apps Script is the maximum execution time. Scripts have a maximum execution time, which varies based on the type of Google account you have:

  • Consumer (e.g., @gmail.com): 6-minute maximum execution time per execution.
  • Workspace accounts: Depending on your account tier, execution time can extend up to 30 minutes.

Tip: Optimize script performance by minimizing the use of services within loops, using batch operations, and splitting large tasks into smaller, manageable functions.

Quota Limits

Google Apps Script enforces quotas and limitations on various services and actions. These include, but are not limited to:

  • Email recipients per day
  • Triggers created per script
  • Concurrent executions

The specific quotas can vary based on your account type (e.g., consumer, Workspace, or Cloud Identity) and are subject to change.

Tip: Regularly check the Apps Script quotas page for the most current limits and plan your script usage accordingly.

Authorization and Permissions

Scripts require authorization to access Google services or data on behalf of the user. This can be a limitation if:

  • Users are wary of granting permissions.
  • The script requires sensitive scopes that need admin approval in a Workspace domain.

Tip: Clearly communicate the necessity and use of each permission your script requires to your users or administrators.

API and Service Limitations

While Google Apps Script can interact with Google APIs and external APIs, there are limitations:

  • Certain Google APIs might have usage limits.
  • Not all Google services have advanced services in Google Apps Script.
  • Calling external APIs may be subject to CORS (Cross-Origin Resource Sharing) restrictions.

Tip: Review the API quotas and limitations beforehand and consider using URL Fetch service for external API calls while handling potential CORS issues.

Size and Complexity Limits

Scripts and projects also have size and complexity limits, such as:

  • Maximum script size (including all files): 1 million characters.
  • Maximum size for returned content in URL Fetch calls: 50 MB.

Tip: Keep your codebase modular, clean up unnecessary code, and utilize external storage (e.g., Google Drive) for large data sets.

Shared Script Limitations

For bound scripts, sharing the Google document doesn’t necessarily share the script’s functionality automatically, especially if custom UI or triggers are involved.

Tip: Ensure users are aware of how to enable scripts or deploy them as add-ons for broader distribution.

Browser Compatibility and HTML Service

Scripts and custom interfaces built with HTML service may behave differently across browsers due to varying support for HTML, CSS, and JavaScript.

Tip: Test your script’s user interface across different browsers and adhere to common web standards for maximum compatibility.

Debugging and Error Reporting

Google Apps Script’s debugging tools are less robust compared to those available in traditional development environments.

Tip: Use Logger.log() and Console.log() for debugging, and consider integrating with Stackdriver Logging for more advanced error reporting.

While Google Apps Script provides extensive capabilities for automating and extending Google Workspace applications, being aware of its limitations is crucial for effective script development. By understanding and planning for these limitations, you can create more reliable, efficient, and user-friendly scripts. Remember to regularly review Google’s documentation and community forums for updates and tips on navigating these limitations.