How to pass the Google Cloud Professional Cloud Architect certification – as a sales guy

Within sales, summer is a time with low customer interaction and allows you to focus on additional activities. Given this background, I decided 6 weeks ago to go for the Google Cloud Professional Cloud Architect certification. I do not really have backend IT experience and never programmed anything myself, so the primary goal was to upskill and become a more knowledgeable counterpart for my customers. Passing the certification was only an aspiration that kept me studying along the way, not an objective in itself that I had to achieve in order to label the whole experience as successful. Having said this, I am surprised that I actually managed to pass the exam, and would like to share with you how one can study and pass the exam.

All of what follows is my personal opinion and should not be considered as official Google advice in any way.

1) Getting started with Coursera: 6 courses, 50 hours of effort

I started by scanning the Exam Prep course, ignoring Qwiklabs. This only took a few hours and gave me a good feeling of the kind of questions in the exam, the focus of the case studies, the depth of technical details required, and where I would need to put my particular attention to in the following weeks. I did the practice exam (25 questions) and scored around 50%. I had heard that 80% was needed to pass the CPA exam, and the snapshot of having answered half of the questions correctly encouraged me that it was doable, albeit a challenge. As I learnt later, however, the Coursera questions are a lot easier than the questions on the exam.

The first course I studied was Google Cloud Platform Fundamentals: Core Infrastructure. It was a good overview of GCP in general and covered more or less what a sales role would have had to study when joining Google anyway. So not a lot of new information here, but definitely a good refresher. Nicely summarized, with good Qwiklabs tutorials. Being the first of five Coursera courses, the practical exercises could have had less focus on Cloud Shell – for my taste, it was a lot of copy & paste, whereas spending more time on the GCP UI could have had a better learning effect –, but helped to not only be less afraid to make one's hands dirty, but on the contrary having fun doing so. Overall effort was somewhere between 10 and 15 hours. 

Next was Essential Cloud Infrastructure: Foundation, which focused on Virtual Networks and Virtual Machines, particularly on Compute Engine (GCE). The first part on VPCs was quite challenging, whereas the second part on VMs (with the exception of images and disks) was easy, since a lot of information had already been provided in the previous Core Infrastructure course. The overall effort of this course was around 5-7 hours, and could easily be done in one day.

The Essential Cloud Infrastructure: Core Services centered on IAM, Storage and Resource Management & Monitoring. The lab on IAM was really painful, more than one hour of pure copy & paste and way too detailed for a non-techie. The rest of the course was very intuitive and easy, especially the second part that centered on Resource Management, Monitoring and Stackdriver functionality. Effort was somewhere between 5 and 7 hours as well.

The course Elastic Cloud Infrastructure: Scaling and Automation was quite insightful, providing frameworks to choose the right networking (VPN, interconnects, peering) and load balancers (HTTPS, TCP Proxy, SSL Proxy, Network and Internal). On the negative side, a few labs were difficult to pass if a typo was overseen in Terraform, and Qwiklabs support was not of any help. The Deployment Manager section felt fully redundant to what was learnt before. Overall effort was between 7 and 10 hours, due to the fact that some labs needed to be done multiple times to actually pass.

Reliable Google Cloud Infrastructure: Design and Process is the last Coursera course. The microservices part was new and challenging. Storage, reliability planning and app deployment were almost a full recap of the basics that were taught in previous learning modules. Hybrid infrastructure, load balancing, connecting networks even were full recaps. So all of this did not feel very rewarding. At least for storage and app deployment, the lessons came with a few good frameworks when to choose which solutions, something that I had missed previously. The lab on app deployment also showed quite well when and how to use App Engine, Kubernetes Engine and Cloud Run. If you are fed up of Coursera and are thinking of skipping a course, this might be the one. I would, however, recommend you to have a look at the ClickTravel workbook, which transferred the knowledge to an imaginary case study. The PDF with its solutions can be downloaded. Overall effort of the course was 7 to 10 hours.

Some colleagues also recommended the additional Qwiklabs quest courses Cloud Architecture: Design, Implement, and Manage and Cloud Architecture. Given that the labs in the Coursera courses had already given me a good understanding of the GCP console, and deeper looks into Cloud Shell or Terraform felt of limited use to me personally, I decided to skip those two practical courses. I also decided against purchasing the Wiley book, which has a lot of negative feedback on Amazon, and also opted against additional videos on Linux Academy, which apparently seems to more in-depth material than Coursera.

2) Knowing where you stand: 50h of effort

