Google Cloud PMLE Study Guide
Reference updated 2026-09-30
How to read this map
NAME → ROLE → FLOW → STYLE → CHOOSE → OPERATE → SCALE → CONNECT → TRADE-OFF → COST
Implementation styles
- Visual/no-code: graphical interface.
- Low-code/configuration-first: templates and managed settings.
- SQL/declarative: describe the desired operation with SQL.
- Notebook/interactive code: develop in executable cells.
- Code-first SDK/framework: implement custom logic.
- Infrastructure/operations: configure and operate runtime infrastructure.
- API consumption: invoke a managed capability.
Scaling models
- Automatic, including scale-to-zero
- Automatic within configured bounds
- Optional/configured autoscaling
- Service-managed elasticity
- Fixed/provisioned capacity
- Job-scoped temporary capacity
Cost categories
- Compute-time: processing duration × resources.
- Provisioned capacity: allocated resources, potentially while idle.
- Data volume: bytes stored, processed, or transferred.
- Request/API/model usage: requests, predictions, tokens, or model units.
- Workflow/downstream usage: services invoked by an orchestrator or tool.
Interactive platform map
Open a branch to compare products and decision characteristics.
Google Cloud
Compute / Application Runtime
Cloud Run
summary
Serverless container platform for applications, APIs, agents, and tools. It automatically scales with demand and can scale to zero when eligible.
role
run stateless containerized services
flow
container image + request → managed service → response
implementation style
code-first SDK/framework + infrastructure/operations
best when
stateless web app / API / agent service
scaling model
automatic, including scale-to-zero; configurable minimum / maximum instances
pairs with
Agent Platform / Pub/Sub / Cloud Storage / BigQuery
trade-off
less infrastructure control than GKE / VMs
cost driver
allocated resources while instances process requests (compute-time + request/API/model usage)
can host AI agents
can host MCP servers / tools
can use Agent Platform features
Agent Identity
Agent Registry
Compute Engine
summary
Self-managed virtual machines offering direct control over the operating system and hardware. That flexibility brings greater operational responsibility and provisioned-resource cost.
role
run self-managed virtual machines
flow
VM image + disks + network → running VM → application / job
implementation style
infrastructure/operations
best when
direct OS / VM / hardware control is required
scaling model
fixed per VM; optional/configured autoscaling requires a managed instance group
pairs with
VPC / persistent disks / GPUs / Cloud Storage
trade-off
maximum control, greatest operational burden
cost driver
provisioned resources while running (provisioned capacity + data volume)
stopped VMs can still incur disk and static IP costs
GKE (Google Kubernetes Engine)
summary
Managed Kubernetes for operating complex containerized systems. It offers more deployment and networking control than Cloud Run, with more cluster and workload management.
role
orchestrate containerized applications with Kubernetes
flow
container images + manifests → cluster → services / workloads
implementation style
infrastructure/operations + low-code/configuration-first
best when
Kubernetes or complex multi-service architecture
scaling model
optional/configured Pod autoscaling plus separate node / cluster autoscaling
pairs with
Artifact Registry / load balancing / Agent Platform
trade-off
more control and more operational complexity than Cloud Run
cost driver
cluster and workload compute resources (provisioned capacity + compute-time)
can host AI agents
can host tools / APIs / MCP servers
supports custom networking / deployment topology
Build / CI/CD/CT (continuous integration / delivery / training)
Cloud Build
summary
Managed build service that converts source code into tested, deployable artifacts. It automates repeatable CI/CD steps but does not run the finished application.
role
build, test, package, and optionally deploy application code
flow
source repository → containerized build steps → tested artifact
implementation style
low-code/configuration-first + code-first SDK/framework
best when
builds must be automated and reproducible
pairs with
source repositories / Artifact Registry / Cloud Run / GKE
boundary
builds and delivers software; it is not the application runtime
trade-off
less build-infrastructure management, but pipeline configuration is still required
cost driver
build duration, worker machine, storage, and transfer (compute-time + data volume)
Artifact Registry
summary
Managed repository for versioning and distributing container images and software packages. It provides the controlled handoff between building software and deploying it.
role
store and distribute container images and software packages
flow
built artifact → versioned repository → deployment target
implementation style
low-code/configuration-first + API consumption
best when
deployment artifacts need centralized, versioned storage
pairs with
Cloud Build / Cloud Run / GKE / Compute Engine
boundary
stores artifacts; it does not build or run them
trade-off
adds a managed handoff and retention lifecycle to the delivery path
cost driver
artifact storage, data transfer, and optional scanning (data volume + request/API/model usage)
Data / Analytics
Pub/Sub
summary
Serverless messaging service that buffers and distributes events between independent producers and consumers. It transports streaming data but is not the permanent system of record.
role
transport and buffer asynchronous messages / events
flow
publisher → topic → subscription → consumer
implementation style
low-code/configuration-first + API consumption
best when
producers and consumers must operate independently
scaling model
service-managed elasticity; publishers and subscribers scale independently
pairs with
Dataflow / Cloud Run / BigQuery
boundary
transports events; does not substantially transform them
cost driver
message throughput / retention / transfer (data volume)
Dataflow
summary
Managed Apache Beam execution for scalable batch and streaming transformation. It processes and routes data without requiring the user to operate the worker cluster directly.
role
transform batch or streaming data at scale
flow
source → Apache Beam pipeline → transformed destination
implementation style
low-code/configuration-first templates OR code-first SDK/framework with Apache Beam
best when
data requires scalable transformation / enrichment
scaling model
automatic worker scaling within configured minimum / maximum limits
pairs with
Pub/Sub / Cloud Storage / BigQuery
trade-off
pipeline development is more complex than a direct transfer
cost driver
worker compute / shuffle / streaming resources (compute-time + data volume)
common stream path: Pub/Sub → Dataflow → BigQuery / Cloud Storage
Managed Service for Apache Spark (Dataproc)
summary
Managed clusters for running existing Spark and Hadoop workloads. It reduces cluster setup work while retaining more cluster responsibility than Dataflow.
role
run distributed Apache Spark and Hadoop workloads
flow
data + cluster configuration → managed cluster → Spark job → results
implementation style
low-code/configuration-first + command line
best when
running existing Spark / Hadoop workloads or distributed batch processing
scaling model
resize the number of worker nodes
pairs with
Cloud Storage / HDFS / Compute Engine
boundary
executes Spark jobs; it does not replace durable source or result storage
trade-off
managed clusters reduce setup work but require more cluster management than Dataflow
cost driver
master / worker VMs, disks, and cluster runtime (provisioned capacity + compute-time + data volume)
course lab examples: SparkPi / SparkPageRank with HDFS input
Document AI
summary
Managed document-processing service that turns PDFs and images into structured information through OCR, classification, splitting, and field extraction.
role
extract and structure information from documents
flow
PDF / image → processor → OCR / classify / split / extract → structured data
implementation style
low-code/configuration-first + API consumption
best when
processing forms, invoices, receipts, IDs, contracts, or scanned documents
scaling model
service-managed elasticity subject to processor quotas
pairs with
Cloud Storage / BigQuery / Agent Search / RAG
boundary
understands and extracts document content; does not replace storage or retrieval
trade-off
managed processors reduce custom ML work but still require configuration and output-quality validation
cost driver
pages processed and processor type (data volume + request/API/model usage)
BigQuery
summary
Serverless analytical data warehouse for storing and querying large structured datasets with SQL. It also supports feature preparation and in-warehouse machine learning.
role
store and analyze large analytical datasets with SQL
flow
structured data → tables / SQL → analytical results / features
implementation style
SQL/declarative
best when
warehouse-centered SQL analytics / feature preparation
scaling model
service-managed elasticity; reservations can autoscale slots to a configured maximum
pairs with
Cloud Storage / Dataflow / BigQuery ML / Feature Store
trade-off
analytical engine, not an operational transaction database
cost driver
storage plus query / compute consumption (data volume + compute-time)
Partitioned tables
summary
BigQuery tables divided by a date, timestamp, or other partitioning field so queries can scan only the relevant portions of the data.
role
organize time-oriented table data by a partitioning field
course flow: Pub/Sub taxi events → Dataflow template → partitioned BigQuery table → SQL results
course table: `taxirides.realtime`
time-partitioning field: event `timestamp`
creation option: `--time_partitioning_field timestamp`
ml feature role
tables / views for training, batch prediction, and Agent Platform Feature Store
BigQuery ML
summary
BigQuery capability for training, evaluating, and using supported ML models through SQL. It keeps modeling close to warehouse data without separate training infrastructure.
role
train / evaluate / predict with SQL
flow
BigQuery table + SQL → BigQuery ML model → predictions
implementation style
SQL/declarative
requires
BigQuery-resident data and a supported model type
best when
supported model + BigQuery-resident data + SQL team
scaling model
inherits BigQuery compute elasticity / reservation limits
pairs with
BigQuery tables / scheduled queries / batch results
trade-off
less modeling flexibility than custom training
cost driver
BigQuery processing plus any remote-model usage (compute-time + request/API/model usage)
boundary
models remain close to data in BigQuery
Logistic regression
model_type = 'logistic_reg'
classification model
labs: predict yes/no outcomes
visitor will purchase or not
team will win or lose
Linear regression
model_type = 'linear_reg'
numeric prediction model
lab: predict taxi fare amount
Gemini Enterprise Agent Platform
summary
Google Cloud's integrated platform for building, training, deploying, operating, and governing traditional ML and generative AI systems.
formerly
Vertex AI
role
enterprise platform for building, training, deploying, and governing AI
Models
Model Garden
summary
Catalog for discovering and comparing Google, partner, and open models. It helps select a starting model before prompting, tuning, deployment, or inference.
formerly
Vertex AI Model Garden
role
discover and compare available models
flow
use-case requirements → model selection → tuning / deployment path
implementation style
visual/no-code discovery + code-first SDK/framework + API consumption
best when
comparing available foundation / partner / open models
pairs with
Agent Studio / tuning / Model Registry / inference
boundary
discovery catalog, not a training or serving runtime
cost driver
selected model's tuning / deployment / inference (workflow/downstream usage)
access
discover through model cards; use selected models through provided code examples, SDKs, or APIs
Google first-party models
partner models
open-source models
Gemini models
summary
Google's managed multimodal foundation-model family for generation, reasoning, and understanding across text, images, audio, video, and documents.
formerly
Gemini on Vertex AI
role
Google foundation-model family for generative AI
flow
prompt + optional context → Gemini model → generated response
implementation style
API consumption + code-first SDK/framework
best when
generation / reasoning / multimodal understanding is required
scaling model
service-managed API elasticity; quotas and rate limits still apply
pairs with
Agent Studio / ADK / RAG / Agent Runtime
trade-off
output quality depends on model choice, context, and evaluation
cost driver
input / output usage, tuning, and reserved capacity if used (request/API/model usage + provisioned capacity)
multimodal
text
image
audio
video
documents
Context caching
summary
Reuses large repeated prompt context across requests to reduce processing cost and latency, either automatically or through an explicitly managed cache.
role
reuse repeated input context to reduce cost and latency
implicit caching
automatic and enabled by default
explicit caching
create and reference a cache with a controlled TTL
best when
large instructions, documents, audio, or video are reused across requests
Gemini model customization / tuning
summary
Adapts a general Gemini model to specialized behavior using supervised examples or response preferences, producing a tuned model for later invocation.
Supervised fine-tuning
train on labeled input/output examples
adjusts model weights
useful for domain-specific behavior
classification
summarization
extraction / Q&A
chat / specialized tasks
Preference tuning
preferred vs. dispreferred responses
aligns model behavior with preferences
produces a tuned Gemini model
deploy / invoke like a specialized model
Train ML models
Agent Platform AutoML
summary
Managed low-code training that automates model selection and tuning. It accelerates common ML projects when convenience matters more than algorithm-level control.
formerly
Vertex AI AutoML
role
automate model selection and tuning with minimal code
flow
labeled dataset → managed training → selected model
implementation style
visual/no-code + low-code/configuration-first
best when
managed model search matters more than algorithm control
scaling model
job-scoped temporary training capacity managed by the service
pairs with
Cloud Storage / BigQuery / Model Registry / inference
trade-off
faster development, less customization
cost driver
training compute and later prediction resources (compute-time + request/API/model usage)
classification / regression
forecasting
image / text models
alternative to custom training
Agent Platform Serverless Training
summary
Runs custom training code on temporary Google-managed CPU, GPU, or TPU infrastructure. It provides framework flexibility without requiring persistent training servers.
role
run custom model-training code on managed infrastructure
flow
code + data + compute specification → training job → model artifacts
implementation style
code-first SDK/framework + low-code/configuration-first job specification
best when
custom code is required without managing training VMs
scaling model
job-scoped temporary capacity; worker count / machine specification is job-defined
pairs with
Workbench / Pipelines / Cloud Storage / Model Registry
trade-off
greater control, greater development responsibility
cost driver
job duration × CPU / GPU / TPU resources (compute-time)
training job types
Custom job
Hyperparameter tuning job
CustomTrainingJob
training pipeline resource
runs a custom or hyperparameter tuning job
can create a model resource after training
training data
Cloud Storage
BigQuery
Agent Platform managed dataset
supported ML frameworks
TensorFlow (TF)
summary
ML framework used to build and train custom models, with Keras as its higher-level model-building API and TFX for production pipelines.
supported by prebuilt or custom training containers
Keras provides a high-level model-building API
pairs with TFX for TensorFlow-centered pipelines
PyTorch
summary
Code-first deep-learning framework supported in custom training containers for building and training flexible neural-network models.
supported by prebuilt or custom training containers
deployment requirements can differ from TensorFlow models
handles job queuing / logging / monitoring
model artifacts
written to Cloud Storage
optionally imported into Model Registry
MLOps / Orchestration
Agent Platform ML Metadata
summary
Managed metadata graph that connects datasets, executions, models, and other artifacts. It supports lineage, reproducibility, debugging, auditing, and governance without executing workflows itself.
role
record ML artifacts, executions, contexts, and lineage
flow
artifacts + executions + contexts → metadata graph → lineage queries / audit
implementation style
API consumption + code-first SDK/framework
best when
reproducibility, traceability, debugging, or governance matters
pairs with
Pipelines / Experiments / Model Registry / Knowledge Catalog
boundary
records relationships and metadata; does not execute workflows or store artifact contents
cost driver
associated pipeline, training, and artifact-storage services (workflow/downstream usage)
Agent Platform Experiments
summary
Experiment-tracking service for comparing training runs, parameters, metrics, and artifacts. It helps identify the best configuration but does not run training itself.
formerly
Vertex AI Experiments
role
track and compare ML experiment runs
flow
parameters + metrics + artifacts → run comparison
implementation style
code-first SDK/framework logging + visual/no-code analysis
best when
selecting among training configurations
pairs with
Training / Pipelines / TensorBoard / Model Registry
boundary
records and compares runs; does not execute them
cost driver
associated training / pipeline / storage resources (workflow/downstream usage)
Agent Platform TensorBoard
summary
Managed TensorBoard dashboards for visualizing and comparing training metrics over time. It exposes model-training behavior rather than executing or deploying models.
formerly
Vertex AI TensorBoard
role
track, visualize, compare, and share ML experiments
flow
training metrics → visual dashboards → experiment comparison
implementation style
code-first metric logging + visual/no-code analysis
best when
training behavior and time-series metrics must be inspected
pairs with
Experiments / custom training
boundary
visualizes experiment data; does not train or deploy models
cost driver
associated TensorBoard and training resources (workflow/downstream usage)
Agent Platform Pipelines
summary
Serverless orchestration for repeatable ML workflows composed of dependent containerized steps. It coordinates preparation, training, evaluation, registration, and deployment.
role
orchestrate repeatable multi-step ML workflows
flow
component DAG + parameters → pipeline run → artifacts / model
implementation style
code-first SDK/framework + low-code/configuration-first templates
best when
ML steps must be repeatable / governed / automated
scaling model
service-managed orchestration; each invoked component scales separately
pairs with
BigQuery / Dataflow / Training / Registry / endpoints
trade-off
orchestration adds design and maintenance complexity
cost driver
pipeline execution plus downstream service usage (workflow/downstream usage)
workflow definition
KFP or TFX DAG of containerized tasks
TensorFlow Extended (TFX)
summary
Production ML pipeline ecosystem centered on TensorFlow. Its reusable components cover data ingestion and validation through training, evaluation, and model release.
role
production ML pipeline ecosystem for TensorFlow-centered workflows
best when
building structured-data pipelines around TensorFlow
TensorFlow Data Validation (TFDV)
summary
TFX data-analysis and validation tooling that computes statistics, infers schemas, and detects anomalies before unreliable data reaches training.
role
analyze and validate ML data within a TFX pipeline
flow
raw data → examples → statistics → schema → anomaly validation
statistics inputs: pandas DataFrame / CSV / TFRecord
ExampleGen: ingest raw data and produce training / evaluation examples
StatisticsGen: compute descriptive feature statistics and samples
SchemaGen: infer feature types, categories, ranges, and required values
ExampleValidator: compare statistics with the schema and identify anomalies
Transform: preprocess features consistently for training and serving
components
Google Cloud Pipeline Components or custom components
example ML lifecycle
prepare data
train model
evaluate model
register model
deploy model
tracks pipeline runs / artifacts / lineage
Cloud Composer (Managed Apache Airflow)
summary
Managed Apache Airflow environment for scheduling dependency-based workflows as DAGs. It flexibly coordinates multiple services but requires DAG and environment management.
role
orchestrate scheduled workflows as DAGs
best when
coordinating multiple Google Cloud services
trade-off
flexible orchestration with added DAG and environment management
Development Environments / Notebooks
Colab Enterprise
summary
Managed collaborative notebooks for quickly exploring data, running code, and testing models with minimal environment setup.
formerly
Vertex AI Colab Enterprise
role
provide managed collaborative notebooks
flow
notebook + data → interactive code / analysis / experiments
implementation style
notebook/interactive code
best when
fast collaborative notebook setup is the priority
scaling model
job-scoped temporary capacity; not application autoscaling
pairs with
BigQuery / Cloud Storage / Agent Platform APIs
trade-off
less environment control than Workbench
cost driver
notebook runtime and selected compute (compute-time + data volume)
Agent Platform Workbench
summary
Customizable managed JupyterLab environment backed by a configurable VM. It provides more dependency and hardware control than Colab Enterprise with more environment management.
formerly
Vertex AI Workbench
role
provide a customizable JupyterLab / VM environment
flow
code + data + environment → interactive development → production handoff
implementation style
notebook/interactive code + infrastructure/operations
best when
a customizable notebook VM is required
scaling model
fixed/provisioned VM capacity until resized or stopped
trade-off
more control and more environment management
cost driver
VM / accelerator / storage while provisioned (provisioned capacity + data volume)
environment controls
CPU / GPU, frameworks, and custom environments / containers
data / code integrations
BigQuery / Cloud Storage / Git
production handoff
Training / Pipelines / Model Registry / inference endpoints
Deploy / Serve Models
Model Registry
summary
Managed catalog for versioning trained and imported models and controlling their handoff to deployment or batch inference. It registers models but does not serve them.
role
catalog and version trained / imported model resources
flow
trained model artifact → registered version → deployment / batch job
implementation style
low-code/configuration-first + API consumption
best when
models require controlled versioning and deployment handoff
pairs with
Training / Pipelines / Experiments / inference
boundary
stores model resources; does not serve predictions itself
cost driver
underlying model artifacts and downstream services (data volume + workflow/downstream usage)
Agent Platform Inference
summary
Managed prediction capabilities for serving registered models either synchronously through online endpoints or asynchronously through batch jobs.
Online inference endpoint
summary
Managed endpoint for immediate, low-latency predictions from a deployed model. Serving replicas can autoscale within limits but available capacity may incur ongoing cost.
role
serve low-latency model predictions
flow
application request → deployed model → immediate prediction
implementation style
low-code/configuration-first deployment + API consumption
requires
registered model + serving compute specification
best when
synchronous request / response predictions are required
scaling model
automatic replica scaling between configured minimum / maximum values
pairs with
Model Registry / applications / Feature Store
trade-off
serving capacity can cost money while available
cost driver
provisioned serving CPU / GPU and traffic (provisioned capacity + request/API/model usage)
traffic management
traffic splitting / routing
observability
monitoring
access
public or private
Batch inference job
summary
Temporary managed job that scores a bounded dataset asynchronously and writes the predictions to storage. It avoids maintaining an always-available endpoint.
role
score a bounded dataset asynchronously
flow
registered model + input dataset → batch job → stored predictions
implementation style
low-code/configuration-first job + API consumption
requires
registered model + supported input / output location
best when
throughput / cost matters more than immediate response
scaling model
job-scoped temporary capacity; no continuously running endpoint
pairs with
Model Registry / BigQuery / Cloud Storage
trade-off
higher latency; not suitable for request / response serving
cost driver
temporary job compute and data processing (compute-time + data volume)
data path
BigQuery / Cloud Storage input → predictions in BigQuery / Cloud Storage
Build agents
Agent Studio
summary
Visual environment for configuring prompts, model settings, grounding, and AI applications. It accelerates experimentation but offers less code-level control than ADK.
formerly
Vertex AI Studio
role
visually configure and test prompts / AI applications
flow
prompt + settings + model → tested configuration / application
implementation style
visual/no-code + low-code/configuration-first
best when
low-code experimentation and application building are priorities
pairs with
Gemini models / grounding / deployment
trade-off
less code-level customization than ADK
cost driver
model, tool, and deployed runtime usage (request/API/model usage + workflow/downstream usage)
ADK
summary
Code-first Agent Development Kit for building agents with custom tools and orchestration. The resulting application still requires a selected deployment runtime.
role
build custom agents with code
flow
agent code + tools + model → deployable agent application
implementation style
code-first SDK/framework
best when
custom orchestration and tool integration are required
pairs with
Gemini models / tools / Agent Runtime / Cloud Run / GKE
trade-off
more development and testing responsibility
cost driver
selected model, tools, and deployment runtime (workflow/downstream usage)
Managed Agents API
summary
Pre-GA managed API and sandbox for creating autonomous agents that can reason, use tools, execute code, and work with files.
role
create autonomous agents through configuration and REST APIs
maturity
Pre-GA; evaluation use rather than production
Run agents
Agent Runtime
summary
Fully managed environment for deploying and operating agent applications with sessions, memory, models, and tools while minimizing runtime administration.
formerly
Vertex AI Agent Engine
role
deploy and operate agent applications
flow
agent application → managed runtime → user / application response
implementation style
low-code/configuration-first deployment + API consumption
requires
deployable agent application and configured model / tools
best when
deploying an agent on the managed Agent Platform runtime
scaling model
service-managed autoscaling for deployed agent applications
pairs with
ADK / Agent Studio / tools / Sessions / Memory Bank
trade-off
less infrastructure control than Cloud Run / GKE
cost driver
runtime, session, model, and tool usage (compute-time + request/API/model usage)
Data / Features
Agent Platform Feature Store
summary
Managed system for registering, sharing, and consistently serving ML features for training, batch prediction, and low-latency online inference.
role
manage and serve reusable structured ML features
flow
BigQuery feature data → registered features → offline / online access
implementation style
SQL/declarative + low-code/configuration-first + API consumption
best when
features must be shared or served consistently online
scaling model
BigQuery elasticity offline; optional/configured Bigtable node autoscaling online
pairs with
BigQuery / Bigtable / Training / inference endpoints
trade-off
extra infrastructure beyond querying BigQuery directly
cost driver
BigQuery offline use + Bigtable online serving (data volume + provisioned capacity)
Feature Registry: feature groups + definitions
offline access: BigQuery historical values → training / batch prediction
online access: Bigtable latest values → low-latency prediction
course lab DataFrame workflow
flow
BigQuery → pandas DataFrame → clean / prepare → streaming ingestion → online serving
DataFrame index → Entity ID
DataFrame column → Feature ID
DataFrame cell → Feature Value
Grounding / Retrieval
Agent Search
summary
Higher-level managed service for semantic search and recommendations over enterprise content. It delivers turnkey retrieval with less custom index engineering than Vector Search.
formerly
Vertex AI Search
role
managed semantic search and recommendations over enterprise data
flow
websites / documents / structured data → indexed data store → search results
best when
turnkey search or a managed retrieval backend is needed
pairs with
RAG / Gemini models / Agent Studio
trade-off
less retrieval control than a custom vector-search solution
Agent Platform Vector Search
summary
Managed high-scale service for indexing embeddings and retrieving semantically similar items. It provides direct control over vector indexes, endpoints, and serving capacity.
formerly
Vertex AI Vector Search
role
index embeddings and retrieve semantically similar items
flow
data → embeddings → vector index → nearest matches
best when
custom RAG, semantic search, or recommendations need high-scale retrieval
scaling model
deployed replicas autoscale within configured limits
trade-off
greater index and endpoint control with more configuration
cost driver
index builds / updates plus deployed serving capacity (provisioned capacity + data volume)
Agent Retrieval
summary
Self-tuning retrieval system combining data storage, embeddings, filtering, and vector or keyword search. It reduces the infrastructure work required by traditional Vector Search.
formerly
Vector Search 2.0
role
unified storage and retrieval for AI applications
includes: data objects / embeddings / vector and keyword search / filtering
best when
managed, self-tuning retrieval is preferred over direct index management
scaling model
usage-based or dedicated autoscaling infrastructure
trade-off
simpler operations with less infrastructure-level control
RAG
summary
Retrieval-augmented generation pattern that supplies private, current, or domain-specific context to a model before it generates an answer.
role
ground model responses in retrieved enterprise knowledge
flow
query → retrieve context → model prompt → grounded response
implementation style
low-code/configuration-first OR code-first SDK/framework
requires
retrievable / indexed knowledge source
best when
responses require private / current enterprise knowledge
pairs with
Agent Search / Vector Search / Agent Retrieval / data stores / Gemini models / agents
trade-off
adds ingestion, retrieval quality, and latency concerns
cost driver
embedding, index, retrieval, and model usage (data volume + request/API/model usage)
common knowledge sources
Cloud Storage / BigQuery / databases / search indexes
Govern / secure
Agent Identity
summary
Gives an agent a unique cryptographic identity so its access can be authenticated, authorized, and audited.
Agent Gateway
summary
Routes agent traffic through a controlled entry point where access and security policies can be enforced consistently.
Model Armor
summary
Managed protection layer that inspects AI prompts and responses for threats, sensitive data, and harmful content before allowing them to continue.
role
screen AI prompts and responses
protects against
prompt injection / data leakage / harmful content
flow
prompt or response → inspect → allow or block
trade-off
stronger filtering can increase latency and false positives
Evaluate / monitor
Gen AI Evals
summary
Managed evaluation service for measuring and comparing model or agent responses with references, rubrics, automated metrics, or model-based judges.
formerly
Gen AI Evaluation Service
role
evaluate model / agent responses against chosen criteria
flow
responses + reference / rubric → evaluation → metrics
implementation style
API consumption + code-first SDK/framework
best when
quality must be compared before or after release
pairs with
Gemini models / agents / Experiments
trade-off
conclusions depend on evaluation data, criteria, and judge quality
cost driver
evaluation and model-judge usage (request/API/model usage + workflow/downstream usage)
evaluation methods
AutoSxS (Automatic Side-by-Side)
compares
model response A vs. model response B
judge
third LLM acts as the autorater
output
preferred response + win rate
ROUGE
compares
summary vs. reference answer
focus
recall / coverage of reference n-grams
BLEU
compares
translation vs. reference answer
focus
precision / matching n-grams
Model Monitoring
summary
Managed production oversight that analyzes serving data and predictions for drift or other quality signals, then raises alerts for investigation.
formerly
Vertex AI Model Monitoring
role
observe deployed model behavior and data changes
flow
serving data / predictions → monitoring analysis → alerts
implementation style
low-code/configuration-first
best when
production quality and drift require ongoing oversight
pairs with
inference endpoints / logging / alerting
trade-off
detects signals; remediation still requires an operational response
cost driver
monitoring jobs, analysis, and retained data (compute-time + data volume)
No products or characteristics match this search.
Implementation approach map
These are common starting points, not exclusive interfaces. A production workflow often combines several approaches.
| Implementation approach | Typical starting points | What the learner or engineer primarily does |
|---|---|---|
| Visual/no-code | Agent Studio, AutoML, Model Garden | Select, configure, test, or compare through a graphical interface. |
| Low-code/configuration-first | Cloud Build, Artifact Registry, Pub/Sub, Dataflow templates, Managed Service for Apache Spark, Document AI processors, managed endpoints, Agent Runtime, Model Monitoring | Configure managed resources, templates, jobs, or deployment settings. |
| SQL/declarative | BigQuery, BigQuery ML, Feature Store data preparation | Express data preparation, training, evaluation, or prediction through SQL. |
| Notebook/interactive code | Colab Enterprise, Agent Platform Workbench | Explore data and develop code incrementally in executable notebooks. |
| Code-first SDK/framework | Cloud Build steps, Model Garden code examples, TensorFlow, PyTorch, KFP / TFX pipelines, ADK, Apache Beam, Serverless Training, Gemini SDKs, custom RAG, Gen AI Evals | Implement custom application, build, pipeline, training, agent, retrieval, or evaluation logic. |
| Infrastructure/operations | Cloud Run, Compute Engine, GKE, customizable Workbench environments | Package, deploy, network, scale, and operate runtime infrastructure. |
| API consumption | Artifact Registry, Gemini models, Document AI, Pub/Sub, inference endpoints, Agent Runtime, Feature Store, ML Metadata | Send requests to an existing managed capability and consume its response. |
Common ML problem and model types
Some entries below describe a problem type while others describe a model family that can solve one or more problem types.
| Problem or model | What it does | Typical output | Example |
|---|---|---|---|
| Binary classification | Chooses between two classes. | Yes/no or 0/1 | Will a customer buy or not? |
| Multiclass classification | Chooses among three or more classes. | One category | Cat, dog, or bird |
| Logistic regression | Common model for classification. | Probability or class | Spam versus not spam |
| Linear regression | Predicts a numeric value. | Number | Taxi fare or sales amount |
| k-means clustering | Groups similar examples without labels. | Cluster or group | Customer segmentation |
| DNN classifier or regressor | Uses a deep neural network for classification or regression. | Class or number | More complex nonlinear problems |
| XGBoost | Uses boosted decision trees for classification or regression. | Class or number | Tabular machine learning |
| ARIMA+ | Performs time-series forecasting. | Future numeric values | Future sales |
| Matrix factorization | Learns relationships for recommendations. | Ranked recommendations | Products or movies a user may like |
| Anomaly detection | Identifies unusual examples or behavior. | Normal or anomalous | Fraud or abnormal behavior |
Google Cloud AI service decision guide
Use this as a starting point, then validate regional availability, security requirements, expected scale, and the current pricing model before implementation. Cost guidance is intentionally qualitative because rates change.
| Need | Preferred starting point | Why it fits | Main trade-off | Main cost driver |
|---|---|---|---|---|
| Stateless web app, API, or agent service | Cloud Run | Serverless containers with minimal infrastructure administration | Less runtime and networking control than GKE or VMs | Allocated CPU/memory, instance time, and requests (compute-time + request/API/model usage) |
| Kubernetes or complex multi-service system | GKE | Container orchestration and deployment-topology control | More operational complexity | Cluster and workload compute (provisioned capacity + compute-time) |
| Direct OS, VM, driver, or hardware control | Compute Engine | Maximum infrastructure customization | Greatest administration burden and idle-capacity risk | Provisioned VM, accelerator, disk, and network resources (provisioned capacity + data volume) |
| Automate reproducible builds and tests | Cloud Build | Managed containerized build steps and source-triggered automation | Requires build configuration and does not replace the runtime | Build duration, worker machine, storage, and transfer (compute-time + data volume) |
| Store versioned container images and packages | Artifact Registry | Central handoff between software builds and deployment targets | Stores artifacts but does not build or run them | Artifact storage, transfer, and optional scanning (data volume + request/API/model usage) |
| Decouple event producers from consumers | Pub/Sub | Scalable asynchronous messaging | Moves messages but does not perform substantial transformations | Message throughput, retention, and transfer (data volume) |
| Transform batch or streaming data at scale | Dataflow | Managed Apache Beam execution and autoscaling workers | Requires pipeline design and operational monitoring | Worker compute, shuffle, streaming, and data movement (compute-time + data volume) |
| Run existing Spark or Hadoop workloads on a managed cluster | Managed Service for Apache Spark (Dataproc) | Managed cluster creation, Spark job submission, and worker resizing | More cluster management than Dataflow | Master/worker VMs, disks, and cluster runtime (provisioned capacity + compute-time + data volume) |
| Extract structured data from forms, invoices, IDs, or other documents | Document AI | Managed OCR, classification, splitting, parsing, and entity extraction | Processor configuration and output quality still require validation | Pages processed and processor type (data volume + request/API/model usage) |
| Analyze and prepare warehouse data with SQL | BigQuery | Serverless analytical warehouse close to structured data | Not designed as a low-latency operational database | Storage and query/slot consumption (data volume + compute-time) |
| Train a supported model directly over BigQuery data | BigQuery ML | SQL training, evaluation, and prediction without moving data | Smaller modeling surface than custom code | BigQuery processing and any remote-model usage (compute-time + request/API/model usage) |
| Build a custom model with minimal ML code | Agent Platform AutoML | Managed model selection and tuning | Less algorithm and architecture control | Training compute and prediction resources (compute-time + request/API/model usage) |
| Run custom training code without managing servers | Agent Platform Serverless Training | Managed CPU/GPU/TPU training jobs | More engineering work than AutoML | Job duration and selected compute/accelerators (compute-time) |
| Compare parameters, metrics, and artifacts across runs | Agent Platform Experiments | Organizes evidence needed to select a configuration | Tracks runs but does not execute training or pipelines | Associated training, pipeline, storage, and TensorBoard resources (workflow/downstream usage) |
| Visualize and compare training metrics over time | Agent Platform TensorBoard | Managed experiment dashboards that can be shared with a team | Visualizes logged metrics but does not execute training or deployment | TensorBoard plus associated training resources (workflow/downstream usage) |
| Trace datasets, executions, models, and downstream artifacts | Agent Platform ML Metadata | Maintains a queryable lineage graph across the ML lifecycle | Records metadata and relationships; it does not execute workflows or store artifact contents | Associated pipeline, training, and artifact-storage services (workflow/downstream usage) |
| Automate a repeatable ML lifecycle | Agent Platform Pipelines | Connects preparation, training, evaluation, registration, and deployment | Additional workflow design and component maintenance | Pipeline execution plus every invoked service (workflow/downstream usage) |
| Collaborative notebook with minimal setup | Colab Enterprise | Managed collaboration and low environment-management burden | Less environment control than Workbench | Notebook runtime and selected compute (compute-time + data volume) |
| Customizable Jupyter environment | Agent Platform Workbench | VM-level environment and dependency control | Provisioned environment requires more management | VM, accelerator, disk, and idle runtime (provisioned capacity + data volume) |
| Immediate predictions | Online inference endpoint | Managed low-latency prediction API | Available serving capacity can create idle cost | Provisioned serving resources and traffic (provisioned capacity + request/API/model usage) |
| High-volume predictions that can wait | Batch inference job | No continuously available endpoint required | Results are asynchronous | Temporary prediction compute and data processing (compute-time + data volume) |
| Low-code agent or prompt application | Agent Studio | Faster visual configuration and testing | Less code-level customization | Model, tool, and deployed runtime usage (request/API/model usage + workflow/downstream usage) |
| Code-first custom agent | ADK | Greater control over tools, orchestration, and application logic | More development and testing responsibility | Model, tool, and runtime usage (workflow/downstream usage) |
| Deploy an agent with minimal runtime administration | Agent Runtime | Managed agent execution integrated with Agent Platform | Less infrastructure control than Cloud Run or GKE | Runtime, session, model, and tool usage (compute-time + request/API/model usage) |
| Ground responses in private or current knowledge | RAG / retrieval | Retrieves relevant enterprise context before model generation | Adds ingestion, retrieval-quality, latency, and evaluation work | Embedding, indexing, retrieval, storage, and model inference (data volume + request/API/model usage) |
| Reusable offline and low-latency online features | Agent Platform Feature Store | Shared definitions and consistent feature serving | Additional resources beyond direct BigQuery access | BigQuery plus online Bigtable serving (data volume + provisioned capacity) |
Product-by-stage MLOps and LLMOps matrix
Products are columns; lifecycle stages are rows.
The panels form one end-to-end lifecycle. A product appears only at stages where it has a direct or supporting role.
🟦 Primary role🟩 Supporting role— No direct role
A. Data preparation and feature pipeline
| Pipeline stage | Cloud Storage | Pub/Sub | BigQuery | Dataflow | Apache Beam | Dataproc / Spark | Document AI | TFDV | Feature Store |
|---|---|---|---|---|---|---|---|---|---|
| 1. Acquire / ingest | Land files, images, CSVs, audio, and documents. | Receive and buffer live events. | Use existing analytical tables as source data. | Read batch or streaming sources. | Provides source connectors in the pipeline code. | Load files for cluster processing or HDFS. | Accept PDFs and images for processing. | — | — |
| 2. Store / organize | Durable object storage. | Retains messages temporarily; not the durable system of record. | Store structured analytical data. | Write processed output to storage. | Defines source and sink I/O. | HDFS is used inside the course Spark workflow. | Send extracted structure to downstream storage. | — | Registry plus offline/online feature access. |
| 3. Transform / preprocess | Read raw objects and write processed objects. | Supplies streaming events. | Transform warehouse data with SQL. | Execute managed batch or streaming transformations. | Define one portable batch/stream processing model. | Execute distributed Spark/Hadoop workloads. | OCR, classify, split, and extract document data. | Receives prepared examples for validation. | Prepare feature values before registration or ingestion. |
| 4. Validate data / schema | Supply CSV or TFRecord inputs. | — | Query and inspect source data. | Apply validation logic within a processing pipeline. | Express custom validation transforms. | Perform distributed quality checks when implemented in Spark. | Validate extraction quality before downstream use. | StatisticsGen → SchemaGen → ExampleValidator. | Protect feature quality and training/serving consistency. |
| 5. Engineer / serve features | Source or export feature data. | Can transport real-time feature events. | Prepare and retain offline feature values. | Build scalable feature transformations. | Define reusable transformation code. | Distributed feature preparation for Spark workloads. | — | Validate feature distributions and anomalies. | Register definitions; serve historical or low-latency values. |
| 6. Prepare retrieval knowledge | Store enterprise documents and objects. | Feed newly arriving content into an ingestion workflow. | Supply structured enterprise knowledge. | Clean and enrich content before indexing. | Define custom ingestion processing. | Optional distributed preparation at large scale. | Convert documents into structured content. | — | — |
B. Development, model selection, and training
| Pipeline stage | Workbench | Colab Enterprise | TensorFlow | PyTorch | BigQuery ML | AutoML | Serverless Training | Model Garden | Gemini | Agent Studio |
|---|---|---|---|---|---|---|---|---|---|---|
| 7. Explore / prototype | Customizable Jupyter/VM environment. | Managed collaborative notebooks. | Prototype TensorFlow/Keras models. | Prototype PyTorch models. | Train and test supported models with SQL. | Configure a managed training experiment. | Prepare custom training code and job settings. | Discover and test available models. | Test multimodal prompts and responses. | Visually prototype prompts and agents. |
| 8. Select an approach / model | Compare custom-code options. | Compare notebook experiments. | Choose for TensorFlow-centered custom ML. | Choose for PyTorch-centered custom ML. | Choose when supported ML can remain beside BigQuery data. | Choose managed model search with less algorithm control. | Choose when custom code and managed infrastructure are both required. | Select a foundation or open model. | Choose Gemini for multimodal foundation-model capability. | Choose for visual/low-code agent development. |
| 9. Train a classical/custom model | Develop and submit training work. | Develop experiments collaboratively. | Build/train through TensorFlow or Keras. | Build/train a PyTorch model. | CREATE MODEL and train with SQL. | Managed training, model selection, and tuning. | Run custom CPU/GPU/TPU training jobs. | Supplies candidate models rather than executing custom training. | — | — |
| 10. Prompt / tune a foundation model | Develop SDK-based prompt or tuning code. | Explore prompts in notebooks. | — | — | — | — | Can support custom training code when applicable. | Choose the base model. | Prompt design, prompt engineering, or model tuning. | Adjust prompts/system settings and test behavior visually. |
| 11. Produce a candidate | Hand custom work to training/pipelines. | Hand prototype code to production tooling. | Produce TensorFlow model artifacts. | Produce PyTorch model artifacts. | Produce a BigQuery ML model. | Produce a managed trained model. | Write artifacts to Cloud Storage; optionally import to Model Registry. | Provides the selected base model. | Produce a prompted or tuned model behavior. | Produce an agent/prompt configuration. |
C. MLOps orchestration, evidence, and release
| Pipeline stage | Agent Platform Pipelines | KFP | TFX | Experiments | TensorBoard | ML Metadata | Model Registry | Cloud Build | Artifact Registry |
|---|---|---|---|---|---|---|---|---|---|
| 12. Orchestrate the workflow | Execute the component DAG serverlessly. | Define a general containerized ML pipeline. | Define a TensorFlow-centered structured-data pipeline. | Group associated pipeline and experiment runs. | Display logged training metrics. | Record component executions and artifacts. | Receive the accepted model at the registration step. | Build pipeline/application containers when required. | Supply versioned container images or packages. |
| 13. Track runs / lineage | Produces runs and artifacts to track. | Provides the component sequence and parameters. | Provides TFX artifacts and validation outputs. | Compare parameters, metrics, artifacts, and runs. | Visualize and share time-series training metrics. | Link datasets, executions, contexts, models, and lineage. | Associate registered versions with lifecycle evidence. | Produces traceable build output. | Versions deployable software artifacts. |
| 14. Validate / approve release | Place evaluation and approval gates in the DAG. | Connect evaluation components. | Use TFDV and evaluation-related pipeline steps. | Compare the candidate with prior runs/baselines. | Inspect convergence and metric behavior. | Trace evaluation evidence back to data and execution. | Hold the approved model version. | Run repeatable tests/build checks. | Hold the approved container/package. |
| 15. Register / package / release | Automate registration and deployment handoffs. | Define the release component sequence. | Define TensorFlow-centered release steps. | Preserve the winning run. | — | Preserve artifact and execution lineage. | Version deployable models. | Build, test, and package code. | Store/version container images and packages. |
| 16. Retrain / repeat | Re-run the parameterized lifecycle. | Reuse the portable pipeline definition. | Re-run TensorFlow data/training components. | Compare the new run with the deployed baseline. | Compare new training curves. | Extend lineage with new data, runs, and models. | Register the accepted replacement version. | Rebuild changed code. | Store the new artifact version. |
D. LLMOps, deployment, inference, and operations
| Pipeline stage | Agent Search | RAG | ADK | Gen AI Evals | Model Armor | Model Monitoring | Online inference | Batch inference | Agent Runtime | Cloud Run / GKE / Compute Engine |
|---|---|---|---|---|---|---|---|---|---|---|
| 17. Ground a foundation model | Managed indexing and semantic retrieval. | Retrieve context before generation. | Connect retrieval as an agent capability. | Evaluate relevance and grounded-answer quality. | Screen resulting prompts/responses when required. | — | Model receives the retrieved context. | — | Agent uses retrieval during a session. | Can host a custom retrieval/application layer. |
| 18. Build an application / agent | Supply managed search capability. | Supply private/current context. | Implement code-first agent tools and orchestration. | Test model/agent behavior during development. | Add prompt/response protection. | — | Invoke deployed models. | — | Managed target for an agent application. | Host custom application, API, agent, or tool runtime. |
| 19. Evaluate the complete system | Evaluate retrieval results. | Evaluate retrieval plus generation together. | Exercise tools and orchestration paths. | AutoSxS, ROUGE, BLEU, rubrics, and model/agent response evaluation. | Test safety filtering and false-positive trade-offs. | Production monitoring is separate from pre-release evaluation. | Test online response quality/latency. | Evaluate asynchronous outputs at scale. | Test sessions, tools, and runtime behavior. | Test the complete deployed application path. |
| 20. Secure / govern | Control searchable enterprise sources. | Restrict retrieved knowledge to authorized data. | Use approved tools and access paths. | Preserve quality/safety evidence. | Inspect prompts/responses for injection, leakage, or harmful content. | Retain operational evidence and alerts. | Secure endpoint access. | Protect batch input/output locations. | Apply agent identity, authorization, and auditing. | Apply runtime IAM, networking, and infrastructure controls. |
| 21. Deploy / serve | Provide retrieval to the deployed system. | Assemble retrieved context at request time. | Supplies the packaged agent logic. | — | Screen live interactions. | Observe deployed behavior. | Low-latency prediction API through an endpoint. | Asynchronous high-volume prediction without an always-on endpoint. | Managed agent execution. | Cloud Run: serverless containers GKE: Kubernetes Compute Engine: self-managed VMs. |
| 22. Monitor / improve | Refresh indexes as knowledge changes. | Diagnose retrieval failures and refresh content. | Revise agent tools/orchestration. | Compare new behavior against prior quality. | Tune policies based on observed failures/false positives. | Detect serving-data and model-behavior changes; alert operators. | Monitor latency, traffic, errors, and prediction behavior. | Inspect job completion and output quality. | Monitor sessions, tools, and runtime use. | Scale, diagnose, roll back, or redeploy the application runtime. |
Module practice quizzes
Work through one question at a time. Submit an answer to reveal the rationale, then continue.