MIKE PROCOPIO: Well, hello, everyone,
and welcome to Google Cloud Next.
Today, we're going to talk about how AppSheet
integrates with and helps you work smarter
with Google Workspace.
I'm Mike Procopio, a senior staff software engineer
here on the AppSheet team in Google Cloud.
And let's take a look at where we're going to go in this talk
here today.
The concept of AppSheet, and no-code app building
in particular, could be new for many of us, as it was for me.
So before we dive into the ways that AppSheet integrates
with Google Workspace, we're first
going to look a little bit about no-code platforms for building
apps in general.
Then we'll talk about how we actually
integrate with Workspace, in particular
focusing on dynamic mail, which is a new feature.
We'll also look at AppSheet integration
and how AppSheet works with Chat and Spaces
to extend Google Workspace.
Here's the team.
I happen to be the one that gets to present
on behalf of the team today, showcasing this work.
But these features are brought to you by many people,
both on the AppSheet team, but also
on the Google Workspace integration team.
And here's some of our folks.
So AppSheet is Google Cloud's no-code platform
for citizen developers.
And we are in a new era of no-code, which is basically
the notion of being able to build apps
without any actual traditional programming and/or software
engineering.
And so no-code platforms enable citizen developers to quickly
build apps without any code.
Typically, these are built on an existing data
source, such as a database or Google Sheets in the cloud.
And we can quickly create business value
by codifying existing business processes that
are in existence today.
And we can deploy the apps that we make quickly
and across multiple platforms.
So AppSheet is Google's no-code app building platform
for citizen developers.
Importantly, anyone on your team can make apps and automate
processes.
These are able to deploy across multiple platforms,
like web and mobile.
And they are-- operate in real time.
And they are powerful.
They have rich user experiences and robust feature sets.
So let's see how this would actually work in practice.
The diagram at the bottom shows the high-level architecture
of the concept of a no-code app.
In the middle, we have the actual app definition,
the thing that we actually build inside AppSheet that
specifies how the app works.
Of course, this is typically built
on an actual data source-- a database or spreadsheet,
for example.
That's what we see in the box on the left.
And then finally, the app that you specify inside AppSheet,
the no-code development environment,
is automatically generated from that specification and data
source and created into an actual live app that,
of course, is then deployed live across multiple platforms.
So let's see what that actually looks like.
Here's the development environment
inside actual AppSheet.
You will notice there is no code.
And that is one of the core value propositions
of no-code app building.
And on the left is the traditional navigation
and where we can actually-- instead of coding,
we specify, in broader terms, how the app works.
In this case, we're in the Data tab
and focusing on tables, where we can talk about which columns
in the actual table or sheet or database
perform which function.
And they can have specific slices and security
rules apply to them, and so on.
And on the right side, we see an actual live preview
of the app in the moment across multiple platforms and screen
form factors.
In this case, it's an app that's built around creating
and monitoring tasks.
And we see, basically, a card layout
that shows the status of all the tasks
that are assigned to your user.
And of course, the user can create new tasks.
Something like this could be generated pretty quickly,
like on the order of a day.
So because AppSheet makes it so easy to build apps
and empowers business technologists and citizen
developers, many people are able to actually build these
beyond just traditional software engineering computer science
sorts of fields.
In fact, 3.7 million AppSheet apps have been created to date.
So the quotes below are from an actual case study that we did.
And I won't read them.
But one of the key takeaways from them
here is that a skilled citizen developer
can deliver a fairly complicated app
in the order of two to four weeks, like a month,
without actually having to code.
And these can be very powerful apps
that can perform very complicated automation
functions and business practices.
And this is in contrast to traditional software
engineering, where you create an app
and it might take on the order of a year to build,
or more, if you're in the best-case scenario.
So that's one of the key value propositions of AppSheet--
is not only does it empower a different class of developer
to actually build an app without having to write code,
we can build them much more quickly.
Let's talk about AppSheet and Google Workspace.
Google Workspace is used by millions
of people and businesses.
So here's an example of Google Workspace in action.
And we can see that this particular animated screenshot
focuses on Gmail, which brings in Chat and Spaces and Docs
and mail and content all in one central hub.
Now, that turns out to be really important
to what Google Workspace is trying to do
as well as how AppSheet is trying to integrate
with Google Workspace.
Gmail, in particular, has become a central hub for productivity
in Google Workspace.
Take a look at the screenshot.
So again, as we noted, we're now integrating mail, Chat, Spaces,
and Google Meet with the actual content
of whatever we're looking at.
Maybe it's chat or mail.
And then on the right side here, we actually
see a live, editable document preview--
so where we can actually edit inline.
And then also notice on the right
is the sidebar that allows additional access to Google
key Tasks, Drive, and Calendar.
So we can see pretty much everything
is integrated into one single view.
And this is central to what we're
trying to do for productivity-- is meet the user where they're
at and keep them in context as much as possible.
So the goal of the integration with Google Workspace
with AppSheet is to be able to extend and customize
Google Workspace.
And we do this through three key ways.
The first layer is available now,
and it's called dynamic mail.
And this brings the power of AppSheet
apps right into Gmail, keeping the user in context.
Next is integration with AppSheet,
which bridges the no-code and low-code development
environment, so we can leverage and access
an increasing degree of functionality
that AppSheet provides.
And then finally, we have a vision
for how we'll integrate with Google Spaces, which
uses the existingly-- existing increasingly rich
functionality available in Google Spaces
to integrate with automations and collect data and meet
the user where they're at in workflow of Google scenarios.
Let's take a look at dynamic mail in particular,
bringing AppSheet into--
AppSheet apps directly into Gmail.
So the screenshot on the right, animated screenshot,
shows us, fundamentally, what this looks like.
You'll recognize it looks pretty similar to one of the apps
that we showed earlier when we were
looking at how AppSheet works in that development environment.
This is an app.
This is a view in an app.
The data is live and available right
in the email message using a technology called AM email.
So this is available now.
And it allows the user to easily send AppSheet forms and views
to users in Gmail with dynamic data that's
updated with the latest data and the data source
when the message is rendered.
So it basically brings AppSheet apps where the user is,
meeting them directly in Gmail, which
is one of the key ideas of the increasingly rich capabilities
we've built into Gmail.
So data is updated live from the underlying data source.
And we can collect live data from the user as well.
And it can be written back all within the context
of that email message.
And when that's done, of course, when data is submitted,
it can trigger additional workflows
that's specified and available inside your no-code app.
So now let's take a look at a demo
for how this works in practice.
Hello.
I'm Mike Procopio, a software engineer
at Google working on AppSheet.
AppSheet is Google's no-code platform
for citizen developers that lets you quickly
build multi-platform applications on top
of common data sources, all without having
to write any code.
Today, I'm going to show a demo of the new dynamic email
feature in AppSheet that lets you bring your no-code apps
right into Gmail.
For this demo, I've written an example app in AppSheet
for making and approving travel requests.
These requests are then reviewed and approved
by a manager in the organization.
And with the new dynamic email feature,
these approvals can now be performed
right from within Gmail.
First, let's talk about data.
In this demo, the application data
is stored in a Google Sheet.
But this could be any cloud-enabled data source,
such as Salesforce or a database already in use
by your organization.
Let's have a look at the user experience
for creating and improving travel costs.
In this demo, we have a user, Santosh,
who has some upcoming business travel,
but must first get approval.
Santosh files a travel request by directly
accessing the AppSheet app.
He adds in travel details, cost, business purpose, and notes
before saving.
This sends the data to the AppSheet server,
which then writes it back to the Google Sheet.
And if we open up the sheet, we can
see that, indeed, a new road has been added with the details
that Santosh just entered--
so far, so good.
Now, here's where it gets interesting.
On the AppSheet side, the app creator
has set up an automation which monitors for new travel
requests and then sends a dynamic email containing
the approval form to the travel manager, Maria.
This appears just like a standard email
in Maria's inbox except that, because it is a dynamic email,
it contains live, up-to-date information
retrieved from the app's data source
when the email is first opened.
This uses a technology called AMP that is built into Gmail.
A dynamic email can also collect a lot of user input
right inside the email.
And this allows Maria to review and approve the travel request
from within Gmail, allowing her to stay
in context without having to navigate away.
Here we see that Maria approves the request,
adds in some notes, and then moves on to other tasks.
And as expected, if we open up the Google Sheet,
we can see that Maria's approval and notes now
appear in the row that was initially
created for the travel request.
Now let's see how this works from the perspective of the app
creator.
Inside the AppSheet editor, we can see the two main views
used by the app.
There's one view for collecting the details of the travel
request and a second view for approving the request.
The views are populated with data from the Google Sheet.
The power of this comes from automations,
which allow an app creator to specify certain actions to take
when some criteria is met.
So in this demo, there's one automation
that monitors for when new travel requests are created.
The action then taken is to send a dynamic email
to the approver that contains the approval view.
All of this can be quickly specified in a few minutes
and without using any code.
Simply reference an existing view to embed in the email,
and you're ready to go.
Well, that concludes our demo of AppSheet dynamic emails.
Thank you for watching, and we can't
wait to see what you build.
So having seen how AppSheet integrates with dynamic email,
let's take a look at how AppSheet
integrates with Apps Script.
So Apps Script enables custom integrations
with Google Workspace.
And as we noted before, it's Google's low-code development
environment.
So this enables business solutions
that integrate, automate, and extend Google Workspace
properties, like Google Docs, Sheets, Slides, Gmail,
Calendar, Maps, and others.
Importantly, it can also be used to call external services,
or perhaps internal services available
within your organization.
No professional development experience is required.
And it's universally available to everyone
with a Gmail account.
So here are some example use cases.
I'll pick a few to focus on.
We talked about how integrating with Apps Scrips
allows an AppSheet app to automate or extend
or programmatically interact with Google Docs properties--
so, for example, Google Slides.
We could edit or create a Google Slide every time
a row is edited or updated or inserted into an AppSheet app.
We can do the same with a calendar appointment.
And so in this way, you can imagine
triggering-- scheduling workflows
from the user's interactions with the AppSheet app.
The final one here at the bottom is an interesting one
I'll call attention to.
Using Apps Script and integrating with it,
we could, for example, call an external service.
Again, perhaps it's internal.
In this case, it could be a trained machine
learning model that can make predictions on data.
And this is just to show an example that's--
that extends past traditional Google Workspace integration.
But that could be an internal service for you.
And the machine learning model can
make a prediction and the value of that could be written back
to your AppSheet app.
And then it can also trigger additional workflows--
for example, sending a dynamic mail.
So let's see what that would look like.
So the idea with a no-code app is
that this should be fairly straightforward to do
and we should be able to do it in a no-code way.
Here's what that actually looks like.
And it's fairly-- it matches what you might expect.
First, we have an automation inside the AppSheet app
to do something.
In this case, it's triggered, and then it executes a task.
This case-- the task is calling an Apps Script function.
So we'll choose which script, and we'll
choose which function to call in the script.
And then this is where it gets interesting.
We choose which parameters to pass to the function.
Where do these parameters come from?
Well, they are derived from your data,
from the columns inside the data source that your AppSheet
app is built on.
And it can also be functions, more complicated functions,
and expressions of multiple pieces of data,
perhaps, across multiple data sources.
And then, finally, that function may, in many cases,
return a value.
And your integration can specify what
to do with that returned value--
for example, writing it to the data store or, perhaps,
using it in a feedforward way to seed other automations
that are built into the app.
So that covers the integration that we
envision with Apps Script, which is in development now.
Here's future vision for how AppSheet will
integrate with Google Spaces.
So one neat thing about Google Spaces
is that there is a very strong extensibility story in place
now.
So for example, commands and dialogues--
so slash commands are a fairly common way
that you can interact with additional functionality
from within the context of a chat window.
This applies to a Spaces--
to Google Space, or also an actual individual chat.
So this can initiate processes.
It's very easily configured.
And-- of note--
it can actually call into your AppSheet app.
Now, one of the more recent things
that are launched and available related
to extensibility for Google Spaces involves rich dialogs.
These are powerful because, now, within the context of a chat,
we can pop up a mobile dialog and you
can interact with the user in a way that's
even less than the traditional conversational way.
We can collect data from the user
and show dynamic data that's up-to-date.
So this is built into Google Spaces today.
And it's important for us because once this data is
submitted, it could call into an AppSheet API
and trigger workflows.
And it can trigger, also, additional automations.
But here is one of the key points of the vision
once we move past this state.
So with this integration, we hope, again,
to meet the user where they're at within Gmail-- in this case,
within the actual chat context.
And this screenshot on the right shows a mock-up
of an idea where we can approve a workflow from the context
of Google Chat.
Now, this is a workflow that's triggered from the AppSheet
app, where it integrates with the actual user conversation
right now.
And the user can approve inline a--
in this case, a travel request.
This data is written back to the AppSheet app.
And we could also use the dialogs that we showed earlier
to create--
to collect additional data from the user
beyond just a simple approval where we could have,
for example, approval comments or other conditions
or metadata.
Well, OK, everyone.
That wraps up our three key integration points
with AppSheet and Google Workspace.
We talked about dynamic mail, integration with Apps Script,
and integration with Chat and Spaces.
Let's talk about next steps with AppSheet.
Here are first steps for learning
more about no-code in general and building apps
with AppSheet.
One of the amazing things about AppSheet--
it has a very rich developer community
available at community.appsheet.com,
very supportive.
And this is a great first resource
to visit when you're learning about AppSheet
and no-code in general.
There's a link here to also try out
dynamic mail, which is spoken about in the actual developer
forums.
You can also start your first app with one click
at appsheet.com/templates from an existing app template.
And then finally, linked below is a video
that is a great first step for learning about building
no-code apps with AppSheet.
OK, everyone.
That wraps up our talk here today.
I'm Mike Procopio on behalf of the entire AppSheet team.
And it's been my great pleasure to speak with you today
about how AppSheet integrates with Google Workspace.
Have a great rest of your time at Google Cloud Next.