Google Cloud Machine Learning Engineer

The cheapest model to maintain is the one you did not hand-build. You use BigQuery ML for models next to the data, call ready-made ML APIs, and train with AutoML, then decide when custom code is justified.

• BigQuery ML model types and SQL syntax
• Prebuilt ML APIs for vision, language and speech
• AutoML for tabular, image and text data
• Importing and remote models in BigQuery ML
• Comparing low-code results with a baseline
• Deciding when to move to custom training

You build A low-code model built in BigQuery ML and compared with an AutoML run on the same data.

Foundation models now solve many tasks without training. You find and call models in Model Garden, design prompts, ground answers with retrieval using Agent Builder, and decide when tuning is worth it.

• Exploring Model Garden and choosing a model
• Prompt design and parameters
• Grounding with your own data
• RAG with Vertex AI Agent Builder
• Evaluating generated output
• Prompting versus tuning versus training

You build A grounded question-answering service over company documents with evaluation results.

Models inherit the flaws of their data. You explore data in BigQuery and Cloud Storage, clean and transform it at scale, handle personal data correctly and keep reusable features in a feature store.

• Exploring data in BigQuery and Cloud Storage
• Cleaning, encoding and scaling
• Large-scale preprocessing with Dataflow
• Finding and masking personal data
• Feature stores and feature reuse
• Avoiding leakage in train and test splits

You build A preprocessing pipeline that cleans a dataset, masks personal data and publishes features.

Prototypes are cheap, but results must be repeatable. You work in managed notebooks, record parameters and metrics with Vertex AI Experiments, and compare runs, including evaluation runs for generative models.

• Vertex AI Workbench notebooks and environments
• Tracking runs with Vertex AI Experiments
• Reproducible code, data and environments
• Comparing runs and choosing a candidate
• Evaluating generative AI experiments
• Sharing results with teammates

You build A tracked experiment series that lets a colleague reproduce and compare every run.

Moving from a notebook to production training changes what matters. You choose frameworks and architectures, package training code, run distributed and custom jobs, and match GPUs or TPUs to the model.

• Choosing frameworks and model architectures
• Packaging training code in custom containers
• Custom training jobs on Vertex AI
• Distributed training strategies
• GPUs and TPUs: matching hardware to the job
• Handling training failures and checkpoints

You build A containerized training job that runs distributed on accelerators with checkpoints.

Tuning is where a decent model becomes a good one, within budget. You run hyperparameter searches, spot overfitting, and fine-tune foundation models on your own examples while checking what was gained.

• Hyperparameter tuning jobs and search strategies
• Overfitting, regularization and early stopping
• Preparing data for fine-tuning
• Supervised and parameter-efficient tuning of foundation models
• Evaluating a tuned model against the base model
• Cost control for tuning runs

You build A tuned model, with a hyperparameter search report and a comparison to a baseline.

How a model is served decides its cost and its usefulness. You run batch and online inference, register versions in a model registry, and package models with custom prediction code when the defaults do not fit.

• Batch versus online prediction
• Deploying models to Vertex AI endpoints
• Custom prediction containers and pre-built ones
• The model registry and versioning
• Latency and throughput measurement
• Serving foundation models

You build A model registered, deployed to an endpoint and also scored in batch.

Real traffic is uneven and models change. You scale endpoints with the right hardware, split traffic between versions for A/B tests, and roll out or roll back safely.

• Autoscaling endpoints and sizing replicas
• Choosing CPU, GPU or TPU for serving
• Traffic splitting between model versions
• A/B tests and canary rollouts
• Cost per prediction
• Rolling back a model version

You build A two-version deployment with a traffic split and a rollback procedure.

A model you cannot rebuild on demand goes stale. You build end-to-end pipelines with Vertex AI Pipelines, using Kubeflow and TFX components, and add validation steps that stop bad data or bad models early.

• Pipeline components, inputs and outputs
• Vertex AI Pipelines with Kubeflow Pipelines
• TFX components for validation and transformation
• Data and model validation gates
• Scheduling and triggering runs
• Caching and cost of pipeline runs

You build An end-to-end training pipeline with validation gates that blocks bad data.

Models need the same release discipline as code, plus a record of where they came from. You build CI/CD with Cloud Build, set retraining policies, and track metadata and lineage so any prediction can be traced back.

• CI/CD for pipelines and models with Cloud Build
• Testing ML code and data
• Promotion from registry to production
• Retraining triggers and policies
• Metadata and lineage tracking
• Auditing a model from prediction back to data

You build A CI/CD setup that tests, builds and promotes a model with lineage recorded.

A model that was right at launch can be wrong in months. You monitor for training-serving skew and feature drift, explain individual predictions, check for bias, and set alerts that trigger action.

• Model Monitoring for skew and drift
• Choosing features and thresholds to watch
• Explaining predictions with feature attributions
• Detecting bias and unfair outcomes
• Common failure patterns in live models
• Alerts and responses that close the loop

You build A monitoring configuration with skew and drift alerts and prediction explanations.

Build one system end to end. You choose the lowest-effort approach that fits, prepare data, train and serve, automate retraining and monitor, then explain each decision to a reviewer.

• Framing the problem and picking the approach
• Preparing data and training
• Serving and scaling
• Automating and monitoring
• Presenting and defending the system

You build A working ML system with data prep, training, serving, pipeline and monitoring.