The PR000263 Google Cloud DevOps Engineer certification, officially known as Google Cloud Certified – Professional Cloud DevOps Engineer, is one of the most practical professional-level certifications in the Google Cloud portfolio. Unlike certifications that concentrate primarily on a single product or technology, PR000263 evaluates your ability to operate reliable software and infrastructure across the complete production lifecycle.
You are not being tested simply on Kubernetes, Terraform, monitoring, or CI/CD. Instead, the certification asks a broader question: can you operate software and infrastructure in production while balancing delivery speed, reliability, security, performance, and cost?
That distinction matters. A developer may know how to build an application, and a cloud engineer may know how to create infrastructure, but a DevOps engineer has to think about what happens after hundreds of changes, multiple environments, production incidents, security requirements, scaling events, and increasingly complicated software delivery pipelines enter the picture.
For students and people who are relatively new to cloud computing, the Professional Cloud DevOps Engineer certification can also serve as a useful technical roadmap. You may not be ready to take the exam immediately, but the objectives provide a surprisingly good checklist of the technologies and engineering practices used by modern cloud operations teams.
PR000263 Google Cloud DevOps Engineer Exam Overview
Before discussing the technical content, it is worth understanding what the PR000263 exam actually looks like.
| Item | Current Exam Information |
|---|---|
| Certification | Google Cloud Certified – Professional Cloud DevOps Engineer |
| Exam Code | PR000263 |
| Level | Professional |
| Exam Length | 2 hours |
| Questions | 50–60 multiple-choice and multiple-select questions |
| Registration Fee | US$200, plus applicable taxes |
| Languages | English and Japanese |
| Delivery | Online-proctored exam or testing center |
| Formal Prerequisites | None |
| Recommended Experience | 3+ years of industry experience, including 1+ year designing and managing production systems on Google Cloud |
| Certification Validity | 2 years |
The absence of a formal prerequisite can be misleading. Google does not require you to earn the Associate Cloud Engineer certification first, but this is still a professional-level exam. The official recommended experience is a useful indication of the expected depth.
A student can absolutely study these technologies, but memorizing the names of Google Cloud products is not enough. You need to understand why one design is safer, easier to operate, more scalable, or more cost-effective than another.
How Valuable Is the Google Cloud Professional DevOps Certification?
There are two ways to think about the value of a cloud certification.
The first is the credential itself. Google Cloud Professional certifications are role-based certifications intended to validate advanced technical skills associated with actual cloud job functions. For employers that use Google Cloud, a Google Cloud DevOps certification can provide useful evidence that a candidate understands more than basic cloud administration.
The second, and in my view more important, value is what you have to learn while preparing for it.
A serious PR000263 preparation process forces you to connect subjects that beginners often study separately:
- cloud infrastructure
- identity and access management
- networking
- Infrastructure as Code
- Kubernetes
- continuous integration
- continuous delivery
- release engineering
- secrets management
- software supply chain security
- monitoring and observability
- incident response
- Site Reliability Engineering
- capacity planning
- performance engineering
- cloud cost optimization
That combination is closely aligned with what a real DevOps or Site Reliability Engineering role requires.
The certification is particularly relevant for people targeting jobs such as:
- Cloud DevOps Engineer
- Site Reliability Engineer
- Platform Engineer
- Cloud Engineer
- Infrastructure Engineer
- Release Engineer
- Cloud Operations Engineer
- DevSecOps Engineer
At the same time, a certification should not be treated as a replacement for practical experience. A candidate who has built a functioning deployment pipeline, debugged a Kubernetes workload, configured an SLO, and investigated real logs will usually develop much better engineering judgment than someone who has only memorized documentation.
The credential is strongest when it sits on top of a demonstrable technical portfolio.
PR000263 Google Cloud DevOps Engineer Exam Domains
The current PR000263 exam guide and preparation material should be approached through five major technical areas.
| Domain | Approximate Weight |
|---|---|
| Bootstrapping and maintaining a Google Cloud organization | ~20% |
| Building and implementing CI/CD pipelines, including continuous testing, for application, infrastructure, and machine learning workloads | ~25% |
| Applying Site Reliability Engineering practices | ~18% |
| Implementing observability practices and troubleshooting issues | ~25% |
| Optimizing performance and cost | ~12% |
Two observations are immediately useful.
First, CI/CD and observability together account for roughly half of the exam. If your preparation consists mostly of Compute Engine, basic IAM, and VPC networking, you are studying the wrong certification.
Second, this is no longer an exam that can be reduced to a traditional “DevOps tools” checklist. The current guide includes AI-assisted development and operations, machine learning delivery pipelines, software supply chain security, OpenTelemetry, PromQL, FinOps, GitOps, and hybrid or multi-cloud considerations.
Domain 1: Bootstrapping and Maintaining a Google Cloud Organization (~20%)
This section establishes the platform on which everything else runs.
You should understand the Google Cloud resource hierarchy and the relationship between organizations, folders, projects, IAM policies, service accounts, networking, and shared operational services.
Important areas include:
- projects, folders, and application-centric resource organization
- Shared VPC
- VPC Network Peering
- Private Service Connect
- multi-project logging and monitoring
- IAM roles and organization policies
- service accounts
- data residency considerations
- Infrastructure Manager
- Terraform
- Config Connector
- Cloud Foundation Toolkit
- Helm
- GitOps
- Python and Go automation
- Cloud Workstations and Cloud Shell
One detail worth noticing in the modern exam guide is the inclusion of Gemini Code Assist, Gemini Cloud Assist, and Gemini CLI. Google clearly expects modern cloud engineers to understand where AI-assisted development and operations can fit into an engineering workflow.
Domain 2: Building and Implementing CI/CD Pipelines (~25%)
This is one of the two largest sections of the exam and should receive significant study time.
You should be comfortable designing pipelines for applications and infrastructure rather than thinking of CI/CD as nothing more than “run tests and deploy a container.”
Technologies and concepts include:
- Cloud Build
- Cloud Deploy
- Artifact Registry
- GKE
- Skaffold
- Kustomize
- Git
- Jenkins
- Argo CD
- Packer
- pipeline triggers
- approval workflows
- continuous testing
- machine learning delivery pipelines
- deployment auditing
You should also understand several deployment strategies:
- rolling deployments
- blue/green deployments
- canary deployments
- traffic splitting
- feature flags
- rollback
Knowing the definitions is only the beginning. You should be able to explain why a team might choose a canary deployment instead of replacing every production instance at once.
Domain 3: Applying Site Reliability Engineering Practices (~18%)
SRE is the conceptual heart of the Professional Cloud DevOps Engineer certification.
A traditional operations team might ask, “How do we prevent changes from breaking production?”
SRE asks a more interesting question: “How do we deliver changes quickly while keeping reliability within an acceptable level?”
You should understand:
- Service Level Indicators (SLIs)
- Service Level Objectives (SLOs)
- Service Level Agreements (SLAs)
- error budgets
- availability and latency targets
- capacity planning
- quotas and limits
- reservations
- autoscaling
- incident mitigation
- traffic draining and redirection
- adding emergency capacity
- rollback strategies
Domain 4: Observability and Troubleshooting (~25%)
This is the other major exam domain.
Modern systems are distributed. A request may travel through a load balancer, an API, several services, a database, a queue, and an external dependency. When the user says “the application is slow,” looking at CPU utilization alone is rarely sufficient.
The current exam guide includes:
- Cloud Logging
- Cloud Monitoring
- Ops Agent
- Cloud Audit Logs
- VPC Flow Logs
- OpenTelemetry
- Google Cloud Managed Service for Prometheus
- log-based metrics
- synthetic monitoring
- Logs Explorer
- Metrics Explorer
- PromQL
- dashboards
- alerting policies
- distributed tracing
- trace waterfalls and spans
- correlation of trace IDs and structured logs
The guide also explicitly includes using Gemini Cloud Assist for analysis of logs, metrics, and traces.
Domain 5: Optimizing Performance and Cost (~12%)
A production system that works correctly but costs five times more than it needs to is not well operated.
The exam therefore connects DevOps with FinOps and performance engineering. Topics include:
- application performance monitoring
- Active Assist insights and recommendations
- Spot VMs
- resource utilization
- committed-use discounts
- sustained-use discounts
- network service tiers
- Google Cloud recommenders
- GKE cost optimization
- Cloud Run cost optimization
- Compute Engine cost optimization
- observability costs
Core Technologies for the PR000263 Google Cloud DevOps Engineer Exam
Trying to memorize every Google Cloud service is not an efficient way to prepare. Instead, organize the platform around engineering problems and understand how individual services work together.
Infrastructure
- Compute Engine
- Managed Instance Groups
- Cloud Run
- Google Kubernetes Engine
- VPC networking
- load balancing
Infrastructure as Code
- Terraform
- Infrastructure Manager
- Config Connector
- Cloud Foundation Toolkit
- Helm
- GitOps
Software Delivery
- Cloud Build
- Artifact Registry
- Cloud Deploy
- Skaffold
- Kustomize
- Argo CD
Security
- IAM
- service accounts
- Secret Manager
- Cloud KMS
- Certificate Manager
- Parameter Manager
- Workload Identity Federation
- Binary Authorization
- Artifact Analysis
Observability
- Cloud Logging
- Cloud Monitoring
- OpenTelemetry
- Managed Service for Prometheus
- Cloud Audit Logs
- VPC Flow Logs
- synthetic monitors
- distributed traces
Do not study these as isolated products. Try to understand how they connect.
For example, a developer pushes code to a Git repository. Cloud Build compiles and tests it. An image is stored in Artifact Registry. Vulnerability analysis evaluates the artifact. Cloud Deploy promotes a release through staging and production. Binary Authorization can enforce deployment policy. GKE or Cloud Run serves the application. Cloud Monitoring and OpenTelemetry expose its health. An SLO defines whether the service is reliable enough.
That complete lifecycle is much closer to the way you should think about the exam.
Why SRE Matters So Much
If there is one topic I would recommend studying beyond the minimum required for the exam, it is Site Reliability Engineering.
SLI vs. SLO vs. SLA
These three terms are easy to memorize and surprisingly easy to confuse.
An SLI is a measurement of service behavior. For example:
- 99.95% of requests are successful.
- 95% of API responses complete in less than 300 milliseconds.
An SLO is the reliability target you want the service to meet.
An SLA is generally a formal agreement with consequences if a defined service commitment is not met.
Error Budgets
Error budgets are where SRE becomes operationally useful.
Suppose your service has a 99.9% availability SLO. That objective implicitly allows a small amount of unreliability.
Instead of demanding impossible perfection, the organization can use that allowed failure budget to balance reliability and engineering velocity.
If the service is comfortably meeting its SLO, the team can potentially take more deployment risk. If the error budget is being consumed too quickly, reliability work becomes more important.
This idea is central to the Google SRE approach: reliability has value, but extreme reliability also has a cost.
CI/CD Is More Than Automation
A common beginner definition of CI/CD is:
“Developers push code, tests run, and the application gets deployed.”
That is correct, but incomplete.
At professional level, you should think about:
- Who is allowed to trigger a deployment?
- Which identity does the build system use?
- Where are credentials stored?
- How are artifacts versioned?
- Can you prove which source produced a container image?
- Are vulnerabilities scanned?
- Which environments require manual approval?
- Can the release be rolled back safely?
- How do you determine whether a canary release is healthy?
- How do you prevent a compromised artifact from reaching production?
- How do you audit who deployed what and when?
These are production questions, not merely automation questions.
Canary Deployments
With a canary deployment, a new release is exposed to a small percentage of traffic first.
You monitor indicators such as:
- error rate
- latency
- CPU and memory consumption
- business transactions
- application-specific health metrics
If the new release behaves correctly, traffic is increased gradually. If the metrics deteriorate, the deployment can be stopped or rolled back before the entire user population is affected.
The important lesson is not simply that “Cloud Deploy supports progressive delivery.” The important lesson is that deployment decisions should be driven by measurable production signals.
Observability and Troubleshooting
Monitoring and observability are related, but they are not exactly the same.
Monitoring tells you whether known conditions are occurring. Observability helps engineers understand what is happening inside a system, including failures they did not predict in advance.
Three signals appear repeatedly in modern observability systems:
- Metrics — numerical measurements over time
- Logs — records of individual events
- Traces — the path of requests across distributed components
Metrics
Metrics are ideal for answering questions such as:
- What is the current request rate?
- What percentage of requests are failing?
- Has latency increased?
- Is CPU utilization approaching a capacity limit?
Logs
Logs provide event-level context. They can help explain why an operation failed or which component produced an error.
You should also understand that logging has operational and financial costs. Collecting every possible log forever is rarely a good design. Filtering, sampling, exclusions, retention, routing, and protection of sensitive data are all part of a mature logging strategy.
Distributed Tracing
Tracing becomes particularly important in microservice systems.
A single user request can generate multiple spans across multiple services. A trace waterfall can reveal that the frontend is healthy while a downstream service or database call is responsible for most of the latency.
The current exam guide’s focus on OpenTelemetry is worth paying attention to. OpenTelemetry provides a vendor-neutral framework for generating, collecting, and exporting telemetry such as metrics, logs, and traces.
DevSecOps and Software Supply Chain Security
Security is not a separate activity that happens after deployment. In a modern DevOps environment, security controls should be incorporated into the delivery process.
Secrets
Do not treat passwords, API tokens, certificates, or encryption keys as ordinary application configuration.
Understand the purposes of:
- Secret Manager
- Cloud KMS
- Certificate Manager
- Parameter Manager
- Workload Identity Federation
One useful exam-preparation question is:
Does this secret actually need to exist during the build, or should it be provided only when the application runs?
That distinction between build-time and runtime secret injection appears in the official exam objectives for a reason.
Software Supply Chain
A secure pipeline should provide confidence that the software running in production is really the software that went through the approved build and testing process.
Important concepts include:
- artifact vulnerability scanning
- artifact provenance
- Binary Authorization
- least-privilege IAM
- environment-specific policies
- SLSA
SLSA, or Supply-chain Levels for Software Artifacts, provides a framework for improving software supply chain integrity and reducing the risk of artifact tampering.
Performance, Capacity, and FinOps
One of the qualities I like about this certification is that cost is treated as an engineering concern rather than somebody else’s accounting problem.
A DevOps engineer influences cost every time they choose:
- instance sizes
- autoscaling limits
- log retention
- deployment architecture
- Kubernetes resource requests
- network paths
- high-availability designs
- storage classes
You should be able to reason about the trade-offs between performance, reliability, and cost.
For example, adding more replicas may reduce the risk of overload, but an unnecessarily high minimum replica count can also waste money. Aggressive log collection may improve diagnostic visibility, but excessive ingestion and retention can increase observability costs.
This is where FinOps becomes relevant: cloud cost optimization should be continuous and connected to engineering decisions.
How to Prepare for the PR000263 Google Cloud DevOps Engineer Exam
There is no universal study schedule, because someone managing GKE clusters every day starts from a very different position than a university student.
For a beginner, I would rather plan for approximately 10 to 12 weeks of consistent hands-on study than try to rush through hundreds of product names.
If you are organizing your preparation around the exam objectives, keeping a dedicated PR000263 preparation resource alongside official Google Cloud documentation can make it easier to keep your revision focused on the certification blueprint.
Phase 1: Build Google Cloud Foundations
Before touching advanced DevOps topics, make sure you understand:
- projects and billing
- IAM
- service accounts
- VPCs and subnets
- firewall rules
- Compute Engine
- Cloud Storage
- Cloud Run
- basic GKE concepts
If these topics still feel unfamiliar, Associate Cloud Engineer-level study material can provide a useful foundation even though earning that certification is not required.
Phase 2: Learn Infrastructure as Code
Build infrastructure using Terraform rather than creating everything manually in the Cloud Console.
Practice:
- providers
- resources
- variables
- outputs
- modules
- remote state
- environment separation
- reviewing infrastructure changes
Phase 3: Build a Real CI/CD Pipeline
Create a small application and build an end-to-end workflow:
- Store the application in Git.
- Trigger Cloud Build when code changes.
- Run automated tests.
- Build a container image.
- Push the image to Artifact Registry.
- Deploy first to a non-production environment.
- Promote the release to production.
- Implement rollback.
Do this yourself. Reading a diagram is not the same as debugging a failed build at 11:30 p.m.
Phase 4: Study SRE Properly
Practice creating:
- SLIs
- SLOs
- error budgets
- alerting policies
- incident response procedures
Read at least the most relevant chapters of Google’s SRE material rather than depending entirely on certification notes.
Phase 5: Build Observability
Instrument your application and investigate:
- structured logs
- metrics
- log-based metrics
- dashboards
- alerts
- Prometheus metrics
- distributed traces
- OpenTelemetry
Then intentionally break something.
Create latency, stop a service, misconfigure a deployment, or generate HTTP errors and use telemetry to find the root cause. Troubleshooting is a skill that grows through failure.
Phase 6: Add Security and Cost Controls
Review:
- least privilege
- Secret Manager
- Workload Identity Federation
- artifact scanning
- Binary Authorization
- SLSA concepts
- Spot VMs
- autoscaling
- rightsizing
- committed-use discounts
- observability cost controls
Phase 7: Scenario-Based Review
Near the exam, spend less time memorizing definitions and more time answering architecture questions such as:
- What is the simplest managed solution?
- Which option follows least privilege?
- How can the team reduce operational overhead?
- Which deployment strategy limits blast radius?
- What telemetry best measures user experience?
- How can the system recover safely?
- Which approach improves reliability without unnecessary cost?
Three Hands-on Projects I Recommend for Students
If you do not have professional cloud experience yet, projects are the best way to make the certification material concrete.
Project 1: Cloud Run CI/CD Pipeline
Build a simple REST application and create this workflow:
Git → Cloud Build → Artifact Registry → Cloud Deploy → Cloud Run
Add:
- automated tests
- a staging environment
- manual production approval
- Secret Manager
- Cloud Logging
- Cloud Monitoring
- a rollback procedure
Project 2: GKE Platform with Terraform
Create a small GKE environment using Terraform.
Include:
- networking
- GKE
- IAM
- Artifact Registry
- Helm or Kustomize
- autoscaling
- Prometheus metrics
- log collection
Then deploy an application using a GitOps-style workflow.
Project 3: SRE and Incident Simulation
Take one of your applications and define:
- an availability SLI
- a latency SLI
- an SLO
- an error budget
- alert thresholds
- a dashboard
Then deliberately create an incident.
Investigate it using logs, metrics, and traces. Write a short postmortem that explains what failed, why it failed, how it was mitigated, and how you would prevent a repeat.
That single exercise teaches more DevOps than many hours of memorizing multiple-choice questions.
PR000263 Exam Strategy
1. Read the Constraint Before Choosing the Product
Scenario questions often contain several technically possible answers.
Pay attention to phrases such as:
- minimum operational overhead
- least privilege
- high availability
- reduce deployment risk
- automatically
- without managing servers
- centralized administration
- multiple projects
- hybrid environment
- cost optimization
The constraint often tells you more than the product names do.
2. Prefer Engineering Principles Over Memorization
If you understand why least privilege, immutable artifacts, progressive delivery, automated testing, SLO-based alerting, and managed services are useful, many questions become easier even when the exact scenario is new.
3. Learn the Boundaries Between Similar Services
For every important service, ask:
- What problem does it solve?
- When should I use it?
- What does it manage for me?
- What alternatives exist?
- What are its security implications?
- How does it integrate with the rest of Google Cloud?
4. Do Not Depend on Brain Dumps
Apart from the obvious certification-policy issues, memorizing leaked questions is a poor way to prepare for a job-role certification.
Google Cloud changes quickly, and the current DevOps exam guide already contains technologies and practices that were much less prominent in older versions of the exam.
Study the current official exam guide rather than assuming a two-year-old course still represents the current test.
What Has Become More Important in the Current Exam?
Candidates using older study material should pay particular attention to a few areas that appear clearly in the current exam guide.
AI-Assisted Cloud Operations
The guide now references:
- Gemini Code Assist
- Gemini Cloud Assist
- Gemini CLI
You do not need to turn preparation into an AI certification course, but you should understand how AI assistance can support development, log analysis, metrics interpretation, trace analysis, and cloud operations.
OpenTelemetry
OpenTelemetry has become increasingly important as organizations seek vendor-neutral application instrumentation across cloud and hybrid environments.
Software Supply Chain Security
Artifact Analysis, Binary Authorization, provenance, and SLSA deserve serious attention.
Machine Learning Delivery
The current CI/CD domain explicitly includes pipelines for application, infrastructure, and machine learning workloads. DevOps principles increasingly extend beyond conventional web applications.
FinOps
Cost optimization is not merely an optional architecture topic. The exam guide explicitly identifies FinOps practices as part of the Professional Cloud DevOps Engineer role.
Who Should Take the PR000263 Exam?
This certification makes the most sense for:
- Google Cloud engineers moving into DevOps or SRE
- DevOps engineers adopting Google Cloud
- Kubernetes engineers working with GKE
- platform engineers building internal cloud platforms
- developers responsible for production delivery
- operations engineers transitioning toward automation
- students who already have a strong cloud foundation and want a structured advanced learning goal
If you are completely new to cloud computing, I would not make PR000263 your first short-term exam target.
You can still use the syllabus as a learning map, but first become comfortable with Google Cloud fundamentals, Linux, networking, Git, containers, IAM, and basic scripting.
PR000263 Google Cloud DevOps Engineer FAQ
Is the PR000263 Google Cloud DevOps Engineer exam difficult?
Yes, especially for candidates without production experience. The breadth is what makes it challenging: you must connect infrastructure, CI/CD, SRE, security, Kubernetes, observability, troubleshooting, performance, and cost rather than studying one narrow product area.
Do I need the Associate Cloud Engineer certification first?
No. Google Cloud does not require another certification before you take the Professional Cloud DevOps Engineer exam. However, Associate Cloud Engineer-level knowledge is a useful foundation if you are new to GCP.
How many questions are on the PR000263 exam?
The current standard exam contains 50–60 multiple-choice and multiple-select questions and has a two-hour time limit. Candidates reviewing the PR000263 certification exam should make sure their preparation reflects the latest exam domains rather than relying only on older study material.
How much does the Google Cloud Professional DevOps exam cost?
The standard registration fee is currently US$200 plus applicable taxes. Always check the official certification page before registering because exam policies and pricing can change.
What is the passing score?
Google Cloud does not provide candidates with a numerical exam score. Certification exams are reported as pass or fail rather than as a public percentage score.
How long is the certification valid?
Google Cloud Professional-level certifications are currently valid for two years from the certification date. Recertification is required to maintain active status.
Is Kubernetes important for the PR000263 exam?
Yes. GKE appears throughout the exam objectives, including enterprise cluster management, deployments, autoscaling, observability, hybrid environments, security, and cost optimization. You do not need to become a Kubernetes project maintainer, but you should be comfortable operating containerized workloads.
Is Terraform on the Professional Cloud DevOps Engineer exam?
Infrastructure as Code is explicitly part of the exam guide, and Terraform is one of the named technologies. You should understand practical IaC workflows, not merely Terraform syntax.
Does the exam cover Gemini?
Yes. The current exam guide references Gemini Code Assist, Gemini Cloud Assist, and Gemini CLI, including AI-assisted development and analysis of operational telemetry.
Does the exam include OpenTelemetry?
Yes. OpenTelemetry appears in the current observability objectives for telemetry collection and distributed tracing.
How long should a beginner study for PR000263?
There is no official required study period. For a student or early-career engineer, a 10-to-12-week hands-on plan is more realistic than attempting to memorize the syllabus in a few days. Candidates with daily GCP DevOps experience may need considerably less time.
Final Thoughts
The PR000263 Google Cloud DevOps Engineer certification is valuable because its syllabus reflects an important shift in modern cloud engineering.
Running production software is no longer just about maintaining servers. Modern cloud operations sits at the intersection of software development, platform engineering, automation, reliability, security, observability, and financial efficiency.
If you prepare correctly, PR000263 becomes more than an exam.
You learn how a source-code commit can become a secure artifact, how that artifact moves safely through environments, how production health is measured, how failures are detected and mitigated, how reliability is balanced against release velocity, and how infrastructure is continuously optimized instead of simply left running.
For students, that is probably the most useful way to approach the certification. Do not ask only, “What do I need to memorize to pass?”
Ask instead:
“Could I design, deploy, observe, troubleshoot, secure, and improve this system if it were actually running in production?”
When the answer begins to become yes, you are learning the skills the certification is intended to represent.
Official and Authoritative References
Because Google Cloud products and certification objectives change regularly, always compare your study material with the latest official exam guide before booking the exam.
- Google Cloud – Professional Cloud DevOps Engineer Certification
https://cloud.google.com/learn/certification/cloud-devops-engineer - Google Cloud – Professional Cloud DevOps Engineer Exam Guide
https://cloud.google.com/learn/certification/guides/cloud-devops-engineer - Google Cloud Certification FAQs
https://support.google.com/cloud-certification/answer/9438208 - Google Cloud Certification Program Policies
https://support.google.com/cloud-certification/answer/10220719 - Google Cloud – DevOps Capabilities and DORA Practices
https://cloud.google.com/architecture/devops - Google Site Reliability Engineering Books
https://sre.google/books/
