Build and Deploy an App on Google Cloud with Claude Code in 30 Minutes

Title

Build and Deploy an App on Google Cloud with Claude Code in 30 Minutes

Meta Description

Google Cloud developer advocate Ivan Nardini demonstrates how to build and deploy a feedback app with Claude Code and Google Cloud in 30 minutes, covering plan mode, MCP servers, Skills, parallel sub-agent development, and security review — showing how AI coding agents span the enterprise software development lifecycle.

Article Content

In a tech talk on Bilibili, Google Cloud developer advocate Ivan Nardini demonstrated how to build and deploy a feedback app with Claude Code and Google Cloud in just 30 minutes. The demo is more than a chain of tools — it reveals how AI-assisted development is reshaping the entire enterprise software delivery pipeline.

One Demo, Five Hats: How AI Spans the Software Lifecycle

Ivan opened with a concrete scenario: in typical enterprise development, a product manager comes up with the idea, a UI/UX designer builds the prototype, a software engineer implements the logic, a security engineer reviews risks, and a data analyst mines insights — five roles interlocked, which also means repeated communication and handoff costs.

Claude Code's positioning is precisely to "augment" these five roles. In the demo, Ivan successively put on the hats of product manager, designer, engineer, security engineer, and data analyst, completing the entire flow from sketch to deployment with the same tool. This "one person playing multiple roles" approach vividly illustrates how AI coding agents compress team collaboration patterns.

A detail worth noting: the audience interaction revealed a key insight — most people already use AI tools to write code, but only a few have used the same tool to complete a deployment. This is exactly the capability gap the talk aims to bridge — from "it runs locally" to "it works in the cloud."

Why Run Claude Models on Google Cloud

Before getting hands-on, Ivan first answered the question "why use Claude models on Google Cloud?" His reasons centered on several pain points of enterprise-grade requirements:

• Token-based billing, with no cap on message count;
• Provisioned throughput to reserve capacity for production-grade applications;
• Application Default Credentials (ADC) automatically discover credentials, eliminating API key rotation or environment variable management;
• Models are served in multiple regions, supporting global and regional endpoints;
• Data stays in your own project, governed by your own policies.

Configuration was also greatly simplified: the built-in Claude Code wizard automatically identifies the project, region, and available models — users just need to "pin" the model they want and start building. For enterprises that need to use AI within compliance frameworks, the appeal of this combination is that "you don't need to build a separate credential and governance system just to use a model."

Provisioned throughput is a capacity guarantee mechanism in cloud model services. Under on-demand billing, requests share a compute pool with other tenants, and peak times can cause queuing or rate limiting. Provisioned throughput lets enterprises reserve fixed model inference capacity per unit time, similar to "reserved instances" in databases or "dedicated bandwidth" in networking. For production-grade applications, this means predictable latency and throughput that won't fluctuate due to sudden spikes in neighbor traffic; the trade-off is paying for idle capacity, making it more suitable for stable workloads or scenarios with clear SLA requirements. Claude models on Google Cloud also support two access methods — global endpoints and regional endpoints — the former routing to the nearest available region to reduce latency, while the latter satisfies data residency and compliance requirements.

Application Default Credentials (ADC) is a unified identity discovery mechanism for Google Cloud client libraries. Code doesn't need to hardcode API keys or service account files — ADC looks up credentials in a fixed order: the file pointed to by the GOOGLE_APPLICATION_CREDENTIALS environment variable, the local gcloud CLI login state, and the built-in service account when running in GCE/Cloud Run/GKE environments. This lets the same code authenticate without modification across local development, CI pipelines, and cloud runtime, while also avoiding API key rotation and leak risks.

From Napkin Sketch to Interactive Prototype

In the first phase of the demo, Ivan played the product manager. He uploaded a hand-drawn sketch — "drawn while having coffee in San Francisco," as he put it — and specified his identity and intent in Claude.md: render a wireframe prototype of the app from the image for the designer to use later. Within minutes, Claude generated a presentable prototype.

The significance of this step isn't the rendering itself, but cutting out the "describe — rework — describe again" loop between product manager and designer. The sketch's ambiguity is filled in by AI into structured interface language, significantly reducing communication costs.

Then the UI/UX designer took the stage. This time the goal was a production-ready three-page app: a landing page, a thank-you page, and a real-time feedback dashboard. Ivan enabled plan mode — letting Claude think and lay out an implementation plan before writing code. He simulated receiving design documents through a Figma MCP server; after the plan was listed, a human confirmed it, and Claude then executed the implementation. Ultimately, a usable interface was iterated from the wireframe.

From the Engineer's Perspective: Deploy Without Knowing Google Cloud

The third hat belongs to the software engineer. Here Ivan pointed out a common dilemma: the frontend is done, but you don't know how to deploy to Google Cloud. His solution involved two newly released components:

