Google Cloud Cloud Developer

Services talk through contracts, and contracts last longer than code. You design REST and gRPC interfaces, manage versions with Apigee, and connect services through Pub/Sub and Eventarc without losing or repeating work.

• REST and gRPC interface design
• API versioning and deprecation
• API management with Apigee
• Pub/Sub topics, subscriptions and delivery semantics
• Eventarc and routing events to services
• Idempotent consumers and ordering

You build An API and an event flow for an order service, with idempotent handlers.

Data models are hard to change once in production. You choose among Firestore, Cloud SQL, Spanner, Bigtable, Memorystore and Cloud Storage, and model data around queries, consistency and growth.

• Firestore document modeling
• Cloud SQL and Spanner for relational data
• Bigtable row key design
• Caching with Memorystore
• Cloud Storage for objects and uploads
• Consistency, transactions and choosing a store

You build A data model for one application across a relational store and a document store.

Application security covers code, credentials and the artifacts that ship. You use service accounts with least privilege, keep credentials in Secret Manager, authenticate users, and only deploy images that pass checks.

• Service accounts and least privilege for applications
• Secret Manager for credentials and keys
• Authenticating end users and calling services
• Scanning dependencies and images for vulnerabilities
• Signed images and Binary Authorization
• Securing API endpoints

You build An application with managed secrets, scoped service accounts and an image policy that blocks unsigned builds.

Fast feedback needs a good local loop. You run emulators for core services, use IDE integrations to develop against Google Cloud, and handle credentials locally without copying keys around.

• Application Default Credentials locally
• Emulators for Pub/Sub, Firestore and other services
• Cloud Code in the IDE
• Cloud Shell and cloud-based workspaces
• Debugging containers locally and remotely
• Keeping local and cloud environments consistent

You build A local development setup that runs a service and its dependencies against emulators.

A container is only trustworthy if you know how it was made. You write lean images, build them with Cloud Build or buildpacks, store them in Artifact Registry, and record provenance so builds can be verified.

• Writing small, secure Dockerfiles
• Buildpacks versus Dockerfiles
• Cloud Build steps, triggers and caching
• Artifact Registry repositories and permissions
• Vulnerability scanning of images
• Build provenance and attestation

You build A build pipeline that produces a scanned, versioned image with provenance.

Tests are where AI coding help is useful and risky. You write unit, integration and contract tests, use emulators for realistic runs, and apply AI assistants to generate and debug tests while checking their output.

• Unit and integration test design
• Testing against emulators and test projects
• Contract tests between services
• Using AI assistants to draft and extend tests
• Reviewing AI-written code for quality and security
• Debugging with AI agents without losing understanding

You build A test suite for one service, partly AI-drafted and fully reviewed.

Cloud Run makes deployment simple and hides important settings. You deploy from source and containers, manage revisions and traffic, tune concurrency and instances, and trigger services with events.

• Deploying from source and from containers
• Revisions, tags and traffic splitting
• Concurrency, minimum instances and timeouts
• Eventarc triggers for Cloud Run services
• Securing and versioning Cloud Run APIs
• Configuration and secrets at deploy time

You build A Cloud Run service with a canary traffic split and an event trigger.

Kubernetes gives control and asks for care. You write deployment and service manifests, set resource requests, add health checks, and configure autoscaling and safe rollouts.

• Deployments, Services and Ingress
• Resource requests and limits
• Liveness, readiness and startup probes
• Horizontal pod autoscaling
• Rolling updates and rollback
• Configuration with ConfigMaps and Secrets

You build A GKE deployment with health checks, autoscaling and a tested rolling update.

Most application code is calls to other services, and those calls fail. You use client libraries, authenticate correctly, call data, messaging and AI APIs, and handle errors with backoff and clear limits.

• Client libraries and authentication
• Connecting to datastores and messaging
• Calling machine learning and generative AI APIs
• Exponential backoff and retry design
• Pagination, batching and quotas
• Handling partial failure

You build A service that calls three Google Cloud APIs with retries and quota-aware batching.

When production misbehaves you need evidence. You write structured logs, publish metrics, trace requests through services, and follow a fault from an alert to its cause using the right tool at each step.

• Structured logging in Cloud Logging
• Metrics and alerting policies
• Error Reporting for grouped failures
• Distributed tracing and trace IDs in logs
• Profiling slow code
• A method for finding the cause of a failure

You build An observability setup for a multi-service application and a traced root cause for an injected fault.

Design, build and ship one application across services. You choose the platform and data stores, secure and test the code, deploy it through a pipeline, then observe it and diagnose a fault.

• Designing the application and its APIs
• Building, securing and testing the services
• Deploying to Cloud Run and GKE
• Integrating Google Cloud services
• Observing it and fixing a fault

You build A deployed multi-service application with tests, pipeline, observability and a documented fix.