CHAPTERS
- 0:05 – 1:07
Session goal: use Claude on Google Cloud to build and deploy end-to-end
Ivan Nardini sets the stage by asking who has used AI to code and who has used AI to deploy on Google Cloud. He frames the talk as an end-to-end demo showing how Claude on Google Cloud can cover both building and deployment workflows.
- •Audience poll on AI coding vs AI deployment on Google Cloud
- •Objective: make end-to-end build+deploy with AI easier
- •Preview of a live demo approach rather than theory
- 1:07 – 2:37
Mapping the enterprise SDLC personas Claude can augment
The talk introduces a typical enterprise team workflow—PM to designer to engineer to security to analytics. This persona map becomes the structure for the rest of the demo as Ivan “wears” each hat in sequence.
- •PM ideation and requirements handoff
- •UI/UX prototyping and interface implementation
- •Software engineering, security review, and post-launch analytics feedback loop
- •Claude Code positioned as augmenting each persona
- 2:37 – 3:39
What you’re building: a simple feedback app as the running example
Ivan explains that the demo will produce a lightweight feedback application that attendees can use to rate the session. The app serves as a concrete thread to demonstrate Claude Code components across the lifecycle.
- •End goal: a feedback app used live during the session
- •Demonstrates multiple Claude Code capabilities in one project
- •Ties development steps to realistic enterprise roles
- 3:39 – 4:40
Setting up Claude Code with Claude models on Google Cloud (ADC + wizard)
Ivan walks through the simplest setup path: Application Default Credentials (ADC). He highlights a newer configuration wizard that detects the GCP project/region, lists available models, and lets you pin a model to start building quickly.
- •Fastest integration path: Application Default Credentials
- •Wizard flow: detect project and region, discover available models, pin model
- •Reduced friction vs manual key/variable management
- 4:40 – 6:41
Why run Claude via Google Cloud: pricing, throughput, governance, and regions
He contrasts using Claude models on Google Cloud with other ways of accessing models. Benefits emphasized include token-based pay-as-you-go (no message caps), enterprise throughput provisioning, simplified credentialing, and data/policy controls within your project.
- •Per-token usage (no message cap) and optional provisioned throughput
- •No API key rotation; straightforward authentication via ADC
- •Enterprise controls: policies and data staying in your project
- •Global vs regional endpoints and Google Cloud availability/infrastructure
- 6:41 – 8:44
PM workflow: turn a sketch into a clickable prototype with Claude Code
Wearing the PM hat, Ivan shows how a rough drawing can be turned into a rendered prototype quickly. He positions this as a major time-saver versus traditional back-and-forth with design to get an initial wireframe.
- •Input can be a simple hand-drawn sketch
- •Claude Code renders a prototype rapidly from minimal artifacts
- •Accelerates early validation and reduces iteration time
- 8:44 – 11:18
UI/UX workflow: use Plan Mode to implement a production-ready interface
Shifting to the UI/UX role, Ivan expands the prototype into a more solid UI with multiple pages (landing, thank-you, and a live dashboard). He introduces Plan Mode so Claude proposes an implementation plan before writing code, enabling review and alignment (e.g., with Figma/design docs).
- •Target UI: landing page, submission/thank-you, and dashboard view
- •Plan Mode: think-first, propose steps, then implement after approval
- •Simulated Figma/design-doc inputs guiding UI decisions
- •Clear shift from rough prototype to polished UI
- 11:18 – 12:49
Software engineer workflow: GCP architecture via MCP + Developer Knowledge API + Skills
Ivan addresses the common gap: building code is easy, deploying to cloud services can be unfamiliar. He introduces Google Cloud’s Developer Knowledge API (fresh docs via an MCP server) plus Google Cloud Skills that guide implementation of specific building blocks.
- •Developer Knowledge API + MCP server: up-to-date GCP docs inside Claude Code
- •Google Cloud Skills: reusable implementation recipes (e.g., deploy to Cloud Run, connect to Firestore)
- •Claude helps design architecture and fill in service-level details
- •Goal: deploy without deep prior GCP expertise
- 12:49 – 14:52
Reference architecture for the feedback app: Cloud Run + Firestore + BigQuery + Looker
He outlines a practical cloud-native architecture: a serverless API on Cloud Run, Firestore for operational storage, BigQuery for analytics, and Looker for dashboards. The message is that Claude Code, paired with Google Cloud tooling, can assemble this stack quickly and correctly.
- •Cloud Run for the serverless backend/API
- •Firestore to collect raw feedback responses
- •BigQuery for analytical warehousing and post-processing
- •Looker for dashboarding and reporting
- •Designed to support both live feedback and downstream analytics
- 14:52 – 16:52
Parallel build with subagents: implement API, ingestion pipeline, and dashboard components
Ivan demonstrates spinning up multiple Claude Code subagents to build different parts of the system concurrently—mirroring how teams run sprints in parallel. He notes Claude Code also handles testing once implementation completes.
- •Subagents split workstreams (API, ingestion, dashboard)
- •Parallelization speeds delivery vs sequential coding
- •Testing is incorporated after implementation
- •Result: codebase ready for deployment
- 16:52 – 19:28
Security engineer workflow: automated review (OWASP + IAM/service accounts) then deployment
Before exposing the app publicly, Ivan runs a security review with a prebuilt Claude Code security workflow. The system flags an issue, fixes it, and then proceeds to deploy the backend to Cloud Run, producing a live endpoint.
- •Security checks include common OWASP concerns and cloud IAM principles
- •Service account permissions should be scoped to least privilege
- •Claude Code security review finds and auto-fixes issues
- •Automated path from “secure enough” to deployed service
- 19:28 – 20:46
Live demo: the deployed feedback app updates in real time and summarizes comments
Ivan shows the running Cloud Run app and collects a live score and comment from the audience. The dashboard updates immediately, and a “feedback analyzer” calls Claude on Google Cloud to generate an automatic summary of received feedback.
- •Cloud Run-hosted app is live on GCP
- •Audience submits rating and comment; metrics update in real time
- •Feedback analyzer invokes Claude to summarize comments
- •Demonstrates end-to-end UX from input → storage → analysis
- 20:46 – 24:19
Post-launch analytics: BigQuery + Looker via MCP servers and the Agent Platform registry
He closes the loop with the analytics persona: collected metrics like response time can drive product improvements. Ivan points to Google Cloud’s Agent Platform/Agent Registry for supported MCP servers (including BigQuery) and mentions an open-source MCP toolbox that integrates with Looker, with code to be released for attendees to extend.
- •Use KPIs (e.g., response time) to guide iteration
- •Agent Platform/Agent Registry lists supported MCP servers on GCP
- •BigQuery MCP server enables querying collected app data
- •Open-source MCP toolbox includes Looker integration with quickstart docs
- •Attendees can extend the sample once code is published
- 24:19 – 26:29
Wrap-up: combining Claude Code components with Claude on GCP for a seamless workflow
Ivan summarizes the core takeaway: skills, MCP servers, and subagents meaningfully accelerate the software development lifecycle across roles. He reiterates that setup and usage on GCP are straightforward and points viewers to the code, quickstarts, and documentation for follow-up.
- •Claude Code components (skills, MCP, subagents) accelerate SDLC tasks
- •Claude on GCP provides a smooth enterprise-ready experience
- •Code release, quickstart resources, and docs on both Google Cloud and Anthropic sides
- •Invitation for questions and feedback