The Developer Knowledge API and its MCP server, which let Claude Code directly consume the latest Google Cloud documentation and determine the best architecture on its own. The architecture chosen in the demo was: the feedback API deployed on Cloud Run serverless service, Firestore collecting raw feedback, raw data synced to BigQuery for analysis, and finally a dashboard presented in Looker.

Google Cloud Skills cover individual implementation modules within the architecture, such as "deploy the API to Cloud Run" or "connect Cloud Run with Firestore." The MCP server provides the big picture; Skills fill in execution details.

A further mechanism is the sub-agent. Ivan launched three sub-agents simultaneously, responsible for the API, the data ingestion pipeline, and the dashboard, driving implementation in parallel — like task decomposition within a single sprint. After implementation, Claude also automatically took over testing.

MCP (Model Context Protocol) is an open protocol that lets AI coding agents connect to external tools and data sources in a standardized way. Think of an MCP server as "a plugin for the model": each server exposes a set of tools and resources with machine-readable descriptions; Claude Code discovers these capabilities at runtime and invokes them as needed. Compared with traditional function calling, MCP's value lies in ecosystem reuse — the same BigQuery MCP server can be used by any MCP-supporting client, with no need to write separate integration code for each AI tool. This is also why the Developer Knowledge API, BigQuery, and Looker can be integrated into Claude Code in a unified way in this article.

Sub-agent is a task delegation mechanism in Claude Code. The main agent can hand off a well-bounded, context-independent subtask to a sub-agent, which has its own conversation context and tool permissions and returns only a result summary to the main agent upon completion. This has two benefits: first, parallelism — multiple sub-agents can simultaneously handle mutually independent modules like the API, data pipeline, and dashboard; second, isolation — the intermediate process of subtasks won't blow up the main conversation's context window. The cost is that a human or the main agent must break down tasks well and ensure sub-agent outputs are consistent at the interface level.

Security Review and One-Click Deployment

Once the application code was ready, the fourth hat was the security engineer. Ivan used the built-in security review process in Claude Code to check for common OWASP issues and limit the service account's permission scope — for example, ensuring database read/write operations are constrained by rules. In the demo, Claude ran the first round of testing, found a potential issue and fixed it automatically, then deployed the backend API and frontend.

The final deliverable was a real-time endpoint on Cloud Run. The live audience rated the talk, and after submission the dashboard updated in real time with response counts, ratings, and visual charts. Ivan also built in a feedback analyzer that calls Claude models on Google Cloud to generate summaries from the comments.

OWASP (Open Web Application Security Project) is a nonprofit organization whose OWASP Top 10 lists the most common categories of web application security risks, such as injection attacks, broken access control, security misconfiguration, and sensitive data exposure. It is not an executable checklist but an industry-consensus risk classification framework, which is why it's often used as the "check dimension" for security review processes. In the context of AI-assisted development, codifying OWASP categories into automatically executable review steps means security checks shift from manual review before release to routine actions during coding; note, however, that automated review mainly covers pattern-based issues — business logic vulnerabilities and the soundness of permission design still require human judgment.

The Final Piece: Data Analysis and the Ecosystem Puzzle

The last hat belongs to the data analyst. Metrics like response time on the dashboard can feed back into product improvement. Ivan didn't demo BigQuery and Looker MCP servers live, but pointed out where to get them: Google Cloud's Agent Registry lists natively supported MCP servers, including the Developer Knowledge service and BigQuery MCP server, with configuration instructions, observability features, and tool descriptions. For Looker, there's the open-source MCP Toolbox for Databases, with a quick-start guide for integration with Claude Code.

What This Demo Really Shows

Technically, this is an integration showcase of a tool chain. But the deeper message is: the value of AI coding agents is shifting from "completing code" to "taking over the process." Skills fill in domain knowledge, MCP servers connect external systems, sub-agents enable parallel execution, and security review is front-loaded into automatable steps — together, these components point to a new delivery paradigm: developers describe intent, and AI handles path planning and execution from prototype to deployment.

Ivan noted at the end that the demo code will be released after the talk, and that both Google Cloud and Anthropic have quick-start documentation. For teams already using AI to write code but haven't yet connected the deployment pipeline, this combination provides a reproducible starting point.

One-line Summary

Google demonstrates the full flow from prototype to cloud deployment of a feedback app with Claude Code in 30 minutes.

Paragraph Summary

The article documents a demo by Google Cloud developer advocate Ivan Nardini at a Bilibili tech talk: using Claude Code with Google Cloud to complete prototype design, implementation, security review, and deployment of a feedback app in 30 minutes. The demo uses a "one person, five roles" approach, successively covering the workflows of product manager, designer, engineer, security engineer, and data analyst, tying together capabilities like plan mode, the Developer Knowledge API's MCP server, Google Cloud Skills, parallel sub-agent implementation, and security review. The article also explains the reasons for choosing Claude models on Google Cloud, including token-based billing, provisioned throughput, passwordless ADC configuration, and data residency. The core conclusion: the value of AI coding agents is shifting from completing code to taking over the complete flow from intent description to deployment.