I’ve been working with Google Calendar for years – as an end customer and as an integrator. During this time, I’ve had the same interactions with other calendars, like Microsoft Outlook, which gave an excellent opportunity for comparison.
As an end customer interacting with Google calendar, I take note of the UI, what tuneables I have available to optimize interactions with my appointments, and in general how much I notice the calendar tool itself as part of my day-to-day work life. Ideally, an app like this all but disappears and becomes a nature part of what I do. In all too many ways, Google calendar has consistently failed in this respect.
I have a more unique viewpoint in that I’m also an integrator into Google calendar. I make use of programmatic APIs to get information from and automatically change settings within calendar events. For almost 10 years I’ve built and maintained a number of these integrations, the most recent of which is Calenzen. If you’re unfamiliar, Calenzen fixes the meeting invitations you receive so you can always dial-in to the conference calls you’re invited to.
The final piece I bring to this analysis is my deep experience across multiple products in this same space, most notably a lifetime integrating into Microsoft Exchange and Office 365.
This is the first in a series of posts that go into more detail on the issues I’ve cataloged and fought with – often unsuccessfully.
General Rules of the Road
As technology consumers, we all have a set of expected behaviors. All Apple iPhone apps should share some common interface elements – that’s why Apple publishes their Human Interface Guidelines as does Google for their Material Design Guidelines.
That’s how we – generally – know how to interact with new software immediately upon installing it.
When guidelines aren’t followed, we’re faced with new patterns. That’s when the software adds friction, we get frustrated, and there’s a better chance of getting unexpected results. As a consumer I expect:
- Full visibility into my events and data – nothing I might find important should be hidden
- Consistent behavior no matter where I use the software – desktop, mobile web, and mobile app
- Connect the dots with information the service knows to make my life easier
Integrators should start with a different set of expectations that consumers. Clearly, more domain-specific knowledge is required. Without it, we cannot hope to understand the primitives we need to actually get our job done:
- The data model
- Process flows
The above are always documented to at least some degree, but there are always gaps. Where documentation does not exist or is otherwise incorrect, friction and risk of bugs enter into the picture. Therefore, as an integrator I expect:
- The above documents to actually exist
- Examples that follow through common tasks and ideally complete process flows
- Visibility into behavior such as logs and verbose error messages
- Easy manual testing and API calls
Now for the List
What follows is my list of grievances. I don’t see any of these as customer or integrator specific design decisions, but rather the rough edges on (what I hope is) an evolving product.
#10 – Event Control
Tag as: consumer, anti-pattern
When someone invites me to a meeting I expect it to show up on my calendar, full stop. There should be no exceptions to this. Not matter who sent the invitation, what app they used, or what vendor hosts their calendar server.
I see appointments in my inbox every day that behave differently, and as a consumer I just don’t get why. Consider these two examples:
As someone who’s spent years working with calendars, ics files, etc. I gather the behavior is due to the right combination of a forwarded invitation. So I worked to duplicate this behavior.
- Forwarding invitations between by Google accounts always returns the “normal” view with Yes/No/Maybe
- When I send an invitation from a non-Google calendar into Google I still get the “normal” view
- Forwarding an invitation from a non-Google calendar to a a new recipient generates the neutered view
As a consumer I expect Google to provide more details on why the behavior changes. Is it because I’m not on the original invitation list and the non-Google meeting doesn’t have the “allow others to be invited” flag set? Will Google send a response to the host? Will I be notified if the meeting itself changes and there’s an update?
#9 – Free/Busy
Tag as: consumer, friction
Publishing free/busy views is an amazing advancement for corporate calendars. We take it for granted that within a large organization we get instant visibility (to some degree) into our peers availability so we can schedule time to meet. This is such an expected behavior that when it doesn’t exist – for example when scheduling meetings with people from other organizations – we’re faced with immense friction trying to get something scheduled (See my other service Appointment.one that solves this problem).
Google Calendar, along with every other major vendor, uses a variety of colors and patterns to overlay availability for a group of people on a grid like the one above. It includes two data points:
- Free, indicated when the grid shows an empty space
- Tentative/Maybe, using a cross-hatch pattern
- Accepted/Busy, using a solid color
Unfortunately, I’d like more visibility into those days where orange has blocked off huge blocks. The appointment details are understandably kept private, but ask yourself – just how “busy” are they really?
Microsoft Exchange solves this by adding a forth type of availability – out of office. There’s a world of difference in information between those two, yet sharing “busy” vs. “out of office” isn’t something most people feel the need to keep private.
Update: With Google’s 2019 Calendar update they have finally added this information, see the screenshot below! Odd that the Calendar team thought it best to add a new type of differentiated element and add a small icon rather than continue with the pattern strategy already in use.
#8 – Right-Click!
Tag as: consumer, anti-pattern
Google Calendar designers really aren’t into enabling right-click functionality. This isn’t the case across the rest of Google’s apps – Gmail supports this as does the entire docs, sheets, presentations suite. It is such a powerful enabler that brings web-based applications on-par with traditional client-based applications.
Prior to Google Calendar’s major 2019 update the entire UI was very dated and weak. Missing this functionality was no surprise. However, when it is largely missing with their recent update this became a thorn in my side.
Think of all the places a right-click context sensitive menu would be useful – whether in the main calendar grid view or within appointments. Despite the possibilities there is one and only one location where the context-sensitive right-click is available.
Right-click on an existing appointment within the calendar grid and you’ll get the simple menu below. That’s it.
#7 – Meeting Forward Notifications
Tag as: consumer
Microsoft Exchange introduced meeting forward notifications over 10 years ago. Initially it was quite surprising and disruptive. What had once been more of a backchannel, was now out in the open.
Many organizations disabled this initially, but over the years the preponderance of Exchange and Office 365 administrators have ultimately reversed this decision.
When an attendee forwards the meeting invitation to another participant, two important things happen:
- The meeting host receives a message in their inbox indicating who the additional attendees are. This is often very helpful for hosts as the makeup of meeting participants changes the entire tenor of the discussion (consider when a suite of executives is suddenly a part of a working call).
- The Exchange server adds the new attendees to the official invite list and updates them when the host makes changes to the meeting.
Google does not perform either these notifications nor updating the invite list. There is one exception – if an authorized attendee adds more participants directly from the native Google web UI.
Were Google to open their walled garden a bit there’s some excellent opportunity for:
- Getting us around the weird “event control” issues I brought up earlier. Newly added attendees would get meeting updates rather than being left out in the cold.
- Keeping hosts informed of updated participants.
Fun fact – if an uninvited participant sends a meeting response (e.g. “Accept”) then Google will just throw this away, rather than keeping track of the newly discovered metadata about the meeting.
#6 – Mining Meeting Responses
Tag as: consumer, integrator
Meeting responses contain a ton of awesome metadata that hosts can take advantage of. Consider the following:
- Attendees names and contact info
- Responses (Accept / Tentative / Decline)
- Response timestamp
Google throws away the following information while Microsoft tracks it with the event:
- Responses from unexpected attendees (e.g. participants who received a forwarded invitation)
- Response timestamp
Consider this screenshot as an example of what’s possible when you retain this information:
#5 – Meeting Attachments
Tag as: consumer
Meeting attachments weren’t possible prior to Google Calendar’s 2019 refresh, although Microsoft Exchange has always offered widespread support. One of the most powerful features within the Outlook / Exchange world is the ability to treat content the same regardless of whether it was an email or a calendar object.
Google added support for attachments with their recent refresh, but they implemented a very backwards pattern in delivering it. Whereas Microsoft embedded the content directly in the event, Google transparently consumes your attachment and makes it available via the Drive app.
Multiple meeting participants can now access attachments associated with events if they are part of the same Google domain. However, this all breaks once you invite a participant from off the Google platform – they get a link to a drive share without proper permissions to access it.
While this may have been implemented for security reasons (preventing data from leaking outside trusted groups), the resulting behavior adds nothing but friction to actual users.
#4 – Inconsistent HTML Tags
Tag as: integrator
Most of my integrations take advantage of styling to make content stand out as much as possible.
Consider your typical Junk email folder for a moment. While none of us look forward to an mailbox full of highly styled marketing emails, you must admit that styling in transactional emails helps you quickly identify the products you purchased, ship date, etc.
The same is true with calendar invitations. True, most of us are a bit lazy and we all too often eliminate an agenda. However, when you do make use of it, proper formatting lets you better emphasize different parts of your message for maximum impact.
Prior to Google Calendar’s 2019 update there existed a very strange universe inside each of your calendar events. While the web UI did not permit any text styling, Google did accept styling from the API integrations made outside of the web UI. The problem of course came if you ever opened one of these beautifully styled appointments from your Google Calendar web browser. Rather than seeing WYSIWYG editing, Google would spit hundreds of lines of raw html at you. This was such atrocious behavior, I spent 15 minutes trying to find an example screenshot but came up empty handed.
Fortunately Google calendar now includes a formatting editor in their web UI and it allows for styling. The problem you run into as an integrator is that Google silently rewrites and drops standard html tags. “spans” turn into “divs”, “a href” links can disappear altogether.
Google should publish their exact output for different input tag combinations so integrators don’t guess or worse yet write code that breaks with future Google Calendar releases.
#3 – No CSS Support
Tag as: integrator
Hot on the heals of the html tag support is support for CSS styling in invitations. Basic formatting is enabled, but only a very limited list. This breaks the illusion that any document type – such as an email or a calendar event – are largely interchangeable from a content perspective.
I’ve made some beautiful styling with the Appointment.one integration that took advantage of this. While it is fully supported with Office 365, and even partially supported in the old Google Calendar app (see screenshot below), all of this content is silently stripped from invitations received by Google.
One of the worst things about this, and the HTML issue above, is that Google is a hypocrite! While they don’t allow you to take advantage of this content, how do you think they style the meeting invitations they send to other providers?
#2 – Line Breaks in Invitations
Tag as: integrator
Similar to (4) above, Google Calendar does some weird things based on how they “think” you’ve encoded the text in your event invitation. They show inconsistent behavior with changing content within an invitation such as newlines vs “br”, or blocks elements like “div”.
The rule I’ve found is that if Google sees a single piece of html in your event, they will strip 100% of all “newline” line breaks within your content.
This makes rendering in mobile clients very challenging. First, as of the time of this writing many mobile clients still believe Google Calendar events are plaintext only (looking at you Apple Calendar on iPhone!). So when you combine Google silently making changes with using different calendar apps to render you get inconsistent results.
It’s almost as though Google doesn’t want you to format anything!
#1 – Different Appointment Rendering Web vs. Mobile App
Tag as: integrator
All of these formatting issues come to a head with client rendering on mobile. Google Calendar appointments are delivered differently to these apps that they are presented via the Web UI, which means every client is starting from a slightly different point.
Add onto this nuances each of these clients introduces to make rendering consistency a bear. I understand differences between Microsoft and Apple written clients, but event the Google Android vs. iPhone Calendar apps behave differently from each other!
At Calenzen, I’ve solved this problem by extensively testing every permutation of html/css within each phone platform (Apple vs. Android) and each app (Apple Calendar, Microsoft Outlook, Google Calendar). This support matrix actually powers what Calenzen updates within your events.
With these rules, Calenzen makes sure that the pertinent data is instantly visible, that phone numbers are always click-to-dial (and believe me, that was really hard when you add in all the teleconference attendee codes and pauses), and that extra formatting is used to your benefit if it is supported.