PALLAVI NARESH: Good afternoon,
everyone.
My name is Pallavi Naresh.
And I'm a product manager
at Google.
I'm joined here by my
colleagues, David Butcher and
Johnie Lee, software engineers
at Google.
Now, how many of you guys were
able to attend the last
session where we introduced
the Wallet Objects API?
Great, a good number of you.
Today, we're going to be talking
about redefining
loyalty for the mobile age using
the Wallet Objects API.
The Wallet Objects API is an
extensible platform that lets
you take anything from your
real world wallet--
loyalty, offers, and more--
and put it in your Google
Wallet in the cloud.
Now today, we're going to
be focused on loyalty.
Why?
Because when we talk to our
users and we talk to them
about digitizing the real world
wallet, the thing they
are most excited about are the
implications for all the
loyalty cards they
carry around or
forget to carry around.
We're going to start with an
overview of the problems that
exist with loyalty and how
we at Google can help.
Now, if you're not developing
for a loyalty program, stick
around, because we're going to
give you an overview of the
Wallet Objects platform and
walk you through a live
integration with our featured
partner, Marriott Rewards.
This will give you a good
overview of what it takes to
use the Wallet Objects API, both
for loyalty as well as
other use cases.
So what are the problems that
exist with loyalty?
Well, first, we have
too many cards.
We can't carry them all
around with us.
And often, we forget them when
we need them the most.
On the flip side, when we want
to sign up for a new
program, it's hard.
There are long forms to fill
out by hand at the worst
possible time.
Picture this.
You've just taken
a long flight.
You show up at your hotel.
You're not a member of the
loyalty program, but you want
to get points for your stay.
You also want to get to bed.
This is the worst time to
fill out more paperwork.
And finally, it's hard to keep
track of all the benefits
we're accruing across all the
programs we're members of.
Over 16 billion points go unused
in the US every year.
That's a lot of money.
So how can we at Google help?
And how can you help if
you're developing
for a loyalty program?
Your program in Google Wallet,
a single place for consumers
to track all of their loyalty
cards, geo-triggered around
your business so that your
customers never have to forget
their card at home again.
Instant enrollment--
acquire new customers instantly
from the phone, also
geo-triggered so the sign up
screen is waiting for them as
they walk through your doors.
And deeper engagement with your
existing customers and
your new customers.
Point updates, account
updates in real time.
Details on when your loyalty
rewards are going to expire.
So your customers never have to
worry about letting those
points go unused.
And personalized messages
delivered right on the phone.
The best part about all this
is that it's an easy
integration into your existing
loyalty systems.
I hope you're as excited about
the platform as we are.
I'm going to give it over to
David to walk you through a
technical overview.
DAVID BUTCHER: Thanks,
Pallavi.
So this platform API is in the
form of a REST service.
So it's resource oriented.
So I'm going to spend a little
time on the two main
resources, the first of which
is the Wallet Object class.
The second is the instance or
the object, and we'll get that
in the subsequent slide.
The idea here is that it's
REST via JSON over HTTP.
We see in front of us some JSON
for a particular class.
The Wallet Object class is
defining the shared data for a
single program which is going
to have many cards in it.
The Wallet Object class is
defining some of the shared
data like, for example, here
we see the issuer name, the
program name, Marriott Rewards,
the rewards tier.
There presumably would be a
class per rewards tier so that
there could be a little bit
different look and feel for
the different tiers.
And it also maps to the specific
look and feel that's
going to show up
on the device.
It's important to note that this
is a polymorphic object.
The class of the proper is in
the type, Wallet Object class,
loyalty class.
This is a loyalty class.
That specifies that there's a
particular schema behind this,
and there would be fields that
are specific to that schema.
Other schemas exist.
They're schemas for loyalty
here, for offers, mentioned in
the previous session.
We're going to be doing things
like boarding passes and some
other stuff.
And there will also be a generic
class that has no
pre-defined schema that allows
you to define your own.
The Wallet Object is an instance
of this class.
So for each program, there will
be actual cards showing
up on devices or
within Wallets.
And that corresponds to
the Wallet Object.
This is also polymorphic.
You'll see here that
it's using the
same type as the class.
It also has specific information
for this end user,
for example, the number of
loyalty points that have been
awarded to this user.
OK, the relationship--
if this wasn't completely
clear-- between the object and
the class is that for each
class there's a bunch of
objects and for each object
there's a single class.
This will become important later
when we think about how
we do updates.
This is your data.
You can update this data
anytime you like.
If you do an update to the class
information, it gets
broadcast to all of the devices
that are holding an
instance in that class.
You could also, as
we'll see later,
directly update the object.
So you as the issuer
own this data.
You can create it and update
it as you please.
There are very few rules
on when you do this.
You can push these updates
as you like.
Did I screw up?
Right.
Where am I?
OK.
There are a few different
ways of getting
instances into the Wallet.
The Save to Wallet from the
browser allows any website to
include some JavaScript to
enable Save to Wallet.
What happens here is the end
user visits the site and
clicks on the Save to Wallet
button, and we arrange for
that to be put onto the
device or devices.
This is a pretty important point
is that things get into
the user's Wallet, the
customer's wallet, because
they put them there.
This is a very strong signal
of interest here.
In addition-- and this is a
loyalty specific thing.
Most of the things that I'm
talking about are pretty much
general to Wallet Objects
across the board.
But there are some specific ways
to get new instances of
loyalty into the Wallet--
specifically, sign
up and link.
Sign up is for people who are
new to your program, and they
want to participate.
And link is when they have an
existing physical artifact and
they want to get it into
their virtual Wallet.
And we'll see these in detail
in the demo when
Johnie covers that.
So of course, this is Google.
When you push an update, either
to an instance or a
class, we will reliably deliver
that update at scale,
even if that class may have
thousands of instances
associated with it distributed
geographically.
We'll make sure that
gets delivered.
This is an important point to
note, is that when we get
stuff onto the phone, it's
cached there, and it can be
used online and offline.
In addition, we can leverage
Google's geo-indexing to get
really intelligent, here
and now surfacing.
So the idea here is that you
walk into, let's say, a
Marriott, and we can determine
that you have, in fact, a
loyalty card relevant here.
We can bring it up and show you
that there is and go ahead
and use it.
Or we could surface that you
can sign up for such a card
right here and now.
Hence the name.
And now that I've given that
over to you, I'd like to turn
it over to Jonie to demonstrate
some of that stuff.
JOHNIE LEE: Thank you.
Thanks, David.
Hi, I'm Johnie Lee, and I'm
here to talk to you today
about merchant integration with
the Wallet Objects API.
If you were at the earlier
session, you would have gotten
a quick peek of the sign up
functionality for a Marriott
Rewards program within
a Google Wallet.
Marriott Rewards is one of our
featured partners with over 42
million loyalty members.
We have been working with
Marriott Rewards in building a
solution that complements their
existing mobile strategy.
During this part of the session,
I will decompose the
sign up and linking
functionality of the earlier
demo, and just to give you an
idea of what it takes to
integrate with our Wallet
Objects API.
Keep in mind, though, that this
is a demo, and that when
we launch the consumer
experience, the Marriott
screens may differ.
The three parts of integration
that I will focus on today is
the creating of a loyalty
Wallet Object.
This is, as David mentioned
earlier, the base object that
represents a loyalty program.
The second step is the setting
up of the signed up and
linking call back service.
This allows the instant sign up
and linking directly from
the mobile phone.
And the third and final step is
the updating of the user's
loyalty information
from the cloud.
As David mentioned earlier, the
Wallet Object class is the
base representation for a
loyalty card, or a number of
loyalty cards.
What we have here is the Wallet
Object class that was
used for the Marriott demo.
In this we indicate the issuer
name and program name as
Marriott and Marriott Rewards.
And we specified the labels
that are used
for each of the fields.
In this case, the rewards tiers
are levels, and the
account IDs are member IDs.
So let's go ahead and try
inserting a loyalty Wallet
Object class.
So what we have here is the same
exact Wallet Object class
that I showed earlier.
This is the JSON representation
of the Marriott
Rewards loyalty card.
And in here, as I pointed out
earlier, we have the issuer
name, the program name, as well
as additional information
such as the logo that will be
used to render the loyalty
card and also the template
that will be
used for the rendering.
So as David mentioned earlier,
this is a REST based service.
And to insert a class, it's as
easy as calling the Wallet
Object class endpoint with
this as the payload.
Sorry.
Right there.
And let's give that a try.
So voila.
We've inserted a brand new
Wallet Object class in the
Google Wallet cloud.
At this point, you should be
able to use this Wallet Object
class for save to Wallet as well
as sign up and linking.
Instant sign up and linking
allows your users to sign up
for a brand new loyalty card for
your program directly from
the mobile phone or link their
existing loyalty card with
your loyalty program
to Google Wallet.
This is all done through the
phone using Google Wallet.
How this works is that a request
is sent from the
client phone to the Google
Wallet cloud to the merchant
callback service.
And the merchant callback
service responds with an
approved or rejected state.
So what we're looking at
here is an example
of a sign up request.
The primary thing to focus on
in here is the Wallet user
profile in the middle of
the sign up request.
One of the benefits of instant
sign up is that we use the
information that is in the
user's Wallet profile to
pre-populate the forms that are
used to sign up for your
loyalty program.
The merchant will need to
pre-select a number of fields
that they would like, which
includes first name, last
name, email, phone
number, maybe zip
code, a number of options.
The information is sent to the
merchant with the user's
explicit permission.
So once the merchant has
received their request and
processed the request, the
merchant is expected to send
back an either improved
response
or a failure response.
This is an example of a
successful response.
In this, the three main fields
to focus on are the sign up
result-- in this case,
it's approved--
the welcome message, and
the Wallet Object.
The welcome message is what is
shown to the user when they've
successfully signed up for the
program welcoming them to be
your loyalty program.
The Wallet Object is the
representation of the loyalty
account within Google Wallet.
In the Wallet Object, it
contains information such as
the number of loyalty points,
the status, and account name.
For a failure response, this is
a typical failure response.
We have a sign up result, which
is in this case was
rejected, and the message
indicating why it was rejected.
So let's go through and
take a look at an
example callback service.
So what we have here is a
Python based App Engine
service that was used to run the
Marriott Rewards demo from
earlier today.
Since we cannot actually hook
up to the Marriott loyalty
back end, I've subbed out the
system by creating this data
access layer which supported
creating a new loyalty account
from the user profile and
looking up an existing loyalty
account using the account ID.
And I pre-populate the values
for the account with a random
number of points.
The request handler
here handles two
types of post requests--
sign up and linking.
For sign up, the three steps
that I go through is first, I
create a new loyalty account
in my back end.
Then I take that loyalty account
and convert it from my
domain specific loyalty account
to a Wallet Object.
As you can see in here, I do
a direct mapping from the
account name to the account
name field in the Wallet
Object, account ID
respectively.
In addition to that, I do
additional customization to
further brand this loyalty
card for the
Marriott Rewards program.
Once I've done that, I add the
additional welcome message and
the sign up result, as you can
see here, and wrap that in the
JSON RPC 2.0 envelope.
So we can actually go ahead
and give this a try.
What I'm going to do is I'm
going to send this fake
request here with the Wallet
user, John Smith and the phone
number there, to an App Engine
server that is run locally.
So here's the request that we're
sending, and the App
Engine server responded
correctly with the Wallet
Object instance and response.
So this is fine and all.
But why don't we look at the
in the real production
environment on the phone?
So here--
focus.
Good.
So here, I have the Google
Wallet application that we are
using for testing.
And again, this is for demo
purposes, and the actual
consumer experience
may differ.
And what we do is we go in
here, find the Marriott
Rewards program, and it should
load up the additional
information about the
Marriott Rewards.
This was similar to the demo
that you saw earlier.
Then we click on Join Now.
And as you can see, it
pre-populates the form with
the name of the user on this
phone, on this account.
I agree to the terms,
and I would like to
get additional emails.
And then I create an account.
And there you go.
We have a brand new loyalty card
instantly inserted into
our Google Wallet application.
So let's take a look at
the back end server
that ran this instance.
Right here, we have the logs
for the App Engine server.
And as you can see
here, this is the
request that was received.
And this was the response
that was returned back.
And really, that's
all there is to
creating a callback service.
Obviously, when you integrate
this with your loyalty back
end, there's additional business
logics that you may
use to create provision
a new account or
link an existing account.
So your once your consumers
have linked their loyalty
account with your loyalty
program to Google Wallet, this
is where the fun part
really comes in.
This is the part that you can
really engage your consumers
by updating their information
regularly or sending them
messages directly to
their mobile phone.
To updatable a loyalty account,
as David mentioned
earlier, we send this
REST resource to
the resource endpoint.
This is a Wallet
Object payload.
And in here, we update
the number of
points to 2000 points.
And you can also update any of
the other fields as necessary.
We then send this as
a part request to
the resource endpoint.
Likewise, for messages, we
send the message payload
either to a Wallet Object
endpoint or to a Wallet Object
class endpoint.
The difference being that a
message sent to Wallet Object
goes to one specific user, and
a message sent to a Wallet
Object class goes to
a group of users.
So why don't we give
this a try here?
All right.
So last night, I stayed at the
Marriott Marquis, like many
people here.
And I've earned an additional
2,500 points for staying at
the Marriott Marquis.
So what I would like to do is
then update the number of
points for this loyalty account
to reflect my new
points status.
What I've done is I've taken
the Wallet Object
that we just created.
We update the version
number to indicate
that it's an update.
And then we update the number
of points to 2,500.
At this point, we find the ID
that was created, that we
created and send that payload
to that resources endpoint.
And then there you go.
The number of points
has updated.
And then if we go back to the
phone itself and hit refresh,
we can see that the number
of points is now 2,500.
[APPLAUSE]
JOHNIE LEE: There you go--
2,500.
So what I've shown you here
is the ability to easily
integrate with the Wallet
Object back end.
And to go back to a story that
Pallavi told earlier.
Imagine now you walk into
the lobby of a hotel.
You have your Google
Wallet on you.
You realize that you
don't have a
membership with that hotel.
You find that program in your
Google Wallet, sign up
instantly, and by the time you
check in, your loyalty account
is updated to the most recent
point transaction.
Now, that is a great
user experience.
I will turn it back to
Pallavi for wrap up.
PALLAVI NARESH: Great.
Thanks, Johnie.
Let's see.
How do I switch this back?
We hope that you'll walk away
from this session with a good
understanding on how to use
the Wallet Objects API to
acquire new customers
and engage
your existing customers.
The best part about this is that
it's a single simple API
for loyalty offers and more.
We're already working with some
great partners, including
several folks who are powering
some of the world's largest
loyalty programs.
If you're interested in signing
up, visit the website
listed here on this slide.
And we're providing access
in the coming days.
We're also available
outside for office
hours in our sandbox.
You can also check out some live
integrations there to see
this all in action.
With that, I want to open the
floor up for questions.
Any questions?
Feel free to come up to
the mic in the middle.
DAVID BUTCHER: Shy crowd.
Here's one.
AUDIENCE: Hi.
Are there any plans to make
the developer version of
Google Wallet that you guys
are using available to
developers along
with the APIs?
PALLAVI NARESH: For now, we are
working with partners to
provide tools that allow you to
preview your Wallet Objects.
And then we are working to
quickly launch the consumer
experience so that you
can use that in
your development process.
AUDIENCE: OK, thank you.
AUDIENCE: In the app, how much
room do you have to customize
how your Wallet Object looks?
And are there plans to
change things if
they're not that flexible?
PALLAVI NARESH: So we actually
allow several degrees of
freedom in customization so that
you can really showcase
your brand.
For specific details, you
can check out the
documentation on the API.
But in general, it's quite
flexible in terms of the
layout you can choose, the
colors, the logos, as well as
the information that you
show in your card.
Great.
AUDIENCE: So the consumer of
your services really seems to
be aimed at businesses--
creating loyalty cards that
reflect what they offer in the
physical world.
But like we saw with Apple's
Passbook, there was an
opportunity for companies that
wanted to support small
businesses that don't have
formal loyalty programs to
sort of consolidate and
act as a broker.
Is there a similar
opportunity here?
Or do you think that the main
consumer is going to be
partners who create
loyalty programs
for their own business?
PALLAVI NARESH: We're actually
already partnering with
BellyCard that is doing exactly
what you describe.
So you can also use the Wallet
Objects API to--
AUDIENCE: Represent other--
PALLAVI NARESH: To
represent others.
That's right.
AUDIENCE: OK.
That was the question.
Thanks.
PALLAVI NARESH: More
questions?
Great.
Well then, with that, we'll wrap
up and hope to see you
guys all in our sandbox
outside.
DAVID BUTCHER: Thank you.
JOHNIE LEE: Thank you.
