Study guide

14.1 Serving Features Online with Feature Store

Google Cloud Professional Machine Learning Engineer PMLE

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Exam Overview & the Agent Platform Map

1.1 PMLE Exam Facts, Policies & the June 2026 Blueprint 1.2 From Vertex AI to Gemini Enterprise Agent Platform: The Product Name Map

2 Chapter 2: Low-Code ML with BigQuery ML

2.1 Choosing, Training & Predicting with BigQuery ML Models 2.2 Feature Engineering & Feature Selection in BigQuery ML 2.3 Fine-Tuning & Evaluating Gemini Models from BigQuery

3 Chapter 3: AutoML & Google Cloud AI APIs

3.1 Training Models with Agent Platform AutoML 3.2 Building with Document AI, Vision, Translation & Other AI APIs

4 Chapter 4: Foundation Models in Model Garden

4.1 Evaluating & Selecting Models in Model Garden 4.2 Building & Tuning Solutions with Gemini, Imagen, Veo & MaaS 4.3 Optimizing Gemini Applications for Cost, Latency & Availability

5 Chapter 5: Exploring, Preprocessing & Protecting Data

5.1 Organizing & Exploring Tabular, Text & Image Data 5.2 Choosing a Preprocessing Tool: BigQuery, Dataflow, Spark or Python 5.3 Creating & Consolidating Features in Agent Platform Feature Store 5.4 Protecting PII & Sensitive Data in ML Workflows

6 Chapter 6: Notebooks, Prototyping & Experiment Tracking

6.1 Workbench vs. Colab Enterprise: Secure, Collaborative Notebooks 6.2 Prototyping with PyTorch, scikit-learn, JAX & Model Garden in Notebooks 6.3 Experiment Environments, Tracking & Lineage with Experiments and ML Metadata

7 Chapter 7: Evaluating Predictive & Generative AI Solutions

7.1 Evaluation Metrics for Predictive Models 7.2 Evaluating Gen AI: Computation Metrics, Rubrics & LLM-as-a-Judge

8 Chapter 8: Choosing the Modeling Approach

8.1 Choosing the Model Type: ARIMA, Trees, DNNs & LLMs 8.2 Choosing the Product & Deployment Strategy 8.3 Modeling Techniques for Interpretability Requirements

9 Chapter 9: Training Data & Training SDKs

9.1 Organizing & Ingesting Training Data from Cloud Storage & BigQuery 9.2 Custom Training on Agent Platform: Containers, Jobs & Worker Pools 9.3 Kubeflow on GKE, AutoML & Tabular Workflows as Training Choices

10 Chapter 10: Troubleshooting, Hyperparameter Tuning & Fine-Tuning

10.1 Troubleshooting ML Training Failures 10.2 Hyperparameter Tuning on Agent Platform 10.3 Fine-Tuning Foundation Models & When to Tune

11 Chapter 11: Training Hardware & Distributed Training

11.1 Choosing CPUs, GPUs & TPUs for Training 11.2 Distributed Training: Data & Model Parallelism

12 Chapter 12: Deploying Models for Inference

12.1 Batch vs. Online Inference on Agent Platform 12.2 Serving Beyond Agent Platform Endpoints: Model Garden, Cloud Run & GKE 12.3 Prebuilt & Custom Serving Containers

13 Chapter 13: Model Versions, Rollouts & Inference Logic

13.1 Organizing & Versioning Models in Model Registry 13.2 Rollout Strategies: A/B Tests, Canaries & Traffic Splits 13.3 Inference Preprocessing & Postprocessing

14 Chapter 14: Scaling Online Serving

14.1 Serving Features Online with Feature Store 14.2 Public, Dedicated & Private Endpoints 14.3 Serving Hardware & Autoscaling for Throughput 14.4 Tuning Models for Production Training & Serving

15 Chapter 15: End-to-End ML Pipelines

15.1 Validating Data & Models in Pipelines 15.2 Agent Platform Pipelines with KFP: Components, Templates & Caching 15.3 Ensuring Consistent Preprocessing Between Training & Serving

16 Chapter 16: Orchestration with Managed Airflow & Ray

16.1 Orchestrating ML Workflows with Managed Service for Apache Airflow 16.2 Ray on Agent Platform for Distributed ML Workloads

17 Chapter 17: Automating Retraining & CI/CD/CT

17.1 Choosing a Retraining Policy 17.2 CI/CD/CT for ML with Cloud Build

18 Chapter 18: Securing AI Systems, Responsible AI & Explainability

18.1 Protecting AI Systems from Data & Model Exfiltration 18.2 Defending Gen AI Apps: Safety Filters, Model Armor & Regex Guardrails 18.3 Responsible AI: Detecting & Monitoring Bias 18.4 Model Explainability on Agent Platform

19 Chapter 19: Monitoring AI Solutions

19.1 Configuring Model Monitoring on Agent Platform 19.2 Training-Serving Skew, Data Drift, Concept Drift & Attribution Drift 19.3 Monitoring, Testing & Evaluating Gen AI Solutions in Production

14.1 Serving Features Online with Feature Store

Key Takeaways Explain This Topic AI

A feature view must be synced at least once before Feature Store can serve its feature values online.

