"Learn by doing, not watching"
"Build deep understanding through experimentation"
"RAD guides your exploration with embedded learning"
"Conceptual mastery through hands-on practice"
Certification proves you know the theory. This programme proves you can engineer.
Statistical analysis of thousands of development and delivery teams worldwide shows that performers fall into distinct groups based on deployment frequency, lead time for changes, mean time to restore, and change failure rate. Elite Performers demonstrate superior performance without trade-offs — fast and stable. The gap between Elite and Low is not a matter of talent; it is a matter of practiced capability.
| DORA Metric | Elite Performer | High Performer | Medium Performer | Low Performer |
|---|---|---|---|---|
| Deployment Frequency | Multiple per day | Once per day — once per week | Once per week — once per month | Once per month — 6 months |
| Lead Time for Changes | < 1 day | 1 day — 1 week | 1 week — 1 month | 1 month — 6 months |
| Mean Time to Restore (MTTR) | < 1 hour | < 1 day | < 1 day | 1 week — 1 month |
| Change Failure Rate | 0–15% | 0–15% | 0–15% | 46–60% |
"Companies that fail to leverage the transformative, value-generating power of IT risk being disrupted by those who do. What has been missing is an analytical, data-driven framework to forecast the value and justify investment in DevOps transformations."
— The ROI of DevOps Transformation, Google Cloud / DORADORA research shows that Elite Performers spend significantly less time on unplanned rework and manual operations. That recovered time is reinvested in new features and value delivery — effectively "free headcount" without additional hiring.
Engineers in high-performing teams report higher job satisfaction and are statistically far more likely to recommend their organisation as a great place to work — a decisive advantage in a competitive talent market.
CAMP demonstrated that practitioners learn best when they work on real modernisation challenges with real cloud infrastructure — not simulations. The RAD programme applies this same insight at the individual practitioner level: structured modules, production-grade infrastructure, embedded expert guidance — without cohort schedules, mandatory sessions, or geographic constraints. The same engineering depth. Your timeline.
| Dimension | Google Cloud CAMP | RAD Cloud Practitioner Programme |
|---|---|---|
| Primary audience | Enterprise modernisation teams | Individual certified practitioners |
| Format | Structured cohort, workshops, expert coaching | Fully self-directed, asynchronous, no cohort |
| Schedule | Fixed programme dates and milestones | No deadlines, no required sessions, self-paced |
| Infrastructure | Expert-provisioned environments | Self-deployed, real GCP resources via RAD portal |
| Expert guidance | Live coaching from Google Cloud architects | Embedded in module documentation and exploration guides |
| Collaboration | Mandatory cohort interaction | Optional community, never mandatory |
| Application depth | Modernisation use cases | 30+ production applications across Cloud Run and GKE |
| Outcome framework | Modernisation capability milestones | DORA metrics alignment — measurable engineering capability |
| Certification alignment | Aligned to modernisation competencies | Explicit ACE, PCA, PCD, PDE, PSE exam domain mapping |
Both programmes insist on working with real cloud infrastructure — not simulations. Every resource provisioned by a RAD module is a live GCP resource, visible in the console, inspectable, and modifiable.
The engineering patterns embedded in every RAD module — Workload Identity, VPC Service Controls, Binary Authorization, Cloud Deploy — are the same patterns that CAMP emphasises and that Google Cloud recommends for production workloads.
Both programmes are designed around the question: "Can you do this on a real project?" — not "Did you finish the course?" DORA metrics provide the RAD programme with a quantified capability framework.
"Self-paced — no deadlines, no required sessions, no cohort pressure. Your certification journey, your engineering journey, on your schedule."
"RAD guides your exploration with embedded learning — every module ships with certification-mapped exploration prompts and engineering practice guides written directly into the documentation."
"Optional community, not mandatory collaboration — engage with other practitioners when it adds value to your learning, not because attendance is tracked."
"The same infrastructure patterns used in CAMP engagements — deployed by you, on real GCP, at your own pace, against applications you choose."
VPC, Cloud SQL, Redis, Filestore, Secret Manager, IAM service accounts, load balancing, Cloud Armor, CDN, and full observability — wired together and ready to explore.
Cloud Build triggers, Artifact Registry, Binary Authorization, Cloud Deploy multi-stage pipelines, and OpenTofu state management — the full engineering automation stack.
Per-section exploration prompts aligned to ACE, PCA, PCD, PDE, and PSE exam domains, plus DORA metric context. No separate study materials required.
The four-tier module architecture — Platform → Foundation → Application → Common — is a production Internal Developer Platform. Practitioners work with real OpenTofu modules, not synthetic exercises.
Elite performers deploy multiple times per day with lead times under one day. This requires practiced CI/CD discipline — not just knowledge of what CI/CD is.
Security shifted left into IaC. Every guardrail — IAP, Cloud Armor, Binary Authorization, VPC-SC, CMEK — is a Terraform resource, reviewed and version-controlled, not a console afterthought.
Elite performers restore service in under one hour. SRE discipline — SLOs, error budgets, health probes, post-mortems — turns that target from aspiration into operational reality.
Cloud costs are not an ops problem — they are an engineering problem. FinOps practices are embedded into every module via scale-to-zero defaults, lifecycle policies, and cost-allocation labels.
You cannot improve what you cannot measure. Google Cloud Observability is natively integrated into every deployed module — practitioners work with real dashboards, traces, and structured logs from their first deployment.
DORA research establishes that Elite performers combine technical capabilities (trunk-based development, continuous integration, deployment automation, loosely coupled architecture, cloud infrastructure, test automation) with lean management and cultural practices. Each of the six disciplines above maps directly to one or more DORA technical capability categories. The RAD programme builds these capabilities through deliberate hands-on practice — not through coursework.
| What you practise in RAD | DORA metric improved | How it manifests on the job |
|---|---|---|
| Cloud Build CI/CD pipelines, Cloud Deploy multi-stage delivery | Deployment Frequency ↑ | Confident one-trigger deployments; ability to deploy multiple times per day without heroics |
| OpenTofu IaC, commit-pinned state, automated validation gates | Lead Time for Changes ↓ | Infrastructure changes reviewed, planned, and applied in minutes — not days of manual provisioning |
| SLO configuration, uptime checks, burn-rate alerts, runbooks | MTTR ↓ | Detects incidents before users report them; structured runbooks enable recovery in under one hour |
| Plan-time validation blocks, canary deployments, traffic splitting | Change Failure Rate ↓ | Misconfigurations caught before apply; risky changes rolled out progressively with automatic rollback |
| VPC-SC dry-run, IAP configuration, Binary Authorization | All four metrics | Security controls that don't slow delivery — the hallmark of Elite-level DevSecOps |
| Blameless post-mortems, chaos engineering, fault injection | MTTR ↓ & CFR ↓ | Systemic improvement mindset; failures are learning events, not blame events |
| Certification | Domains | Primary Disciplines |
|---|---|---|
| ACE — Associate Cloud Engineer | 4 sections | Platform Eng, GitOps, Ops |
| PCA — Professional Cloud Architect | 6 sections | Platform Eng, DevSecOps, SRE |
| PCD — Professional Cloud Developer | 4 sections | CI/CD, GitOps, Observability |
| PDE — Professional DevOps Engineer | 5 sections | CI/CD, SRE, FinOps |
| PSE — Professional Security Engineer | 5 sections | DevSecOps, Zero Trust, VPC-SC |
DORA explicitly frames DevOps ROI as value-driven, not just cost-driven. Engineers liberated from rework and manual toil reinvest that time in new features — "free headcount" without additional hiring.
The TechEquity automation layer reduces application provisioning from 3–5 days of manual work to under 2 hours — a 95% reduction in setup time that directly compresses lead time for changes.
DORA data shows that Elite-performing teams have markedly higher employee satisfaction. The programme develops the skills that make practitioners the kind of engineers that high-performing teams want to hire and keep.
Resist the urge to complete modules quickly. Spend more time in the GCP console than in the deployment portal. Read resource configurations, follow IAM bindings, trace request paths through Cloud Trace. Depth beats breadth.
Every "Customisation" prompt surfaces a failure mode. Lower a memory limit until OOMKill. Break a health check. Point IAP at an unauthorised user. Observe. The moment a deployment fails for a reason you understand is the moment you become an Elite engineer.
After each experiment, ask: which DORA metric does this improve? How does this CI/CD pattern compress lead time? How does this alert policy reduce MTTR? This reflection transforms operational experience into engineering understanding.
If you notice an unfamiliar resource — click into it. If a role looks broader than expected — investigate. Self-directed learning rewards the practitioner who asks "why does this work this way?"
Engage with the practitioner community when it adds value — to share a finding, discuss an architecture decision, or ask a question. Participation is never mandatory, never tracked, never measured.
The partner-modules repository ships with CLAUDE.md (project context for Claude Code), AGENTS.md (eight slash-command agentic workflows: /global, /foundation, /application, /troubleshoot, /security, /performance, /maintain, /cicd), and .agent/skills/ layered skill guides for every module tier. A scaffold script — scripts/create_modules.sh — generates a complete CloudRun + GKE + Common module triple in one command. AI tools read this context and accelerate module authoring from weeks to hours.
Claude Code is an AI-native CLI that reads CLAUDE.md and AGENTS.md to understand the repository's four-tier architecture, naming conventions, and critical rules before writing a single line of code. It operates within the repository's own governance.
Jules is Google's asynchronous GitHub-native AI agent. Participants assign Jules to issues and pull requests; Jules reads the repo, writes code, opens PRs, and responds to review comments — enabling asynchronous code review and iteration without synchronous pairing sessions.
A production-ready <App>_CloudRun + <App>_GKE + <App>_Common module set for a containerised application of the participant's choosing — wired to the Foundation Module and following all four-tier conventions.
A structured exploration guide for the new module — covering all six engineering disciplines, with per-section prompts mapped to ACE, PCA, PCD, PDE, or PSE exam domains, and DORA metric context. Written following the same format as the existing module library.
The completed module is a concrete demonstration that the participant can build production-grade RAD modules independently — wiring IAM, secrets, CI/CD, observability, and documentation from scratch. Whether the module is contributed to the ecosystem or used privately is the participant's choice.
| Session | Focus | AI Tool |
|---|---|---|
| Session 1 | Architecture review & module scaffolding with create_modules.sh | Claude Code |
| Session 2 | IaC resource implementation: VPC, Cloud SQL, secrets, IAM | Claude Code + Jules |
| Session 3 | CI/CD wiring, validation gates, exploration guide authoring | Jules (async PRs) |
| Session 4 | Peer review, DORA mapping, documentation completion and module validation | Jules (review response) |
To build a module — one that correctly wires IAM, handles secret rotation, exposes meaningful UIMeta variables, and ships with a certification-mapped exploration guide — a practitioner must fully understand every layer of the four-tier architecture. The Module Factory develops this proficiency through structured, AI-assisted practice. Whether a completed module is used privately, shared with a team, or contributed to the ecosystem is entirely at the participant's discretion.
Self-paced. No deadlines. No cohort pressure. Real GCP infrastructure. Real engineering disciplines. DORA-measurable outcomes.
"Learn by doing, not watching"
"Build deep understanding through experimentation"
"RAD guides your exploration with embedded learning"
"Conceptual mastery through hands-on practice"