Last reviewed: May 2026
A scannable reference of architectural patterns the PMLE exam tests. Read top-to-bottom, or jump to a section.
Build classification, regression, or recommendation models on large tabular datasets in BigQuery for teams with strong SQL skills.
Use BigQuery ML with SQL syntax (e.g., `CREATE MODEL ... OPTIONS(model_type='BOOSTED_TREE_CLASSIFIER')`). Enable explainability with `EXPLAIN_PREDICT`.
Why: Avoids data movement and leverages existing SQL skills for rapid development. Keeps data governance within BigQuery and provides integrated explainability.
Extract structured data (e.g., names, dates, codes) from unstructured documents like forms or invoices with minimal ML expertise.
Use Document AI with a pre-trained or custom processor. Train a custom processor with labeled sample documents for specialized layouts.
Why: A specialized, managed service for document parsing that outperforms building custom OCR and parsing logic from scratch.
Analyze unstructured data like audio or text for sentiment, entities, or topics without training a custom model.
Chain pre-trained APIs. Example: Speech-to-Text API for transcription, followed by Natural Language API for entity and sentiment analysis.
Why: Fastest time-to-market for common use cases. Leverages Google-trained models without requiring data labeling or model training.
Build a high-quality custom image, video, or tabular model with labeled data but limited ML coding expertise.
Use Vertex AI AutoML (e.g., AutoML Vision Object Detection). Provide labeled data and let the service handle architecture search and training.
Why: Balances custom model needs with ease of use. Outperforms generic pre-trained APIs for custom tasks (e.g., identifying specific products).
Build a conversational AI or knowledge assistant that answers questions based on a large, proprietary document corpus.
Implement a Retrieval-Augmented Generation (RAG) pattern. Use Vertex AI Vector Search to find relevant document chunks and pass them as context to a Gemini model for grounded response generation.
Why: Grounds LLM responses in factual data, reducing hallucinations and providing citations. More scalable and up-to-date than fine-tuning for knowledge.
Create an enterprise-grade chatbot or search engine with minimal code, connected to internal data sources like Cloud Storage or BigQuery.
Use Vertex AI Agent Builder. Configure data store connectors to your knowledge base and use tools (function calling) for real-time data lookups.
Why: Low-code solution that automates RAG pipeline creation, including document parsing, chunking, embedding, and retrieval, for rapid deployment.
Perform real-time defect detection on high-volume video streams from manufacturing cameras with sub-second latency.
Deploy optimized models to edge devices using Vertex AI Edge Manager. Perform inference locally and send only defect metadata to the cloud for monitoring.
Why: Handles high bandwidth and low latency requirements that are infeasible or cost-prohibitive with a cloud-only approach.
Manage ML features to ensure consistency between batch training and real-time serving, preventing training-serving skew.
Use Vertex AI Feature Store. Define feature groups with different sync schedules (batch, streaming). Use time-travel queries for point-in-time correct training data.
Why: Provides a centralized feature repository, ensures consistent feature definitions, and solves point-in-time correctness for training data.
Implement model governance with versioning, approval workflows, and auditable deployment history.
Use Vertex AI Model Registry to version and store models. Link to experiments and datasets. Use IAM and version aliases (e.g., "production") to manage deployment approvals.
Why: Centralizes model management, enabling governance, reproducibility, and safe rollback capabilities. Integrates with CI/CD pipelines.
Systematically track and compare ML experiments, including hyperparameters, metrics, and artifacts, to ensure reproducibility.
Use Vertex AI Experiments. Automatically log parameters and metrics from training jobs. Link artifacts and datasets for full lineage tracking.
Why: Provides a structured, queryable system for experiment management, moving beyond spreadsheets or manual logs for better collaboration.
Train and serve models on sensitive data (e.g., PHI, PII) while meeting strict data residency and security requirements.
Configure Vertex AI within a VPC Service Controls perimeter. Use Private Endpoints for network isolation and Customer-Managed Encryption Keys (CMEK) for data at rest.
Why: Creates a secure network perimeter that prevents data exfiltration and ensures all processing and data transit occur within controlled boundaries.
Version control training data to ensure experiments are reproducible and models can be traced back to the exact data snapshot used for training.
Use Vertex AI Managed Datasets with versioning. Create new dataset versions for significant data changes and link specific versions to training runs.
Why: Provides immutable, versioned data snapshots with automatic lineage tracking in ML Metadata, crucial for compliance and debugging.
Label a large, unlabeled dataset for model training with a limited budget for human annotation.
Implement an active learning loop. Train an initial model on a small labeled subset, then use its uncertainty scores to prioritize the most informative samples for human labeling.
Why: Maximizes the value of each human-labeled sample, reducing labeling costs and time compared to random sampling or exhaustive labeling.
Reduce training time for a large model on a massive dataset by scaling across multiple GPUs or nodes.
Use a synchronous data parallelism strategy, such as TensorFlow's `MultiWorkerMirroredStrategy`. Package training code and submit to Vertex AI Training with a multi-worker configuration.
Why: Standard, effective method for scaling most training jobs. Vertex AI manages the cluster setup and synchronization, requiring minimal code changes.
Train a foundation model (LLM) that is too large to fit in a single accelerator's memory (e.g., >50B parameters).
Use 3D parallelism: Tensor Parallelism (shards layers within nodes), Pipeline Parallelism (stages layers across nodes), and Data Parallelism (replicates across the pod). Train on TPU pods.
Why: The only feasible way to train models that exceed single-device memory. Each parallelism dimension addresses a different scaling bottleneck (memory, compute, network).
Minimize costs for long-running, fault-tolerant training jobs (e.g., >12 hours).
Use Spot VMs (preemptible) for training, which offer up to 80% cost savings. Implement frequent checkpointing to Cloud Storage and configure the job for automatic restart.
Why: Drastically reduces training costs. Checkpointing ensures minimal progress is lost upon preemption, making it a reliable strategy for non-urgent jobs.
Efficiently find optimal hyperparameters for a model with a large and complex search space.
Use Vertex AI Hyperparameter Tuning (Vizier) with Bayesian optimization. Define the search space and objective metric. Enable early stopping to prune unpromising trials.
Why: Bayesian optimization is more sample-efficient than grid or random search, finding better configurations with fewer trials, saving time and money.
A training job requires specific library versions, custom CUDA kernels, or private packages not available in pre-built containers.
Build a custom Docker container with all dependencies pinned. Push the container to Artifact Registry and reference it in the Vertex AI Training job.
Why: Provides full control over the execution environment, ensuring reproducibility and handling complex dependencies that pre-built containers cannot.
Train a model on a very large BigQuery dataset without the delay or cost of exporting it to Cloud Storage.
Use the BigQuery Storage Read API directly from the training container. This enables high-throughput, parallel streaming of data into TensorFlow or PyTorch data loaders.
Why: Fastest and most efficient way to read large BQ datasets for training. Avoids intermediate storage and I/O bottlenecks.
Serve a model with high or variable traffic (e.g., 10,000 RPS peaks) while maintaining low latency and optimizing cost.
Deploy the model to a Vertex AI Endpoint with a GPU machine type. Configure autoscaling with minimum and maximum replica counts based on traffic or utilization.
Why: Automatically scales resources to match demand, ensuring performance during peaks and cost savings during lulls. GPUs provide low latency for complex models.
Serve model predictions to a global user base with minimal latency in each region.
Deploy the model to regional Vertex AI Endpoints in each target geography (e.g., US, EU, APAC). Use a global load balancer to route users to the nearest endpoint.
Why: Minimizes network latency by serving requests from infrastructure close to the user. Essential for latency-sensitive global applications.
Deploy a new model version safely by gradually shifting traffic while monitoring performance.
Deploy the new version to the same Vertex AI Endpoint as the current model. Use traffic splitting to send a small percentage of traffic (e.g., 5%) to the new version, gradually increasing it.
Why: Enables canary deployments and A/B testing. Allows for safe validation of new models under real production traffic with immediate rollback capability.
Serve real-time recommendations from a catalog of millions of items with latency under 50ms.
Implement a two-stage architecture: 1) A fast retrieval stage using Vertex AI Vector Search (ANN) to find top-K candidates. 2) A precise ranking stage that applies a more complex model to the small candidate set.
Why: Balances precision and latency. The fast ANN retrieval prunes the vast item space, allowing the computationally expensive ranker to operate on a manageable subset.
Reduce model inference latency to meet strict real-time requirements (<20ms).
Apply model optimization techniques. Compile the model with TensorRT for GPU or OpenVINO for CPU. Use quantization (e.g., INT8) to reduce precision and increase throughput.
Why: These techniques optimize the model graph and leverage hardware-specific acceleration, often providing 2-5x latency reduction without significant accuracy loss.
Serve dozens of low-traffic models cost-effectively without provisioning dedicated resources for each.
Use a multi-model endpoint to co-host multiple models on a shared set of serving resources. Vertex AI dynamically loads models based on incoming requests.
Why: Dramatically reduces costs for serving many models with infrequent traffic by improving resource utilization compared to dedicated single-model endpoints.
Reduce the latency of large language model (LLM) generation for interactive applications.
Implement speculative decoding. Use a smaller, faster "draft" model to generate candidate tokens, which are then verified in a single pass by the larger, more accurate model.
Why: Significantly accelerates token generation by replacing sequential decoding with parallel verification, reducing a major LLM serving bottleneck.
Automate a multi-step ML workflow including data validation, preprocessing, training, evaluation, and conditional deployment.
Define the workflow as a DAG using Vertex AI Pipelines with the Kubeflow Pipelines (KFP) SDK. Use pre-built or custom components for each step.
Why: Provides a managed, serverless orchestration service for ML with built-in artifact tracking, lineage, caching, and conditional execution.
Prevent bad data from entering a training pipeline and causing model quality degradation.
Add a TensorFlow Data Validation (TFDV) component early in the pipeline. Compare incoming data statistics against a baseline schema and halt the pipeline if drift or anomalies are detected.
Why: Acts as an automated quality gate, catching data issues proactively before they waste compute resources and result in a flawed model.
Automatically trigger model retraining when new data arrives or when model drift is detected.
Use an event-driven architecture. A Pub/Sub message (e.g., from a Cloud Storage update or a drift alert) triggers a Cloud Function or Eventarc trigger that starts a Vertex AI Pipeline run.
Why: Creates a responsive, efficient system that retrains models only when necessary, ensuring model freshness without wasteful scheduled runs.
Automate model promotion to production only if the new model outperforms the current production model on key business metrics.
In a Vertex AI Pipeline, add an evaluation component that compares the new model against a production baseline. Use a `dsl.Condition` to execute the deployment component only if the new model meets or exceeds the performance threshold.
Why: Automates the final quality gate in an MLOps pipeline, preventing performance regressions and ensuring only superior models are deployed.
Standardize common tasks (e.g., feature engineering, evaluation) across multiple ML pipelines and teams.
Package shared logic into versioned, containerized custom components. Store them in Artifact Registry and share them across projects.
Why: Promotes code reuse, ensures consistency, and simplifies maintenance. Teams can compose complex pipelines from a library of trusted, standardized components.
Accelerate pipeline development and reduce costs by avoiding redundant computation during repeated runs.
Enable execution caching in Vertex AI Pipelines. The service will automatically reuse the outputs of a component if its inputs and implementation have not changed.
Why: Dramatically speeds up iterative development by allowing you to re-run a pipeline and only execute the components you've changed.
Implement a CI/CD workflow to automatically test and deploy changes to ML pipeline code.
Use Cloud Build triggered by a Git repository push. The build process runs component unit tests, compiles the pipeline, and deploys it to a staging or production environment.
Why: Applies software engineering best practices to MLOps, enabling rapid, reliable, and automated updates to production ML systems.
Detect when a production model's performance is degrading due to changes in incoming data or predicted outcomes.
Configure Vertex AI Model Monitoring. Set up a job to detect training-serving skew (input distribution changes from training) and prediction drift (output distribution changes over time).
Why: Provides an automated early warning system for model degradation, enabling proactive retraining or intervention before business metrics are significantly impacted.
Model performance is degrading, but input feature distributions appear stable (no data drift detected).
Implement monitoring of prediction outcomes against delayed ground truth labels. A drop in accuracy or other evaluation metrics indicates concept drift, where the relationship between features and the target has changed.
Why: Feature drift monitoring alone is insufficient. Concept drift requires evaluating model predictions against actuals to detect changes in underlying patterns.
Provide explanations for individual model predictions to meet regulatory compliance or for stakeholder trust.
Enable Vertex AI Explainable AI on the deployed endpoint. Use methods like Sampled Shapley or Integrated Gradients to get feature attributions for each prediction.
Why: Provides local, per-prediction explanations that identify which features contributed to a decision, which is essential for auditing and debugging "black-box" models.
Ensure a model performs equitably across different user segments (e.g., demographics) and detect hidden biases.
Configure model monitoring to compute and track performance metrics (e.g., accuracy, error rates) on slices of the data defined by sensitive attributes.
Why: Aggregate metrics can hide poor performance for minority subgroups. Sliced analysis is crucial for identifying and mitigating fairness issues.
Prevent a model from making unreliable, overconfident predictions on inputs that are fundamentally different from its training data.
Implement an out-of-distribution (OOD) detection model (e.g., an autoencoder) alongside the main model. High reconstruction error flags an input as OOD, triggering fallback logic.
Why: Provides a safety mechanism against domain shift, improving model robustness by identifying when the model is operating outside its area of expertise.
Document a model's intended use, limitations, training data, and fairness evaluation for both technical and non-technical stakeholders.
Create a Model Card using Google's framework. Include sections on model details, intended use, ethical considerations, quantitative analyses (including sliced metrics), and limitations.
Why: A standard for responsible AI documentation that promotes transparency, accountability, and proper model usage across an organization.
Maintain a searchable, auditable log of all prediction requests and responses for compliance and debugging.
Enable access logging on the Vertex AI Endpoint. Configure logs to be exported to BigQuery for structured, long-term storage and analysis.
Why: BigQuery provides a scalable and queryable platform for creating audit trails, analyzing prediction trends, and joining predictions with ground truth data.