Bigtable online serving handles terabyte-scale feature data, supports scheduled and continuous sync, and doesn't manage embeddings, which belong in Vector Search.

Feature Store fetches online values with fetchFeatureValues by entity ID, returning KEY_VALUE JSON or PROTO_STRUCT formats.

Direct write (preview) updates feature values in a Bigtable-served feature view with about 100 ms freshness, without changing the BigQuery source.

Bigtable online stores autoscale between a minimum and maximum node count around a CPU utilization target.

Last updated: September 2026

The exam guide's scaling section begins with managing and serving features using Agent Platform Feature Store . Section 5.3 covered creating features in BigQuery and the Feature Registry. This section is about getting those features to a model within milliseconds.

Online Serving Architecture

  • Resource Role
  • FeatureOnlineStore The serving cluster, with its serving type, node scaling, and encryption

FeatureView A logical set of features inside an online store, sourced from feature groups and features or directly from a BigQuery table or view

  • Data sync Copies the latest values from BigQuery into the feature view
  • fetchFeatureValues Reads a feature record for an entity ID at request time

A feature view must be synced at least once before it can serve.

Online Serving Types

Type Status Characteristics

Bigtable online serving Current, recommended Large data volumes (terabytes) with high durability. Scheduled and continuous sync . Supports CMEK . No embedding management , so use Vector Search for embeddings

Optimized online serving (public or Private Service Connect endpoint) Deprecated February 17, 2026. Shutdown February 17, 2027 Ultra-low latency plus embedding management, scheduled sync only. Migrate to Bigtable online serving

Bigtable online store capacity

Create the store with autoscaling settings: minimum node count, maximum node count, and a CPU utilization target . For example, 1-3 nodes at 50% CPU. Size minimum nodes for baseline traffic so lookups don't wait for scale-up.

Keeping Online Features Fresh

Mechanism How it works Freshness Notes

Scheduled sync A cron schedule re-syncs from BigQuery. You can also trigger a sync manually Minutes to hours, based on schedule Works for any serving type. BigQuery reads cost money, so don't over-sync

Continuous sync Syncs as new rows land in BigQuery Near real time for new records Bigtable serving plus registered feature groups, with the source in us , eu , or us-central1 . Updates and deletes in BigQuery aren't synced. A feature view with continuous sync can't be updated

Direct write (preview) Write values straight into a Bigtable-served feature view About 100 ms Doesn't update the BigQuery source. The next sync overwrites with any newer BigQuery value. Each feature view needs its own writes

Null handling: by default the store serves the latest non-null value, falling back to the most recent non-null historical value. To serve latest values including nulls , register the feature group with dense = true , use Bigtable online serving, and use scheduled sync.

Fetching Features in the Serving Path

A typical online inference request flow:

The client calls the app with customer_id=C123 and the transaction details.

The app, or a CPR preprocess() , calls fetchFeatureValues on the feature view for C123 . Results come back as KEY_VALUE JSON or PROTO_STRUCT .

The app merges the stored features (such as spend_30d and chargebacks_90d ) with request-time features (transaction amount, merchant).

It sends the combined instance to the model endpoint.

It logs the exact feature values used, for monitoring and future training. aiplatform.init(project="my-project", location="us-central1")

  • fos = FeatureOnlineStore("fraud_online_store")
  • fv = FeatureView("customer_features", feature_online_store_id=fos.name)
  • record = fv.read("C123") # latest values for this entity ID
  • Latency budgeting

If an end-to-end SLA is 80 ms, measure feature lookup p99 separately from model inference. Put the application, the online store, and the endpoint in the same region , and use private connectivity where possible.

Training-Serving Consistency

Online and offline features come from the same BigQuery-defined feature , which avoids re-implementing aggregations in application code.

Build training data with point-in-time lookups (offline serving or ML.FEATURES_AT_TIME ), so training values match what online serving would have returned then.

Log served feature values. Comparing them with training distributions is how training-serving skew monitoring works (Chapter 19).

Online Store vs. Other Low-Latency Options

  • Need Option
  • Per-entity feature values defined in BigQuery, served to models Feature Store online store (Bigtable serving)
  • Nearest-neighbor search over embeddings Vector Search
  • Application state unrelated to ML features The application's own database
  • Precomputed predictions for lookup A key-value store or a table read by the app (Chapter 12 hybrid patterns)
  • Security and Operations

IAM on online stores and feature views controls who can read features.

CMEK is supported for Bigtable online stores.

Monitoring: track fetch latency, error rates, sync job status, and Bigtable CPU.

Cost: online stores bill for provisioned nodes. Syncs incur BigQuery query costs, so match the sync frequency to how often the source changes.

Worked Scenario

A card issuer scores transactions in under 100 ms. Its features are 30-day spend aggregates (updated hourly in BigQuery) and a "transactions in last 10 minutes" counter.

Serve the hourly aggregates from a Bigtable online store with an hourly scheduled sync .

Write the 10-minute counter from the streaming Dataflow pipeline with direct write for about 100 ms freshness. Also write it to BigQuery so training data and the next sync stay consistent.

Fetch both in the scoring service, send to a Private Service Connect endpoint, and log the served values to BigQuery.