GCP AI Upskilling For AI-First Software Engineering Trainer

# Track 1: AI-First Software Engineering (Type A) Part of the GCP-Centered AI Upskilling Program that BetterFutureLabs is delivering in partnership with a top university for the end-client insurance company. The cohort is 265 of the insurance company's software engineers. 12-week live-virtual program starting August 17, 2026. Learner commitment: 8 to 10 hours per week. Teaching days are Tuesday and Thursday. Weeks 1 to 10 are instructor-led builds and labs; Weeks 11 to 12 are the capstone. ## Who this track is for This track is for practicing software engineers who write, integrate, test, and ship application code and now need to build AI features on Google Cloud. Day to day they own services, APIs, and delivery pipelines, and decide how a feature is designed, tested, and deployed safely. The track moves them beyond ad hoc prompting into grounded AI applications, retrieval, tool use, orchestration, and production-aware agentic workflows. The emphasis is engineering discipline: an AI feature is done not when it demos well but when it is tested, observable, secured, and deployable. Because these learners are engineers at the end-client insurance company, every build is anchored to insurance work: claims processing, underwriting, policy servicing, fraud detection, and customer support. ## What learners will be able to do by the end - Design AI-first software using established patterns for prompting, grounding, retrieval, and tool use rather than one-off prompt hacks. - Build a Retrieval-Augmented Generation (RAG) workflow that grounds model output in approved enterprise data sources. - Implement tool and function calling, then compose those calls into orchestration logic and agentic workflows that complete a task or terminate safely with human escalation. - Design APIs for AI-enabled applications, including request and response contracts, error handling, and fallback behavior. - Containerize and deploy an AI-enabled service to Cloud Run, and reason about when GKE container orchestration fits better. - Stand up a delivery pipeline using Cloud Build and Artifact Registry, with secrets in Secret Manager and access scoped through IAM. - Write tests and evaluation harnesses for AI-enabled software (correctness, regression, groundedness, output quality) and run them as a CI gate that fails the build on a quality regression. - Instrument an AI feature with Cloud Logging and Monitoring so behavior, cost, and failures are observable in production. - Apply responsible AI, AI-endpoint security (including prompt-injection and indirect-injection defense), and operational guardrails before an application reaches users. - Produce technical documentation and a deployment and monitoring plan suitable for enterprise review. ## Primary skill areas - AI-first software design patterns - Prompting, grounding, embeddings, vector search, and RAG - Agentic workflow design and reliability engineering - Tool and function calling and orchestration logic - API design for AI-enabled applications - GCP-based deployment patterns - Cloud Run, containers, CI/CD, and artifact management - Testing, evaluation harnesses, and CI quality gates for AI-enabled software - Observability, logging, and monitoring - AI-endpoint security and red-teaming - Responsible AI, security, and operational guardrails ## Google Cloud emphasis - Vertex AI and Gemini development workflows - RAG and grounding patterns - Cloud Run for serverless deployment - GKE for container orchestration depth - Cloud Build and Artifact Registry for delivery pipelines - IAM and Secret Manager - Cloud Logging and Monitoring ## How this track sits on the shared GCP architecture spine All four tracks are built on one shared GCP architecture spine and one cross-track common foundation, so every learner shares the same vocabulary for cloud projects, identity, AI workflows, retrieval, deployment, observability, and governance. That foundation covers GCP orientation and cloud foundations; AI and GenAI foundations for enterprise use; responsible AI, risk, and governance; data access, privacy, and security expectations; RAG and grounding concepts; AI system evaluation and validation; deployment and observability concepts; and capstone architecture and defense expectations. This track leans hardest on the build-and-ship end of that spine: - Vertex AI and Gemini-based AI development workflows - RAG and grounding patterns - Cloud Run, GKE, or equivalent deployment pathways - Cloud Logging, Monitoring, and operational observability - Security, governance, and responsible AI controls (especially Secret Manager and IAM as applied to running services) - Capstone architecture documentation and final defense expectations ## Capstone artifact In Weeks 11 to 12, each learner designs and presents a production-aware AI-enabled software solution: a working prototype or agentic application, a RAG-enabled software prototype, or an equivalent AI-enabled service, with a deployment and monitoring plan. The capstone proves the learner can take an AI feature from idea to a state an enterprise team at the insurance company could review and run. Capstone scaffolding runs through the build weeks so Week 11 is not a cold start: Week 4 is a branch point where each learner steers the capstone toward a RAG-heavy, agentic, or service-heavy shape; Week 5 collects a one-page proposal; Week 7 runs a design review with a named section reviewer; the cumulative Weeks 1 to 10 artifact is the capstone seed rather than a separate Week-11 build. Required components: - Architecture diagram showing the application, its data sources, and its GCP services - GCP services used, with a short rationale for each choice - Role-specific implementation artifact: a working prototype, agentic workflow, or RAG-enabled software prototype, including prompt, retrieval, and tool orchestration design - Risk and validation evidence: testing and evaluation results showing the system behaves correctly and degrades safely - Security and governance considerations: secret handling, access control, responsible AI controls - Operational readiness: the deployment and monitoring plan, including logging, metrics, and failure response - Final presentation and defense of the design choices ## How learners are evaluated Evaluation uses the program-wide rubric shared across all four tracks: Applied Execution and Capstone Evidence 30%, Technical and AI Capability 25%, Cloud/GCP and Architecture Readiness 20%, Judgment/Validation/Critical Thinking 15%, and Engagement/Adoption/Professional Growth 10%. Evidence comes from weekly assignments, hands-on GCP labs, the capstone artifact, technical documentation, and the final defense, supplemented by SME evaluation, course assistant observations, peer and team feedback where appropriate, and a post-program applied skills assessment read against a Week-Zero applied diagnostic that sets each learner's baseline, so the program reports measured per-learner uplift rather than an absolute end-state score (see program-operations.md). The weights are shared, but this track's differentiators are scored as explicit anchors inside those dimensions. Under Technical and AI Capability, two anchors apply: evaluation rigor (a learner-built eval set of 20 to 30 cases scored by exact, semantic-similarity, and LLM-as-judge methods and wired as a CI gate) and agent reliability (step and budget caps, loop detection, tool-failure fallback, human escalation). Under Judgment, Validation, and Critical Thinking, AI-endpoint security is an anchor: prompt-injection and indirect-injection red-teaming of the learner's own endpoint plus enforced safety and PII controls with evidence each fires. ## Alignment with Google's recommended learning path The current Google industry-standard path for this role pairs two Google Cloud Skills Boost learning paths: [Build and Modernize Applications with Generative AI](https://www.skills.google/paths/1282), the app-developer generative AI path, plus the [Professional Cloud Developer Certification](https://www.skills.google/paths/19) path, which supplies the engineering backbone and aligns to the Professional Cloud Developer exam. For deeper retrieval, function calling, and responsible AI, Google adds [Advanced: Generative AI for Developers](https://www.skills.google/paths/183), and the sequence assumes [Introduction to Generative AI](https://www.skills.google/paths/118) as a prerequisite. This track maps onto those paths and overlaps the Professional Cloud Developer credential on its application-development and deployment domains, while going deeper on the engineering disciplines that path underweights. It is not a full exam prep track: several exam-blueprint domains (Cloud SQL, Firestore, App Engine, Cloud Tasks, and Apigee) are out of scope and need separate self-study. ### Skills map: client requirements vs. Google's path | Client-required skill area | Covered by Google's path? | Google course(s) | | --- | --- | --- | | AI-first software design patterns | Full | Gemini for Application Developers; Create Generative AI Apps on Google Cloud; Integrating Applications with Gemini on Google Cloud (path 19) | | Prompting, grounding, and RAG | Full | Create Generative AI Apps on Google Cloud; Vector Search and Embeddings; Inspect Rich Documents with Gemini Multimodality and Multimodal RAG (path 183) | | Agentic workflow design | Partial | Build Generative AI Agents with Vertex AI and Flutter; Accelerate App Development with Gemini CLI | | Tool and function calling and orchestration logic | Partial | Develop Gen AI Apps with Gemini and Streamlit (function calling); Service Orchestration and Choreography on Google Cloud (this is microservice orchestration, not LLM tool or function calling, so the LLM tool-calling depth is ours to own) | | API design for AI-enabled applications | Partial | Developing Applications with Google Cloud: Foundations; Developing Applications with Cloud Run Functions | | GCP-based deployment patterns | Full | Google Cloud Fundamentals: Core Infrastructure; Developing Applications with Cloud Run: Fundamentals; Deploy and Scale AI Models with Cloud Run | | Cloud Run, containers, CI/CD, and artifact management | Partial | Developing Containerized Applications on Google Cloud (Docker, Artifact Registry, Cloud Build); the Cloud Run courses (CI/CD coverage is light) | | Testing and evaluation of AI-enabled software | Partial | Gemini for End-to-End SDLC; MLOps with Vertex AI: Model Evaluation (no dedicated LLM evaluation harness) | | Observability, logging, and monitoring | Partial | Developing Applications: Foundations and the Cloud Run courses (Cloud Logging and Monitoring); no LLM-specific tracing, token, or cost observability | | Responsible AI, security, and operational guardrails | Partial | Responsible AI: Applying AI Principles with Google Cloud; Responsible AI for Developers: Interpretability and Transparency; Introduction to Security in the World of AI (path 1283). These are conceptual; hands-on AI-endpoint security (prompt-injection red-teaming, enforced safety filters, DLP PII redaction) is ours to own | ### Gaps we deliberately cover Google's app-developer path underweights several engineering disciplines this role depends on. Our curriculum owns each and names the week where it lands: - Systematic testing and evaluation of AI software (LLM eval harness, groundedness and hallucination checks): Week 8, a full week, where learners build an evaluation harness over a learner-built set of 20 to 30 insurance test cases, score output with exact match, semantic similarity, and an LLM-as-judge rubric, run a RAG faithfulness and context-relevance track, pin temperature 0 and seeds, and wire the harness as a CI gate that fails the build when groundedness or correctness drops below threshold; reinforced by Week 4, where RAG answers must return source citations. - LLM-specific observability (prompt tracing, token and cost monitoring): Week 9, where learners add a structured trace per request capturing prompt, retrieved context, tool calls, latency, and token count, with per-request cost attribution and alerts tied to cost and failure rate. - AI-endpoint security (prompt and indirect injection, insecure output handling, data exfiltration via tools, RAG PII leakage, OWASP LLM Top 10): Week 9, where learners red-team their own endpoint and add input and output filtering and allow-listed tool arguments, and Week 10, where they enforce Vertex AI safety filters at tested thresholds and DLP PII redaction with evidence each control fires. - CI/CD pipeline depth and artifact governance: Week 7, where learners wire a Cloud Build trigger that pushes a governed image to Artifact Registry and secures build artifacts inside the pipeline. - AI-specific API design (streaming, schemas, versioning, rate limiting): Week 6, where learners put the feature behind a resilient REST gateway with a streaming response path, a versioned request schema, and a rate limit, building on the typed contracts from Week 3, plus a first cost-and-latency optimization pass (caching layer, model-routing rule) measured before and after. - Formal multi-agent orchestration with reliability engineering (Agent Development Kit and Agent Engine, planner-executor patterns, guardrails for autonomous loops): Week 5, with ADK and Agent Engine and a planner-plus-tool two-agent workflow, plus agent reliability the same week: step and budget caps, loop detection, tool-failure retries with fallback, human-in-the-loop escalation, and one trajectory-level evaluation that the run terminated correctly. ### Certification as an optional outcome The Professional Cloud Developer certification is an optional graduation credential for learners who want external, industry-recognized validation of the engineering backbone. Weeks 6 and 7 (containerization, API design, and serverless deployment on Cloud Run; GKE depth and CI/CD delivery) overlap most directly with the [Professional Cloud Developer Certification](https://www.skills.google/paths/19) path. A learner who finishes the track has the application-build, deployment, and CI/CD foundations the exam tests, but the exam also covers data and managed-service domains this track does not (Cloud SQL, Firestore, App Engine, Cloud Tasks, and Apigee), so sitting it still requires focused self-study on those domains. ## Week-by-Week Curriculum Each week runs two learning cycles, one on Tuesday and one on Thursday, each with three parts in a fixed order. First, the assigned Google Cloud Skills Boost sub-module (roughly 45 minutes) is foundational pre-work done before the workshop; it is flexible-before, not pinned to a day. Second, the live applied workshop is the only time-fixed event: the trainer delivers it Tuesday and Thursday and applies the topic to the learner's own work at the end-client insurance company; it is recorded for catch-up. Third, the trainer-built lab is post-work done after the workshop, building something that solves a realistic insurance problem and encodes the skill; it is flexible-after. Thursday builds directly on Tuesday, so the two cycles form one self-contained weekly component. Components stack across Weeks 1 to 10, so a learner reaching Week 10 holds the full role-readiness stack; Weeks 11 to 12 are the capstone with no new Skills Boost assignment. The shared cross-track foundation (console fluency, identity, core cloud infrastructure and Cloud Storage, and AI plus GenAI grounding) is front-loaded in Week 1, which carries one extra short core-infrastructure module so every later build runs in a correctly scoped project with a Cloud Storage home for the RAG document corpus. Several assigned items are multi-hour courses; where so, only a single module is assigned. Where the parent course's own lab runs long (for example Vector Search and Embeddings at 4 hours, the ADK and Agent Engine course at 6 hours, or GKE Foundations at 24 hours), the pre-work is the concept and video portion of one module and the hands-on seat time lives in the trainer-built lab. This keeps pre-work near 45 minutes and the week inside the 8 to 10 hour budget. All links resolve on skills.google; legacy cloudskillsboost.google URLs permanently redirect. Every link opens the resource's Google Skills catalog page; labs launch from there and require the program's provided Skills Boost access. If a lab link shows a QL401 access-denied error, open it from the catalog page rather than as a direct launch link. ### Week 1: GCP foundations, identity, LLM behavior, and the responsible AI gate **Component focus:** Establish console, IAM, and core cloud infrastructure fluency (including a Cloud Storage home for the approved document corpus the later RAG weeks reuse) and a working model of how LLMs behave, then gate every AI feature with a responsible AI checklist before any code is written. This compresses two padded foundation weeks into one, freeing a week for evaluation, agent reliability, and AI-endpoint security later. **Estimated learner time this week: about 9 hours** (Tuesday cycle plus Thursday cycle plus 30 minute reflection; optional office hours not included). **Outcome (pitch to sponsor):** By the end of this week, your team can stand up a correctly scoped GCP project with least-privilege service accounts, provision a Cloud Storage bucket for the approved insurance document corpus the later RAG weeks reuse, size an LLM feature for token cost, latency, and failure modes, and gate it with a responsible-AI checklist before any code is written, so every later AI build runs on a secure, auditable foundation. | Day | Sub-module (pre-work, before workshop) | Applied workshop (live, fixed) | Trainer-built lab (post-work, after workshop) | | --- | --- | --- | --- | | Tuesday | [A Tour of Google Cloud Hands-on Labs](https://www.skills.google/focuses/2794?parent=catalog) (about 45 min) plus the Cloud Storage and core-infrastructure module of [Google Cloud Fundamentals: Core Infrastructure](https://www.skills.google/course_templates/60) (one module, from a 5 hr course; about 30 min); console navigation and Cloud Storage grounding. | Map projects, resources, roles, and permissions to how a service account is scoped for an application the insurance company ships (for example a claims-intake service), and orient on Cloud Storage and core infrastructure as where a RAG document corpus lives. (1 hr, live) | "Project and IAM warm-up plus corpus bucket": stand up a sandbox project, bind a least-privilege role to a service account for a claims-processing workload, and create a Cloud Storage bucket for the approved insurance document corpus the later RAG weeks reuse. Builds on: first GCP console login. (about 2.5 hr) | | Thursday | [Introduction to Large Language Models](https://www.skills.google/course_templates/539) (about 1 hr, full microlearning); the working model of what LLMs are, where they apply, and how prompt tuning shapes output. | Tokens, context windows, latency, and the failure modes an engineer must design around, then translating Google's AI principles into a concrete pre-code review gate for an insurance feature. (1 hr, live) | "Responsible AI pre-flight and token budget": draft a five-item responsibility checklist for a proposed claims-summarization feature and estimate its token cost and truncation risk. Builds on: Tuesday's sandbox project. (about 2 hr) | ### Week 2: Prompting and Vertex AI Studio **Component focus:** Move from ad hoc prompts to structured, version-controlled, testable prompt design. Basic prompting is review for this senior cohort, so the week is pitched at the Gemini-specific deltas and at treating prompts as tested engineering assets; the senior place-out applies (program-operations.md). **Estimated learner time this week: about 8 hours** (Tuesday cycle plus Thursday cycle plus 30 minute reflection; optional office hours not included). **Outcome (pitch to sponsor):** By the end of this week, your team can turn ad hoc prompts into versioned, source-controlled prompt templates and a reusable prompt-pattern library the team can test against, anchored on real insurance tasks like policy-document summarization. | Day | Sub-module (pre-work, before workshop) | Applied workshop (live, fixed) | Trainer-built lab (post-work, after workshop) | | --- | --- | --- | --- | | Tuesday | [Introduction to Vertex AI Studio](https://www.skills.google/course_templates/552) (one lab; about 45 min); the Vertex AI Studio prototyping surface. | Prototype a prompt in Studio for an insurance task (for example underwriting-note extraction), then identify exactly what must move out of the UI and into source control. (1 hr, live) | "Studio to repo": capture a working Studio prompt as a versioned prompt template in the repo. Builds on: Week 1 token budget. (about 2 hr) | | Thursday | [Prompt Design in Agent Platform](https://www.skills.google/course_templates/976) (one module; about 45 min; formerly Prompt Design in Vertex AI); core prompt-engineering and structured-output technique (including image-analysis and multimodal prompting). | Treat zero-shot, few-shot, chain-of-thought, and system instructions as version-controlled, testable engineering patterns, focusing on the Gemini-specific deltas (system-instruction handling and structured-output coupling) rather than prompt basics. (1 hr, live) | "Prompt pattern library v1": implement and label three prompt patterns against one insurance task. Builds on: Tuesday's versioned prompt template. (about 2 hr) | ### Week 3: The Gemini API and controlled, structured output **Component focus:** Call Gemini from code with the SDK, handle multimodal inputs, and enforce structured, schema-constrained output the way a real service would. Generic retry and timeout wrappers are review for this senior cohort, so the depth is on the Gemini-specific controlled-generation surface (response schemas, JSON mode, multimodal contracts); the senior place-out applies (program-operations.md), and reclaimed attention is reinvested in the Week 5 agent and Week 9 security builds. **Estimated learner time this week: about 8 hours** (Tuesday cycle plus Thursday cycle plus 30 minute reflection; optional office hours not included). **Outcome (pitch to sponsor):** By the end of this week, your team can call Gemini from production code behind a typed, retry-safe service wrapper, enforce controlled generation (response schemas, JSON mode) so output is machine-parseable, and expose a multimodal (text plus image) endpoint with a defined request and response contract. | Day | Sub-module (pre-work, before workshop) | Applied workshop (live, fixed) | Trainer-built lab (post-work, after workshop) | | --- | --- | --- | --- | | Tuesday | [Explore Generative AI in Agent Platform](https://www.skills.google/course_templates/959) (one lab; about 30 min; formerly Explore Generative AI with the Gemini API in Vertex AI); the first hands-on Gemini API call. | Wrap a Gemini SDK call behind a typed function with retries, timeouts, error handling, and controlled generation (response schema and JSON mode) so output is machine-parseable. (1 hr, live) | "Gemini service wrapper with schema": build a Python function that calls Gemini and returns schema-validated structured output for a claims field-extraction task. Builds on: Week 2 prompt pattern library. (about 2 hr) | | Thursday | [Build Real World AI Applications with Gemini and Imagen](https://www.skills.google/course_templates/1076) (one lab; about 1 hr); multimodal (text plus image) generation. | Design typed request and response shapes for a multimodal (text plus image) feature (for example reading a photo of accident damage alongside a claim description). Resilience, versioning, and rate limiting come in the Week 6 API week. (1 hr, live) | "Multimodal endpoint contract": define and stub an endpoint that accepts text plus an image and returns structured fields. Scope is the typed input and output shape only. Builds on: Tuesday's Gemini service wrapper. (about 2 hr) | ### Week 4: Grounding, embeddings, vector search, and RAG **Component focus:** Ground model output in approved insurance data with embeddings, Vertex AI Vector Search, and a RAG pipeline so answers cite sources instead of hallucinating, and measure retrieval quality. This week is the capstone branch point. **Estimated learner time this week: about 8.5 hours** (Tuesday cycle plus Thursday cycle plus the pattern-selection decision clinic plus 30 minute reflection; optional office hours not included). **Outcome (pitch to sponsor):** By the end of this week, your team can build a RAG pipeline over approved insurance documents (policy wordings, claims manuals) on Vertex AI Vector Search, return source citations instead of hallucinations, reason about indexing cost and query latency, and measure retrieval quality. | Day | Sub-module (pre-work, before workshop) | Applied workshop (live, fixed) | Trainer-built lab (post-work, after workshop) | | --- | --- | --- | --- | | Tuesday | [Vector Search and Embeddings](https://www.skills.google/course_templates/939) (one module, from a 4 hr course; about 45 min); the embeddings and Vertex AI Vector Search foundation. | Embeddings, the anatomy of a RAG pipeline (chunk, embed, index, retrieve, augment, generate) on Vertex AI Vector Search, and the indexing cost and query latency trade-offs of the vector store, inside an app you maintain. (1 hr, live) | "RAG pipeline skeleton on Vertex AI Vector Search": stand up a retrieve-then-generate flow over a small set of policy documents and record query latency against the pre-staged Vector Search index (pre-built for the cohort so lab time stays on retrieval, not provisioning; see program-operations.md). Builds on: Week 3 Gemini service wrapper. (about 2 hr) | | Thursday | [Inspect Rich Documents with Gemini Multimodality and Multimodal RAG](https://www.skills.google/course_templates/981) (about 45 min total, the short skill badge assigned in full); extends RAG to PDFs and scanned claims images. | Extend RAG to PDFs and scanned images (claims forms), return citations alongside every answer, and score retrieval quality (precision and recall of retrieved chunks). Close with a pattern-selection decision clinic at the capstone branch point: when to choose RAG versus an agent versus long-context versus fine-tuning for a given insurance problem. (1 hr, live) | "Cited multimodal answers with retrieval-quality check": return cited answers from a mixed text-and-image claims corpus and report retrieval precision and recall on a small labeled query set. Pick your capstone shape (RAG-heavy, agentic, or service-heavy) and record a short pattern-selection decision (RAG versus agent versus long-context versus fine-tuning) for your chosen insurance problem. Builds on: Tuesday's RAG pipeline skeleton. (about 2.5 hr) | ### Week 5: Tool and function calling, agentic orchestration, and reliability **Component focus:** Let the model call validated tools, compose them into orchestrated multi-step agentic logic, and engineer the agent to finish the task or terminate safely when it cannot. Learners submit a one-page capstone proposal. **Estimated learner time this week: about 8 hours** (Tuesday cycle plus Thursday cycle plus 30 minute reflection plus capstone proposal; optional office hours not included). **Outcome (pitch to sponsor):** By the end of this week, your team can let a model safely call validated tools and compose a planner-and-tool two-agent workflow that completes a multi-step insurance task (for example triaging a claim) end to end, or terminates safely with a human escalation. | Day | Sub-module (pre-work, before workshop) | Applied workshop (live, fixed) | Trainer-built lab (post-work, after workshop) | | --- | --- | --- | --- | | Tuesday | [Develop Gen AI Apps with Gemini and Streamlit](https://www.skills.google/course_templates/978) (one function-calling lab; about 45 min); model function and tool calling. | Define function schemas and execute model-selected calls safely, validating and allow-listing arguments before they hit real code (for example a fraud-signal lookup), carrying controlled generation forward from Week 3. (1 hr, live) | "Function-calling tool registry": register two tools (for example a policy lookup and a fraud-signal check) and route a model-chosen call to real code with validated, allow-listed arguments. Builds on: Week 4 RAG pipeline. (about 2 hr) | | Thursday | [Deploy Multi-Agent Systems with Agent Development Kit (ADK) and Agent Engine](https://www.skills.google/course_templates/1275) (build-an-agent module only, from a 6 hr course; about 1 hr); ADK and Agent Engine multi-agent patterns. | Parent and child agent flows, multi-turn state and context-window budgeting across steps, and agent reliability engineering: step and budget caps, loop detection, tool-failure retries with fallback, and human-in-the-loop escalation. (1 hr, live) | "Reliable two-agent workflow": compose a planner agent and a tool agent that hand off one claims-triage task, with a step budget, a loop guard, tool-failure retries with fallback, a human escalation path, and one trajectory-level evaluation that the run terminated correctly. The agent skeleton with stubs is pre-staged for the cohort so freed lab time goes to reliability engineering, not boilerplate (see program-operations.md). Builds on: Tuesday's tool registry. (about 2 hr) | ### Week 6: API design, containerization, and serverless deployment on Cloud Run **Component focus:** Containerize the AI feature, put it behind a real API, deploy it serverlessly on Cloud Run with secrets handled correctly, and add a first cost-and-latency optimization pass (caching, model routing) measured before and after. **Estimated learner time this week: about 9 hours** (Tuesday cycle plus Thursday cycle plus 30 minute reflection; optional office hours not included). A genuinely heavier week, budgeted at the top of the range. **Outcome (pitch to sponsor):** By the end of this week, your team can containerize and deploy the AI feature as a Cloud Run service behind a resilient API (streaming, a versioned schema, rate limiting, secret-managed keys, graceful degradation), and cut cost and perceived latency with a caching layer and a model-routing rule measured before and after. | Day | Sub-module (pre-work, before workshop) | Applied workshop (live, fixed) | Trainer-built lab (post-work, after workshop) | | --- | --- | --- | --- | | Tuesday | [Docker Essentials: Containers and Artifact Registry](https://www.skills.google/focuses/127756?parent=catalog) (about 45 min); container build, run, and publish to Artifact Registry (Secret Manager is introduced in the workshop and lab, not this module). | Container fundamentals (build, run, publish a Docker image), Cloud Run service identity, and pulling secrets from Secret Manager instead of env files. (1 hr, live) | "Containerize the AI service": build a Docker image for the Week 5 agent, push it to Artifact Registry, wire a Secret Manager-backed key, and deploy a first Cloud Run revision. Builds on: Week 5 reliable two-agent workflow. (about 2 hr) | | Thursday | [Develop Serverless Applications on Cloud Run](https://www.skills.google/course_templates/741) (one lab; about 45 min); the Cloud Run serverless deployment model. | REST API design for AI endpoints: streaming responses for perceived latency, request schema versioning, rate limiting, asynchronous patterns with Pub/Sub, Identity-Aware Proxy and context-aware access in front of the endpoint, and explicit fallback behavior, plus a cost-and-latency optimization pass: a caching layer and a model-routing decision measured before and after. (1 hr, live) | "Resilient API contract with a cost-and-latency pass": add a REST gateway with a streaming response path, a versioned request schema (extending the typed contract from Week 3), a rate limit, and a graceful-degradation path to the deployed service, then add a caching layer and a model-routing rule and report before-and-after cost and latency. Builds on: Tuesday's Cloud Run revision. (about 3 hr) | ### Week 7: Containers at scale, GKE depth, CI/CD delivery, and capstone design review **Component focus:** Know when GKE fits instead of Cloud Run, automate build, artifact storage, and release, and pass a capstone design review using the artifact so far. **Estimated learner time this week: about 8 hours** (Tuesday cycle plus Thursday cycle plus 30 minute reflection; optional office hours not included). **Outcome (pitch to sponsor):** By the end of this week, your team can make a defensible Cloud Run versus GKE call and ship the service through an automated Cloud Build pipeline that pushes governed artifacts to Artifact Registry. | Day | Sub-module (pre-work, before workshop) | Applied workshop (live, fixed) | Trainer-built lab (post-work, after workshop) | | --- | --- | --- | --- | | Tuesday | [Architecting with Google Kubernetes Engine: Foundations](https://www.skills.google/course_templates/32) (containers and Kubernetes architecture module only, from a 24 hr course; about 1 hr); GKE container-orchestration architecture. | Cloud Run versus GKE decision criteria for an AI workload, judged on scaling, cost, and operational load. (1 hr, live) | "Deployment target decision record plus capstone design review": write a short architecture decision record choosing Cloud Run or GKE for the service, then present a capstone design review of the Weeks 1 to 6 artifact (the capstone seed) to your section's assigned reviewer (the section SME or course assistant) in a scheduled slot, receiving written rubric-anchored feedback that mirrors the Weeks 11 to 12 defense panel (cohorting and reviewer staffing per program-operations.md). Builds on: Week 6 deployed service. (about 2 hr) | | Thursday | [Implement CI/CD Pipelines on Google Cloud](https://www.skills.google/course_templates/691) (multi-lab skill badge covering Cloud Build, Artifact Registry, and Cloud Deploy; the catalog headline reads about 30 min, but the full badge runs several labs, on the order of 3.5 hr of hands-on, so only the introductory concept and overview module is assigned as pre-work, about 45 min, and the deeper multi-lab pipeline seat time, vulnerability scanning, release attestation, and the Cloud Deploy promotion labs, is deferred to the trainer-built lab); Cloud Build, Artifact Registry, and Cloud Deploy patterns. | Cloud Build steps, Artifact Registry, securing build artifacts inside the pipeline, and promoting a release across dev, stage, and prod environments. (1 hr, live) | "Build-to-registry pipeline": wire a Cloud Build trigger that pushes a governed image to Artifact Registry and deploys it, starting from the pre-staged Cloud Build pipeline (with Workload Identity Federation) provisioned for the cohort (see program-operations.md). Builds on: Tuesday's deployment target decision. (about 2 hr) | ### Week 8: Evaluation of AI software **Component focus:** Prove the AI feature behaves correctly with a learner-built evaluation harness that becomes a CI gate. Evaluation is a full week because the assigned platform courses do not ship a build-your-own LLM evaluation harness, so the learner builds one. **Estimated learner time this week: about 8 hours** (Tuesday cycle plus Thursday cycle plus 30 minute reflection; optional office hours not included). **Outcome (pitch to sponsor):** By the end of this week, your team can build an evaluation harness over a learner-built set of 20 to 30 insurance test cases that scores output with exact, semantic-similarity, and LLM-as-judge methods, runs a RAG faithfulness and context-relevance track, handles non-determinism reproducibly, and fails the build when groundedness or correctness drops below threshold. | Day | Sub-module (pre-work, before workshop) | Applied workshop (live, fixed) | Trainer-built lab (post-work, after workshop) | | --- | --- | --- | --- | | Tuesday | [Machine Learning Operations (MLOps) with Vertex AI: Model Evaluation](https://www.skills.google/course_templates/1080) (generative-evaluation module, from a 2.5 hr course; about 45 min); generative-model evaluation methods. | Build an evaluation set for your own app output: assemble 20 to 30 labeled insurance cases (claims questions with approved answers) and score with exact match, semantic similarity, and an LLM-as-judge rubric. (1 hr, live) | "Eval set and multi-method scoring": build a 20 to 30 case eval set for the RAG or agent feature and score it with exact, semantic, and judge methods. Builds on: Week 7 delivered service. (about 2 hr) | | Thursday | [Machine Learning Operations (MLOps) with Vertex AI: Model Evaluation](https://www.skills.google/course_templates/1080) (a second evaluation-metrics module; about 45 min); evaluation-metrics grounding. | RAG faithfulness, context relevance, and groundedness; handling non-determinism with temperature 0 and fixed seeds; and wiring the harness as a CI regression gate. (1 hr, live) | "Eval harness as a CI gate": add RAG faithfulness and groundedness scoring, pin temperature 0 and seeds for reproducibility, and wire the harness into the Cloud Build pipeline so a groundedness or correctness regression fails the build. Builds on: Tuesday's eval set. (about 2 hr) | ### Week 9: LLM observability and AI-endpoint security **Component focus:** Make the feature's behavior, cost, and latency observable with a focused per-request trace, then give AI-endpoint security the larger share of the week to harden the endpoint against prompt injection and abuse. The cost-and-latency optimization pass moved to Week 6, so this week is two focused deliverables, not three crammed ones. **Estimated learner time this week: about 9 hours** (Tuesday cycle plus Thursday cycle plus 30 minute reflection; optional office hours not included). A genuinely heavier week, budgeted at the top of the range, with security weighted over observability. **Outcome (pitch to sponsor):** By the end of this week, your team can instrument the feature so a per-request trace captures prompt, context, tool calls, latency, and tokens with cost attribution and alerts, and red-team the AI endpoint against prompt injection, indirect injection, data exfiltration via tools, and RAG PII leakage against the OWASP LLM Top 10. | Day | Sub-module (pre-work, before workshop) | Applied workshop (live, fixed) | Trainer-built lab (post-work, after workshop) | | --- | --- | --- | --- | | Tuesday | [Monitor and Log with Google Cloud Observability](https://www.skills.google/course_templates/749) (one lab; about 45 min); the Cloud Logging and Monitoring foundation. | LLM-specific observability: a structured trace per request capturing prompt, retrieved context, tool calls, latency, and token count, with per-request cost attribution and alerts tied to cost and failure rate. (The cost-and-latency optimization pass moved to Week 6.) (1 hr, live) | "Prompt-trace instrumentation": add a per-request prompt trace with token and cost attribution and one cost or failure-rate alert. Builds on: Week 8 eval harness. (about 2 hr) | | Thursday | [Introduction to Security in the World of AI](https://www.skills.google/course_templates/1147) (about 1 hr); the AI-specific risk framework. | AI-endpoint security: prompt injection and indirect (data-borne) injection, insecure output handling for tool-calling agents, data exfiltration via tools, and RAG PII leakage, mapped to the OWASP LLM Top 10. (1 hr, live) | "Red-team your endpoint": run a set of prompt-injection, indirect (data-borne) injection, data-exfiltration-via-tools, and RAG PII-leakage attacks against your own service, add input and output filtering and allow-listed tool arguments, verify each control fires on a crafted input, and document findings against the OWASP LLM Top 10. Builds on: Tuesday's instrumented service. (about 2.5 hr) | ### Week 10: Responsible AI enforcement, safety guardrails, and release readiness **Component focus:** Enforce safety and privacy controls technically with tested evidence, and assemble the release-readiness pack for sign-off. **Estimated learner time this week: about 8 hours** (Tuesday cycle plus Thursday cycle plus 30 minute reflection; optional office hours not included). **Outcome (pitch to sponsor):** By the end of this week, your team can ship the feature with enforced Vertex AI safety filters at tested thresholds, DLP-based PII redaction in the RAG path, and a human-in-the-loop escalation trigger (each with evidence it fires), plus a release-readiness pack (model card, Secret Manager and IAM review) ready for enterprise sign-off. | Day | Sub-module (pre-work, before workshop) | Applied workshop (live, fixed) | Trainer-built lab (post-work, after workshop) | | --- | --- | --- | --- | | Tuesday | [Responsible AI: Applying AI Principles with Google Cloud](https://www.skills.google/course_templates/388) (one module only, from a 2 hr course; about 45 min); Google's AI principles as an enforced-control mindset. | Turn AI principles into enforced controls: Vertex AI safety filters at tested thresholds, citation and grounding enforcement, DLP-based PII redaction for the RAG path, and a human-in-the-loop escalation trigger. (1 hr, live) | "Enforced guardrails with evidence": configure Vertex AI safety filters at a tested threshold, add DLP PII redaction to the RAG path, and add a human escalation trigger, with a test that shows each control fires on a crafted input. Builds on: Week 9 red-team findings. (about 2 hr) | | Thursday | [Responsible AI for Developers: Interpretability & Transparency](https://www.skills.google/course_templates/989) (one module only, from a 3 hr course; about 45 min); interpretability and transparency grounding. | Interpretability, transparency, and assembling a model or feature card and an operational sign-off pack for enterprise review. (1 hr, live) | "Release readiness pack": assemble a model card, a Secret Manager and IAM review note, and the deployment and monitoring plan for handoff to the insurance company's review board. Builds on: Tuesday's enforced guardrails. (about 2 hr) | ### Weeks 11 to 12: Capstone No new Skills Boost sub-module is assigned. Learners apply the accumulated Weeks 1 to 10 stack (prompt design, controlled generation, grounding with embeddings and vector search and RAG, tool and function calling, agentic orchestration with reliability engineering, API design, containerization and Cloud Run deployment, GKE judgment, CI/CD with Cloud Build and Artifact Registry, secrets and IAM, an evaluation harness wired as a CI gate, LLM observability, AI-endpoint security, and enforced responsible AI guardrails) to a single production-aware AI-enabled software solution: a working prototype, an agentic application, or a RAG-enabled software prototype, delivered with a deployment and monitoring plan and defended in the final presentation. The artifact carried through Weeks 1 to 10 is the capstone seed, so these weeks deepen and defend it rather than start a new build. ### Sources All items below were verified by fetching the page and confirming the title matches. None are unverified. Listed in week order. - [A Tour of Google Cloud Hands-on Labs](https://www.skills.google/focuses/2794?parent=catalog) (Week 1; lab GSP282; Introductory; about 45 minutes of lab access; assigned in full) - [Google Cloud Fundamentals: Core Infrastructure](https://www.skills.google/course_templates/60) (Week 1; Introductory; about 5 hours total, verified on the live page; only the Cloud Storage and core-infrastructure module assigned, about 30 minutes; provides the Cloud Storage and core-infrastructure foundation for the document corpus the RAG weeks reuse) - [Introduction to Large Language Models](https://www.skills.google/course_templates/539) (Week 1; Introductory; about 1 hour; assigned in full) - [Introduction to Vertex AI Studio](https://www.skills.google/course_templates/552) (Week 2; Introductory; about 2 hours total; only one lab assigned, about 45 minutes) - [Prompt Design in Agent Platform](https://www.skills.google/course_templates/976) (Week 2; Introductory skill badge; about 1 hour total; only one module assigned, about 45 minutes; the live page title now reads "Agent Platform", this is the rebranded "Prompt Design in Vertex AI") - [Explore Generative AI in Agent Platform](https://www.skills.google/course_templates/959) (Week 3; Intermediate skill badge; about 30 minutes; rebranded from "Explore Generative AI with the Gemini API in Vertex AI") - [Build Real World AI Applications with Gemini and Imagen](https://www.skills.google/course_templates/1076) (Week 3; Introductory skill badge; about 1 hour; one lab assigned) - [Vector Search and Embeddings](https://www.skills.google/course_templates/939) (Week 4; Intermediate; about 4 hours total; only one module assigned, about 45 minutes; covers embeddings, Vertex AI Vector Search, and RAG) - [Inspect Rich Documents with Gemini Multimodality and Multimodal RAG](https://www.skills.google/course_templates/981) (Week 4; Intermediate skill badge; about 45 minutes total, verified on the live page; assigned in full, about 45 minutes) - [Develop Gen AI Apps with Gemini and Streamlit](https://www.skills.google/course_templates/978) (Week 5; Intermediate skill badge; about 1 hour total; only one function-calling lab assigned, about 45 minutes) - [Deploy Multi-Agent Systems with Agent Development Kit (ADK) and Agent Engine](https://www.skills.google/course_templates/1275) (Week 5; Advanced; about 6 hours total; only the build-an-agent module assigned, about 1 hour) - [Docker Essentials: Containers and Artifact Registry](https://www.skills.google/focuses/127756?parent=catalog) (Week 6; lab gem-docker-basics; Introductory; about 30 minutes of lab access (about 1 hour total engagement), verified on the live page; assigned in full, about 45 minutes of seat time; covers Docker build, run, and publish to Artifact Registry; does not cover Secret Manager) - [Develop Serverless Applications on Cloud Run](https://www.skills.google/course_templates/741) (Week 6; Intermediate; about 1 hour 15 minutes total; only one lab assigned, about 45 minutes) - [Architecting with Google Kubernetes Engine: Foundations](https://www.skills.google/course_templates/32) (Week 7; Intermediate; about 24 hours total; only the containers and Kubernetes architecture module assigned, about 1 hour, concept and video portion as pre-work) - [Implement CI/CD Pipelines on Google Cloud](https://www.skills.google/course_templates/691) (Week 7; Intermediate multi-lab skill badge covering Cloud Build, Artifact Registry, and Cloud Deploy across GKE and Cloud Run, including vulnerability scanning and release attestation; the catalog headline reads about 30 minutes, verified on the live page, but completing the full multi-lab badge runs on the order of 3.5 hours of hands-on; only the introductory concept and overview module is assigned as pre-work, about 45 minutes, with the deeper multi-lab pipeline seat time deferred to the trainer-built lab) - [Machine Learning Operations (MLOps) with Vertex AI: Model Evaluation](https://www.skills.google/course_templates/1080) (Week 8; Intermediate; about 2 hours 30 minutes total; two evaluation modules assigned across the week, about 45 minutes each; covers generative-model evaluation) - [Monitor and Log with Google Cloud Observability](https://www.skills.google/course_templates/749) (Week 9; Introductory skill badge; about 1 hour 15 minutes total; only one lab assigned, about 45 minutes) - [Introduction to Security in the World of AI](https://www.skills.google/course_templates/1147) (Week 9; Introductory; about 1 hour; assigned in full; provides the AI-specific risk framework, path 1283) - [Responsible AI: Applying AI Principles with Google Cloud](https://www.skills.google/course_templates/388) (Week 10; Introductory; about 2 hours total; only one module assigned, about 45 minutes) - [Responsible AI for Developers: Interpretability & Transparency](https://www.skills.google/course_templates/989) (Week 10; Intermediate; about 3 hours total; only one module assigned, about 45 minutes) ## Delivery operations annex (cohort of 265) Running this track for 265 software engineers is a logistics problem as much as a curriculum one. Program-wide operational conditions (the Week-Zero baseline, catch-up reference snapshots, data and asset provisioning, environment pre-staging at 265 learners, time realism, cohorting and grading staffing, and the senior place-out) are owned by program-operations.md; the track-specific logistics below sit on top of it, planned before the cohort starts so no learner is blocked at lab time and cost stays controlled: - GCP project provisioning and quota: each learner receives a sandbox project from a pre-provisioned pool, with Vertex AI, Cloud Run, Vector Search, and Artifact Registry quota requested ahead of Week 1 so the Week 1 labs are not gated by quota approval. - Per-learner spend caps and billing alerts: every sandbox project carries a hard budget cap and a billing alert, with a daily cost rollup across all 265 projects so runaway spend (for example an agent loop calling a model in Week 5, before the step and budget caps are in place) is caught the same day. - Lab-support staffing: course assistants are staffed to a target ratio so the two weekly lab windows for 265 learners have live help, with an SME escalation path for platform issues. - Grading and capstone defenses: the 265 capstone defenses in Weeks 11 to 12 are scheduled across parallel panels with a shared rubric and a calibration session so scoring is consistent, and the weekly artifact serving as the capstone seed spreads evaluation load across the term rather than concentrating it at the end.