I Knew Almost Nothing About GCP. Here's How I Passed the Professional Cloud Developer

Three months ago, my total GCP experience was spinning up one Compute Engine VM and immediately forgetting to shut it down. $47 later, I decided maybe I should actually learn this stuff properly.

Fast forward to last week: I passed the Google Cloud Professional Cloud Developer exam. Not by a landslide — the email just said "Pass" without a score, which is Google's way of keeping you humble. But a pass is a pass.

Here's my honest account of what worked, what didn't, and what I'd change if I did it again.

What Exactly Is the GCP Professional Cloud Developer?

The PCD is Google's certification for people who build applications on GCP. Not design them (that's the Professional Cloud Architect), not manage the infrastructure (that's closer to the ACE) — build them. Deploy them. Debug them. Scale them.

Google recommends 3+ years of industry experience including 1+ year designing and managing GCP solutions. I had roughly 3 months of panicked self-study. So take their recommendation with a grain of salt.

Exam Quick Facts

The 5 Domains You Need to Know

Google breaks the PCD into these sections. The percentages aren't published, but based on my exam experience, here's my rough estimate of weight.

1. Designing Highly Scalable Applications (~25%)

This is about application architecture patterns on GCP. Twelve-factor app methodology, microservices vs monoliths, event-driven architectures. You need to know when Pub/Sub makes sense versus Cloud Tasks, and why you'd choose Firestore over Cloud SQL for certain workloads.

Key services: Cloud Run, GKE, App Engine, Cloud Functions, Pub/Sub, Cloud Tasks

2. Building and Testing Applications (~20%)

CI/CD pipelines with Cloud Build. Container image management with Artifact Registry. Testing strategies — unit, integration, end-to-end. How to use Cloud Source Repositories (though honestly, most people just use GitHub).

The questions here are surprisingly practical. Things like "your build fails because the container image can't be pushed — what's the most likely issue?" (Usually IAM permissions on Artifact Registry.)

3. Deploying Applications (~20%)

Cloud Run vs App Engine vs GKE — when to use each and why. Traffic splitting for canary deployments. Blue-green deployment patterns. Rollback strategies.

One topic that surprised me: you need to understand GKE concepts like Pods, Deployments, Services, and Ingress even if you're not a Kubernetes expert. Not deep kubectl wizardry, but enough to read a YAML manifest and understand what it does.

4. Integrating Google Cloud Services (~20%)

This is the breadth section. Cloud Storage, BigQuery, Spanner, Memorystore, Secret Manager, Cloud KMS. You don't need deep expertise in each, but you need to know which to pick for which problem.

My biggest struggle was the data services. When do you use Firestore vs Bigtable vs Spanner vs Cloud SQL? The answer depends on data model, scale, consistency requirements, and cost. There's no simple cheat sheet.

5. Managing Application Performance (~15%)

Cloud Monitoring, Cloud Logging, Error Reporting, Cloud Trace, Cloud Profiler. You need to know which tool answers which question: "Where is my latency?" (Trace), "What errors are happening?" (Error Reporting), "Is my service healthy?" (Monitoring + uptime checks).

My 12-Week Study Plan

I studied about 10-12 hours per week. Here's the breakdown:

Weeks 1-3: Foundation Building

• Completed the GCP Fundamentals learning path on Google Cloud Skills Boost
• Set up a personal GCP project with billing alerts (learn from my $47 mistake)
• Deployed a simple web app on each: App Engine, Cloud Run, and a GKE cluster
• Got comfortable with gcloud CLI — this matters more than the console for the exam

Weeks 4-6: Core Development Services

• Deep dive into Cloud Run: deployment, revisions, traffic splitting, concurrency settings
• Cloud Functions (2nd gen): triggers, event-driven patterns, cold starts
• Pub/Sub: topics, subscriptions, dead-letter topics, exactly-once delivery
• Cloud Build: build configs, triggers, substitution variables, multi-step builds

Weeks 7-9: Data and Security

• Firestore: document model, queries, transactions, security rules
• Cloud SQL: connection patterns (Cloud SQL Proxy, private IP), high availability
• Cloud Spanner: when you absolutely need global consistency
• IAM: service accounts, workload identity, least privilege patterns
• Secret Manager and Cloud KMS: storing and managing secrets properly

Weeks 10-11: Operations and Observability

• Cloud Monitoring dashboards and alerting policies
• Structured logging with Cloud Logging
• Distributed tracing with Cloud Trace
• SLOs, SLIs, and error budgets — Google takes this seriously

Week 12: Practice Tests and Review

• Took practice tests on ExamCert's GCP PCD practice exam
• Reviewed every wrong answer and mapped it to documentation
• Did one final end-to-end lab: built and deployed a microservices app using Cloud Run, Pub/Sub, Firestore, and Cloud Build

What I'd Do Differently

Start with hands-on, not reading. I spent the first two weeks reading documentation and retained maybe 15% of it. The moment I started deploying things, everything clicked. GCP's free tier is generous enough for study purposes — use it.

Focus more on Cloud Run. Cloud Run is Google's darling right now and it shows on the exam. If I had to pick one service to know inside and out, it's this one. Know the deployment model, concurrency settings, scaling behavior, and how it handles traffic splits.

Don't ignore GKE basics. I almost did. "I'm not a Kubernetes person" isn't an excuse — you need to understand Deployments, Services, ConfigMaps, Secrets, and Ingress at a conceptual level.

Use the gcloud CLI more. Several questions asked about command-line operations. Things like gcloud run deploy flags or gcloud builds submit options. The console is nice for learning, but the CLI is what the exam tests.

Resources That Actually Helped

• Google Cloud Skills Boost: The structured labs are excellent. Worth the subscription
• ExamCert GCP PCD practice questions: Most realistic practice I found
• Google Cloud Documentation: Specifically the "How-to" guides, not the concept pages
• The official exam guide: Read it three times. Each time you'll notice things you missed
• GCP YouTube channel: The "What is..." series gives good high-level overviews

PCD vs PCA: Which Should You Take?

If you're wondering whether to take the Professional Cloud Architect or the Professional Cloud Developer, here's the simple version:

• PCA: You design systems. "We need a globally distributed database with strong consistency" → "Use Spanner, here's why." Architecture and business requirements.
• PCD: You build systems. "How do you deploy this microservice with zero downtime?" → "Cloud Run with traffic splitting, here's the config." Implementation and operations.

If you write code daily and deploy it: PCD. If you draw architecture diagrams and make technology decisions: PCA. Many people eventually get both, and honestly, there's about 30% overlap in the material.

GCP Developer Certification Salary Impact

Let's talk money, because that's probably why you're here.

Based on 2026 salary data from LinkedIn and Glassdoor:

• GCP-certified developers in the US: $125K-$165K USD average
• Australia: $135K-$170K AUD
• UK: £70K-£100K

Google Cloud's market share keeps growing (they're at about 12% now, up from 10% two years ago), and the supply of GCP-certified professionals hasn't kept up with demand. So the certification carries real weight — more so than an additional AWS cert if you already have three of those.

Frequently Asked Questions