☁️ Google Cloud Professional ML Engineer (PMLE) - Exam-Prep
Free exam-prep for Google Cloud Professional ML Engineer (PMLE), signed certificate $5. Learn the modules, pass the 10-question exam, EN/FR, no account.
Last updated: June 2026
For ML practitioners and cloud engineers who want to design, build, deploy, and operate production ML systems on Google Cloud and pass the PMLE exam with confidence. The course is organized into 8 modules, ending with a final exam (pass mark 70%). It is independent, free exam-preparation training — not an official or accredited review course.
What you'll learn
- Exam Overview, Domains & ML Problem Framing on Google Cloud
- Architecting Low-Code AI Solutions: BigQuery ML, AutoML, Gemini & Pre-built APIs
- Collaborate Across Teams to Manage Data & Models
- Scaling Prototypes into Production ML: Custom & Distributed Training and Hyperparameter Tuning
- Serve & Scale Models: Endpoints, Batch Prediction, Hardware & Cost
- Automate & Orchestrate ML Pipelines: Vertex AI Pipelines, CI/CD & Metadata
- Monitor AI Solutions: Skew & Drift, Performance, and Responsible AI
- Exam Strategy, Mock Exam & Final Review
Learning objectives
- Map every PMLE exam domain to concrete Google Cloud services and choose the right service for each ML task.
- Architect low-code and pre-built AI solutions using Vertex AI, BigQuery ML, and Gemini-based APIs.
- Collaborate across teams to manage data, features, and model artifacts with Vertex AI Feature Store, datasets, and Model Registry.
- Scale prototypes into trainable models using custom training, distributed training, hyperparameter tuning, and AutoML.
- Serve and scale models with Vertex AI Endpoints, batch prediction, optimized hardware, and cost/latency trade-offs.
- Automate and orchestrate end-to-end ML pipelines with Vertex AI Pipelines, CI/CD, and metadata tracking.
- Monitor deployed AI solutions for skew, drift, performance, and responsible-AI concerns, and trigger retraining.
- Apply exam-taking strategy to scenario-based multiple-choice and multiple-select questions under time pressure.
Course facts
- Estimated study time
- about 1.5 hours
- Final assessment
- 60 questions · Pass mark 70%
- Available in
- English, Français
- Price
- Free. Optional verifiable certificate: $5
- Last updated
- Published by
- AMAADOR ACADEMY
Course content
1. Exam Overview, Domains & ML Problem Framing on Google Cloud
The Google Cloud Professional Machine Learning Engineer (PMLE) certification validates that you can design, build, productionize, and maintain ML solutions on Google Cloud. This chapter maps the exam, the scoring logic, and the single most-tested skill: framing a business problem as the right ML problem. AMAADOR ACADEMY prepares you independently; we are not affiliated with or endorsed by Google.
Exam logistics at a glance. ~50–60 multiple-choice / multiple-select questions, 2 hours, proctored (online or onsite). No official passing percentage is published — Google uses scaled scoring, but candidates target ~70%+. Valid 3 years. Recommended background: 3+ years industry experience including 1+ year designing and managing solutions on Google Cloud. The exam is scenario-heavy: you pick the best option, not merely a correct one.
The exam blueprint (six domains)
The current outline organizes the exam into six task domains. Memorize the relative weighting — it tells you where to spend study time.
| Domain | Focus | Approx. weight |
|---|---|---|
| 1. Architecting low-code ML solutions | BigQuery ML, AutoML, pre-trained APIs | ~13% |
| 2. Collaborating to manage data & models | Feature Store, datasets, governance, MLOps roles | ~14% |
| 3. Scaling prototypes into ML models | Vertex AI training, frameworks, distributed training | ~18% |
| 4. Serving & scaling models | Endpoints, batch/online prediction, scaling | ~20% |
| 5. Automating & orchestrating pipelines | Vertex AI Pipelines, CI/CD, retraining triggers | ~22% |
| 6. Monitoring ML solutions | Drift/skew detection, Model Monitoring, explainability | ~13% |
2. Architecting Low-Code AI Solutions: BigQuery ML, AutoML, Gemini & Pre-built APIs
One of the most heavily tested ideas on the PMLE exam is choosing the lowest-effort tool that meets the requirement. Google's documented philosophy is to move along a spectrum from pre-built APIs → AutoML / BigQuery ML → custom training on Vertex AI, only stepping right when the simpler option cannot satisfy accuracy, data-residency, or customization constraints. The exam rewards engineers who avoid building custom models when a managed service already solves the problem.
Exam principle. When a question describes a small team, a tight deadline, "minimal ML expertise," or "minimal operational overhead," the intended answer is almost always a pre-built API or a low-code service — not custom TensorFlow.
The four low-code building blocks
| Tool | Best for | Data location | Skill needed |
|---|---|---|---|
| Pre-built APIs (Vision, Natural Language, Translation, Speech, DocAI) | Common perception tasks with no labelling | Any (call via REST/gRPC) | None / app dev |
| BigQuery ML | Structured data already in BigQuery | In-warehouse | SQL only |
| AutoML (via Vertex AI) | Custom models on images, text, tabular, video | Cloud Storage / BigQuery | Low; needs labelled data |
| Gemini & generative APIs | Summarization, extraction, multimodal reasoning, chat | Prompt-based | Prompt engineering |
3. Collaborate Across Teams to Manage Data & Models
On the Professional Machine Learning Engineer exam, this domain tests whether you can build the shared, governed assets that let data scientists, ML engineers, and analysts work from a single source of truth. The three pillars are Vertex AI Feature Store, Vertex AI managed datasets, and the Vertex AI Model Registry.
1. Vertex AI Feature Store: solving training/serving skew
A feature store is a centralized repository where features are defined once, shared, and reused across teams and models. Its primary exam justification is eliminating training–serving skew — the silent killer where a feature computed differently in the training pipeline than at serving time degrades production accuracy.
Two read paths you must know:
- Online serving — low-latency lookups (milliseconds) of the latest feature values for real-time prediction.
- Offline serving / batch — large historical pulls for training, with point-in-time correctness so you only join feature values that existed before the label timestamp (prevents data leakage).
The newer Feature Store with BigQuery uses your BigQuery table as the offline source of truth and an online store / feature view for serving — Bigtable-optimized for high throughput or an optimized online store for low latency. The legacy store organized data as Featurestore → EntityType → Feature.
4. Scaling Prototypes into Production ML: Custom & Distributed Training and Hyperparameter Tuning
A notebook prototype rarely survives contact with production scale. This chapter covers how to take a model that trains on a laptop and run it as a reproducible, distributed, tunable job on Vertex AI custom training. Expect 5-8 exam questions here on choosing training options, distribution strategies, hardware, and tuning.
From notebook to a managed training job
Vertex AI offers three custom-training packaging paths. Knowing when to pick each is a recurring exam trap.
| Option | What you provide | Use when |
|---|---|---|
| Pre-built container | A Python source distribution (training app) + args | Standard TF/PyTorch/scikit/XGBoost, minimal custom deps |
| Custom container | Your own Docker image with the trainer | Unusual dependencies, custom CUDA, non-Python steps |
| Custom Python package | A packaged trainer run on a pre-built image | Quick lift of existing code, no Docker expertise |
Best practice: Containerize the trainer. A pinned image guarantees the same library versions in dev, training, and Vertex pipelines — eliminating the "works in my notebook" failure mode.
Choosing the right accelerator
Do
- GPUs (A100/L4/T4) for PyTorch, custom ops, dynamic graphs, moderate scale
- TPUs for very large matrix-dense TF/JAX models, large batches
- CPU for small tabular / classical ML
5. Serve & Scale Models: Endpoints, Batch Prediction, Hardware & Cost
Once a model is trained and registered, the engineering challenge shifts from accuracy to delivery: how do you serve predictions reliably, at the right latency, and without burning the budget? On the PMLE exam, this domain is heavy on decision-making — choosing online vs. batch, picking accelerators, and right-sizing autoscaling. Memorise the trade-offs, not just the buttons.
Online vs. Batch: the first decision
The single most-tested distinction is when to use a Vertex AI Endpoint vs. a batch prediction job. Online serving deploys a model behind a persistent REST/gRPC endpoint that returns low-latency responses to single requests or small request payloads. Batch prediction runs an asynchronous job over a large dataset (in Cloud Storage or BigQuery), writing results back — no always-on infrastructure.
Use ONLINE when…
- Real-time, request/response (recommendations, fraud scoring)
- Latency budget in milliseconds
- Traffic is continuous or interactive
Use BATCH when…
- Scoring millions of rows on a schedule
- No latency requirement (nightly, hourly)
- You want zero idle cost between runs
Exam trap: If a question says "score the entire customer table every night and write to BigQuery," the answer is batch prediction — deploying an endpoint there wastes money on idle replicas. Conversely, "sub-100ms response per user click" is always an online endpoint.
6. Automate & Orchestrate ML Pipelines: Vertex AI Pipelines, CI/CD & Metadata
Manual notebook-driven ML breaks the moment a model reaches production. The Professional Machine Learning Engineer exam expects you to convert experiments into reproducible, automated, and governed pipelines. This chapter covers Vertex AI Pipelines (built on Kubeflow Pipelines and TFX), CI/CD/CT automation, and ML Metadata for lineage.
Why orchestrate at all?
A pipeline turns a chain of steps — ingest, validate, transform, train, evaluate, deploy — into a DAG (directed acyclic graph) of containerized, parameterized components. Benefits: reproducibility, caching, lineage, and the ability to trigger continuous training (CT) when data drifts or code changes.
Key fact — Vertex AI Pipelines is serverless. You do not manage a GKE cluster as you did with self-hosted Kubeflow. You compile a pipeline to a JSON/YAML spec and submit it; Google provisions and tears down compute per run. It runs pipelines authored with the Kubeflow Pipelines (KFP) SDK v2 or TFX.
Authoring options: KFP vs TFX
| Aspect | KFP SDK (v2) | TFX |
|---|---|---|
| Best for | Custom, flexible Python components | Standardized TensorFlow production pipelines |
| Components | @component / @dsl.pipeline decorators | Prebuilt: ExampleGen, StatisticsGen, SchemaGen, Transform, Trainer, Evaluator, Pusher |
| Data validation | Manual / TFDV calls | TFDV + TFMA built in |
| Output | Compiled IR YAML | Compiled pipeline run on Vertex |
7. Monitor AI Solutions: Skew & Drift, Performance, and Responsible AI
A model that scored well at validation is not a model that will perform forever. The world the model was trained on keeps moving, and silent degradation is the single most common cause of business loss from a deployed ML system. Monitoring closes the MLOps loop: it detects when reality has diverged from training assumptions, triggers retraining, and guards fairness and safety in production. On the exam, expect scenarios where accuracy is quietly falling and you must pick the correct detection tool and the correct response.
Training–Serving Skew vs. Drift
These two terms are confused constantly and the exam loves to test the distinction.
Training-serving skew is a discrepancy between how features are computed at training time and at serving time, present from day one (e.g. a different preprocessing library, time-zone handling, or a feature available offline but not online). It is a code/pipeline bug, not a data-evolution problem.
Drift appears over time after deployment. Data (feature/input) drift = the distribution of incoming features P(X) changes. Concept drift = the relationship P(y|X) changes, so the same inputs now map to different outcomes (a new fraud pattern, post-pandemic shopping). Prediction drift = the distribution of model outputs shifts.
8. Exam Strategy, Mock Exam & Final Review
This final chapter converts everything you have learned into a repeatable test-taking system for the Google Cloud Professional Machine Learning Engineer exam. The exam is ~2 hours, 50–60 multiple-choice and multiple-select questions, no penalty for wrong answers, and is scored pass/fail (Google does not publish a numeric cut score — aim comfortably above ~70%). Roughly 80% of questions are scenario-based: a paragraph describes a business goal, constraints, and a partial pipeline, then asks for the best next action.
How questions are built — and how to break them down
Every scenario embeds 3 to 5 constraint signals. Train yourself to highlight them before reading the options: latency budget, cost ceiling, team skill level, data volume, retraining cadence, governance/PII, and "managed vs. custom." The correct answer is almost always the option that satisfies all stated constraints with the least operational overhead — Google rewards managed services (Vertex AI, BigQuery ML, AutoML) over hand-rolled infrastructure.
Pacing math: 120 min ÷ 55 questions ≈ 2.1 min/question. Do a first pass answering everything you know in ~75 min, leaving ~40 min for flagged items and ~5 min final review. Answer every question — blanks score zero, guesses have ~25% upside.
The full lesson continues in the interactive course on this page.