Before I really started to study in-depth, I needed a second snapshot of where I stood. I did the practice exam on cloud.google.com/certification and scored 11 out of 17 without having read the case studies the questions had referred to. Overall a decent result, but I had guessed quite a lot, so this was not the right foundation to become overconfident. But a nice encouragement to go ahead and get this done. I then revisited the Exam Prep Coursera course, and once more did the Coursera practice exam. This time, I scored 65%, up from 50% two weeks earlier. I then reserved the exam voucher and scheduled the exam 4 weeks down the road. There was no way back from here. I also shared the news with some of my colleagues with the idea of making myself accountable to study each and every day.

Next, I spent 20 euros on the Whizlabs practice exams (250 questions) and signed up for the Linux Academy practice exams (roughly 100 questions). For the latter, one only has to pay after a 7-day trial. The great thing about learning from these questions is that you not only understand your weaknesses, but also are provided right away with the correct answers and the GCP documentation links where one could learn more. Given that the official GCP documentation feels ultra-extensive and endless, the exam prep questions gave me a good indication where to spend my time. They are also a good practice to get the TerramEarth, Mountkirk Games and Dress4Win case study details hammered into your brain.

With respect to the case studies, the Learn GCP with Mahesh YouTube videos felt also like a worthwhile investment. Just make sure to reflect the case study responses yourself, given that there is no officially correct, Google-approved answer template, and opinions deviate a lot. With Mountkirk Games, for example, Linux Academy mentions Cloud Spanner and Bigtable as the preferred backend solutions, whereas Coursera and Mahesh are in favor of Firestore/Datastore and BigQuery. That’s quite a substantial difference in architecture! Interestingly, this exact question showed up in my final exam, and I do not know the answer until today ;-)

In case you look for reference points, I scored in all Whizlabs and Linux Academy exams somewhere between 45% and 70%, so nowhere near the passing threshold of the real exam. All of this took around 50 hours of studying, within roughly 3 weeks.

3) Fill your knowledge gaps: 30h of effort

With ten days to go, I made myself a plan to dedicate 2-3 hours per day to the topics I felt I knew the least about. In my case, this was networking, gcloud commands, connecting securely to VMs, backup strategies, general best practices, Kubernetes, error codes and their causes and solutions, as well as developer tools. Distinguishing all products easily is a must, so if you are confused by Firestore, Filestore, Datastore and Firebase, put this topic right on the top of your list. Do not get distracted by all the new announcements Google has made during Next ‘20. None of them appeared in the final exam (yet).

Those are the links I found the most helpful for my knowledge gaps:

• Priyanka Vergadia’s sketchnotes
• The following table is a good comparison of the hosting options. Particularly, I often mixed up GKE, Cloud Run, App Engine Flexible and App Engine Standard: https://cloud.google.com/hosting-options#comparing_options
• Decision Trees and Flowcharts Overview: https://grumpygrace.dev/posts/gcp-flowcharts/#compute
• 13 popular architectures with GCP: https://cloud.google.com/blog/products/application-development/13-popular-application-architectures-for-google-cloud
• Connecting securely to VMs (this was not covered in any course): https://cloud.google.com/solutions/connecting-securely
• GCP command line cheat sheets: https://medium.com/@tams67680/google-cloud-platform-command-line-cheat-sheet-ae3fe5fde436 and https://cloud.google.com/sdk/docs/images/gcloud-cheat-sheet.pdf
• Error codes: https://cloud.google.com/apis/design/errors
• Kubernetes Best Practice: https://cloud.google.com/kubernetes-engine/docs/best-practices
• Storage Best Practice: https://cloud.google.com/storage/docs/best-practices

4) Stay calm in the exam

I had a lot of technical problems with Kryterion, and their support was not particularly helpful. Overall 5 different agents tackled my firewall issues, and I had to start explaining the situation again and again. If you are able to do the exam on-site, I’d definitely recommend this option.

In terms of the content: Around 10 of the 50 questions directly referred to GCP Best Practices, so this really is something you need to study well. Around 10 questions addressed Mountkirk, TerramEarth and Dress4Win, with at least half of them being Mountkirk. I was surprised that only 3-4 questions included command lines as potential answers, so the exam was less developer-focused than I had expected.

In general one had to very carefully read both questions and answers, but it did not feel unfair. The questions were easier to grasp than the ones in Linux Academy and Whizlabs, although not easier in difficulty. A decisive difference to the practice exam is that 49 out of 50 questions only had one correct out of only four potential answers. Eliminating half of the options left you often with a pretty decent 50/50 choice, which presumably help me over the finish line.

Any questions, feel free to reach out. Good luck!