Google Cloud Cloud DevOps Engineer

Infrastructure that lives only in a console cannot be reviewed or rebuilt. You write Terraform modules, manage state safely, review plans before applying, and detect drift from what is declared.

• Resources, modules and variables
• Remote state, locking and workspaces
• Reading and reviewing a plan
• Detecting and correcting drift
• Testing and validating Terraform code
• Policy checks on planned changes

You build A tested Terraform module deployed to two environments with remote state.

Consistent environments cut a whole class of failures. You provide development workspaces with Cloud Workstations, keep environments alike, and connect tooling such as MCP servers to assist operations safely.

• Cloud Workstations for consistent developer setups
• Ephemeral and long-lived environments
• Promoting changes between environments
• Access and secrets in development environments
• MCP servers that give AI tools controlled access
• Environment cost and cleanup

You build A standard workstation image and environment layout for a platform team.

A pipeline is a product with its own users. You build with Cloud Build, release with Cloud Deploy, promote artifacts through environments, and choose canary or blue/green releases for each target.

• Cloud Build triggers, steps and caching
• Cloud Deploy delivery pipelines and targets
• Promoting immutable artifacts
• Canary and blue/green releases
• Approvals and release gates
• Deploying to GKE and Cloud Run

You build A pipeline that builds, tests and promotes a service with a canary stage.

Infrastructure and models need the same discipline as application code. You build pipelines that plan, review and apply infrastructure changes, and that test, register and release ML models.

• Terraform pipelines: plan on review, apply on merge
• Securing credentials in infrastructure pipelines
• Testing infrastructure changes
• ML pipeline stages and promotion
• Model registry to deployment automation
• Rollback for infrastructure and models

You build A pipeline that applies infrastructure changes after review and one that promotes a model.

A build system is a target. You separate configuration from code, store secrets safely, and use provenance, scanning and policy so you can show where every deployed artifact came from, in line with SLSA.

• Configuration management across environments
• Secret Manager in pipelines and runtimes
• Artifact scanning and dependency checks
• Build provenance and SLSA levels
• Binary Authorization policy
• Responding to a vulnerable dependency

You build A supply chain setup with scanning, provenance and a deploy-time policy.

Reliability is a number you agree on, not a feeling. You choose indicators that reflect user experience, set targets, track error budgets, and use them to decide when to ship and when to stop.

• Choosing SLIs that reflect users
• Setting realistic SLO targets
• Measuring SLIs with logs and metrics
• Error budgets and release decisions
• Burn-rate alerting
• Negotiating SLOs with product teams

You build SLIs, SLOs and an error budget policy for one service, with burn-rate alerts.

Services age, grow and change owners. You manage a service from launch review to retirement, forecast demand, plan capacity and autoscaling, and cut the repetitive work that eats engineering time.

• Production readiness reviews
• Forecasting demand and capacity
• Autoscaling policies and limits
• Quotas and regional capacity
• Identifying and reducing toil
• Retiring services safely

You build A launch checklist and capacity plan for a growing service.

Incidents cannot be avoided, but their damage can be limited. You design for fast rollback, graceful degradation and clear incident roles, then learn from each failure in blameless reviews.

• Rollbacks, feature flags and progressive delivery
• Graceful degradation and load shedding
• Incident roles and communication
• Runbooks and on-call practice
• Blameless postmortems
• Turning findings into reliability work

You build An incident response runbook and a postmortem for a simulated outage.

You can only operate what you can observe. You instrument code with OpenTelemetry, collect logs, metrics and traces, and use Prometheus-style metrics and PromQL where workloads run on Kubernetes.

• Structured logs and log routing
• Metrics with Cloud Monitoring
• OpenTelemetry instrumentation
• Managed Prometheus and PromQL queries
• Distributed traces across services
• Controlling the volume and cost of telemetry

You build An instrumented service that emits correlated logs, metrics and traces.

Alerts should lead to action, and dashboards to answers. You build views for service owners, write alerting policies on symptoms, and troubleshoot problems in infrastructure, pipelines and applications with Logs Explorer and traces.

• Dashboards for service owners
• Alerting policies that reflect user impact
• Log-based metrics
• Queries in Logs Explorer
• Troubleshooting failed pipelines and deployments
• Tracing a slow request across services

You build Dashboards and alerting policies for one service, and a traced investigation of a failure.

Reliable systems can still waste money. You gather performance data, use recommendations and discounts wisely, choose between standard and Spot capacity, and track the cost of AI workloads, including token use.

• Performance data and bottleneck analysis
• Rightsizing with Active Assist recommendations
• Committed use discounts and Spot VMs
• FinOps practices: showback and budgets
• Provisioned Throughput for model serving
• Tracking token consumption

You build A cost and performance review with five changes and their estimated effect.

Combine every discipline into one platform. You set up the hierarchy and infrastructure code, deliver an application through a secured pipeline, define SLOs, instrument it, and prove it recovers when you break it.

• Designing the platform and its governance
• Building pipelines and infrastructure code
• Defining SLOs and observability
• Breaking it on purpose and responding
• Presenting the platform

You build A delivery platform with governance, pipelines, SLOs, observability and a recovery test.