PMLE domain - 16% of the exam

Collaborating Within and Across Teams to Manage Data and Models

Collaborating Within and Across Teams to Manage Data and Models is 16% of the PMLE exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

44
Practice questions
3
Objectives
44
Medium

Where people go wrong

  • Swapping what Dataflow and Dataproc run

    The wrong answers swap the two services: Beam pipelines are said to run on Dataproc, Dataflow is called batch-only or streaming-only, or its runtime is treated as Spark. Dataproc runs managed Spark and Hadoop clusters, so existing Spark code ports with little change, but the team sizes and tunes the cluster. Dataflow runs Apache Beam on a serverless autoscaling service with no cluster to provision, and one pipeline definition executes as both batch and streaming.

    See it in a sample question
  • Reaching for pandas at terabyte scale

    The wrong answers offer pandas for a 4 TB table and for 8 TB of raw images. Pandas needs the whole dataset in one machine's memory, so it fails at that scale. BigQuery runs SQL as a distributed job across many slots where the data already sits, with no extraction. Dataflow autoscales workers for per-image work such as decoding, resizing and augmentation, so neither large job needs an in-memory tool.

    See it in a sample question
  • Giving the Feature Store a job it does not do

    The wrong answers credit the Agent Platform Feature Store with drift-triggered retraining, encryption or masking of fields, prediction caching, or translating pipeline code into SQL or Spark. None of these makes training and serving read the same value. The Feature Store is a shared registry of feature definitions with an offline store for point-in-time training reads and an online store serving the same feature at low latency, which is what removes training-serving skew.

    See it in a sample question
  • Confusing Experiments with ML Metadata

    The wrong answers swap the two records. An Experiment groups runs so their parameters and metrics can be compared and ranked, but a dashboard of runs does not link an artefact to the execution that produced it. ML Metadata stores artefacts, executions and their input and output relationships, so a deployed model can be traced back to its dataset version. Ranking runs is not its job, and pipeline steps write to it without extra logging code.

    See it in a sample question
  • Authenticating a shared notebook with keys or personal identities

    The wrong answers authenticate a shared notebook with an exported service account key, a key emailed to the team, an encrypted key committed with its passphrase, per-user credentials or interactive user login. Each leaves long-lived key material exposed or attributes activity to individuals. The supported design attaches a dedicated service account to the runtime, set in a Colab Enterprise runtime template, so Application Default Credentials supply short-lived tokens and audit logs show one principal.

    See it in a sample question

Objectives in this domain

Sample questions from this domain

Free sampleCollaborating Within and Across Teams to Manage Data and Modelsmedium

A team is building a continuously running pipeline that cleans, parses, and tokenises text records as they arrive from a streaming source, with the same transformation logic later needed for a large historical backfill. They want one programming model that runs both streaming and batch on a managed, autoscaling service. Which statement most accurately describes Dataflow's role here compared with Apache Spark?

  • ADataflow can only process bounded batch data, so the streaming portion must be handled separately by Spark Structured Streaming before the backfill runs.
  • BDataflow and Spark both require the engineer to write SQL queries only, so the tokenisation logic cannot be expressed as custom transform code in either system.
  • CDataflow is an in-memory single-node library suited to small datasets, while Spark is the only one of the two that can distribute the parsing work across machines.
  • DDataflow runs Apache Beam pipelines as a fully managed service with unified batch and streaming semantics and autoscaling, whereas a self-managed Spark cluster needs the team to provision and tune the workers themselves. Correct
Use Dataflow for managed, autoscaling Beam pipelines that share one batch-and-streaming model, reducing cluster operations compared with self-managed Spark. Dataflow runs Apache Beam, which unifies batch and streaming under a single API, and provisions and autoscales workers as a managed service; with self-managed Spark the team owns cluster sizing and tuning, which is the operational contrast the scenario tests.

Why A is wrong: It is tempting because batch backfills are mentioned, but it is wrong: Dataflow handles unbounded streaming and bounded batch with the same Beam pipeline, so there is no need to offload the streaming part to Spark.

Why B is wrong: This is tempting if you conflate these engines with a SQL warehouse, but it is wrong: both Beam pipelines on Dataflow and Spark jobs let you write custom code for transforms like tokenisation, not just SQL.

Why C is wrong: This is tempting because in-memory tools exist for small data, but it is wrong: Dataflow is a distributed managed service that scales across many workers, so it is not a single-node library and both engines distribute work.

Why D is correct: Dataflow executes Apache Beam, whose model treats batch and streaming as one API, and the service autoscales workers without manual cluster management; running Spark directly typically means the team sizes, scales, and tunes the cluster, which is the operational difference the scenario asks about.

Free sampleCollaborating Within and Across Teams to Manage Data and Modelsmedium

A retail data team must join two years of clickstream logs stored as 4 TB of Parquet in Cloud Storage with a customer dimension table in BigQuery, producing an aggregated feature table for model training. The transformation involves several wide joins and window functions over the full history, runs as a one-off backfill, and the team wants to write standard SQL rather than maintain cluster infrastructure. Which approach should the team choose for this preprocessing job?

  • AProvision a Dataproc cluster running Apache Spark, read both sources with the connectors, and express the joins and window functions in Spark SQL.
  • BBuild a streaming Dataflow pipeline with the Apache Beam SDK that reads the Parquet files and emits aggregated features continuously.
  • CDownload the Parquet files to a single large virtual machine and process the joins with the pandas in-memory framework.
  • DLoad the Parquet files into BigQuery as an external table and run the joins and window functions as a scheduled BigQuery SQL query. Correct
Choose BigQuery for large bounded SQL-based joins and window aggregations when avoiding cluster management matters. BigQuery is a serverless analytics engine that scales terabyte joins and window functions automatically, reads Parquet via external tables, and needs no provisioned cluster, so it satisfies the scale, SQL, and no-infrastructure constraints together.

Why A is wrong: Spark on Dataproc can express the same logic and is tempting for large Parquet workloads, but it forces the team to size, run, and tear down a cluster, which contradicts their wish to avoid maintaining infrastructure for a one-off backfill.

Why B is wrong: Dataflow suits continuous or event-time pipelines, so it sounds modern here, but a streaming job is the wrong shape for a bounded historical backfill and requires Beam coding rather than the standard SQL the team asked for.

Why C is wrong: Pandas is the right reach for small datasets and feels simple, but 4 TB will not fit in a single machine's memory, so this in-memory approach fails at the required scale.

Why D is correct: BigQuery handles multi-terabyte joins and window functions in standard SQL with no cluster to manage, and external tables let it read the Parquet directly alongside the existing dimension table, matching every stated constraint.

Free sampleCollaborating Within and Across Teams to Manage Data and Modelsmedium

Two teams independently engineer the feature 'customer_30d_purchase_count' in their own pipelines, and a serving model later shows degraded accuracy because the feature value computed at training time differs from the value computed at serving time. The organisation wants to consolidate feature definitions so the same logic and values are shared across teams and reused consistently. Which statement best describes how the Agent Platform Feature Store addresses this?

  • AIt provides a central registry and shared store of feature definitions and values that both training and serving read from, so teams reuse one consistent feature and reduce training-serving skew. Correct
  • BIt encrypts each team's raw training files so the duplicated feature pipelines can keep running separately without exposing personally identifiable information to other teams.
  • CIt automatically rewrites each team's preprocessing code into SQL so the pipelines execute faster, which by itself guarantees the two computed values converge.
  • DIt acts purely as a dashboard that visualises the divergence between training and serving values but leaves each team to maintain its own independent feature pipeline.
Use a Feature Store as a shared registry so training and serving read identical feature values, reducing duplication and training-serving skew. Training-serving skew arises when features are recomputed by different code paths; the Feature Store centralises definitions and serves the same values to both training and online inference, giving teams one reusable source of truth instead of duplicated pipelines.

Why A is correct: The Feature Store centralises feature definitions and the underlying values so training and online serving consume the same source, which is exactly what removes duplicated logic across teams and curbs the training-serving skew described in the scenario.

Why B is wrong: It is tempting because PII protection is a real concern in feature pipelines, but it is wrong: encryption of raw files does not consolidate feature definitions or stop training and serving from computing different values.

Why C is wrong: This is tempting because faster execution sounds beneficial, but it is wrong: the Feature Store does not transpile arbitrary pipeline code to SQL, and speeding up two separate pipelines does not make them produce the same value.

Why D is wrong: This is tempting because monitoring divergence is useful, but it is wrong: a Feature Store is a managed serving and registry layer, not merely a dashboard, and its purpose is to share definitions rather than leave pipelines duplicated.

Free sampleCollaborating Within and Across Teams to Manage Data and Modelsmedium

A data science team runs many quick, ad hoc training runs to compare hyperparameters for a tabular model, logging metrics and parameters for each run so they can sort and visualise the results side by side. They do not yet need to schedule, orchestrate, or chain these runs into a repeatable workflow. Which capability is the most appropriate fit for this stage of their work?

  • AExperiments on the Agent Platform, because it is designed to log, group, and compare individual runs by their parameters and metrics for analysis. Correct
  • BKubeflow Pipelines, because it provides a managed cluster that automatically tunes every hyperparameter combination without any code from the team.
  • CAgent Platform Pipelines, because comparing runs always requires a scheduled and orchestrated workflow before any metrics can be logged.
  • DML Metadata on its own, because it both stores artifact lineage and renders the run comparison charts the team wants to see.
Choose Experiments for tracking and comparing individual ad hoc runs before orchestration is needed, rather than a pipeline service. Experiments groups individual runs and lets you compare their logged parameters and metrics, which is the right tool for ad hoc tuning comparison; pipelines exist to orchestrate repeatable multi-step workflows, a need that has not yet arisen here.

Why A is correct: Correct: Experiments is purpose-built for tracking and comparing many individual runs by their logged parameters and metrics, which matches an ad hoc comparison stage that does not yet need orchestration.

Why B is wrong: Kubeflow Pipelines is tempting because it can run training and supports tuning components, but it is built to orchestrate multi-step workflows and does not auto-tune combinations without authored components, so it is heavier than ad hoc comparison needs.

Why C is wrong: Pipelines is tempting because it can run training steps, but logging and comparing metrics does not require an orchestrated workflow first, so introducing a pipeline adds unnecessary structure at this stage.

Why D is wrong: ML Metadata is tempting because it records run-related artifacts and lineage, but it is a metadata store rather than an interactive run-comparison and visualisation surface, so it does not by itself meet the comparison need.

Free sampleCollaborating Within and Across Teams to Manage Data and Modelsmedium

A data science team wants to prototype a PyTorch model in Colab Enterprise. Several analysts need to open and run the same notebook, but the team lead requires that the notebook execute under a dedicated service account rather than each user's personal identity, so that data access is governed centrally and audit logs attribute resource use to one principal. What is the correct way to configure this?

  • AAsk every analyst to set GOOGLE_APPLICATION_CREDENTIALS to a downloaded service account key file inside each notebook session before running cells.
  • BHave each analyst run the notebook under their own user identity and rely on a shared IAM group to make every analyst's access identical to the service account.
  • CAttach a runtime template to the notebook that specifies the dedicated service account, and grant each analyst the role needed to use that runtime template. Correct
  • DConfigure organisation policy to force all Colab Enterprise runtimes in the project onto the default Compute Engine service account for execution.
In Colab Enterprise, the runtime template defines the service account a notebook executes as, centralising data access and audit attribution. Colab Enterprise separates the notebook from its compute: a runtime template specifies the machine and the service account, so binding the dedicated account in the template makes every runtime created from it execute as that single governed principal.

Why A is wrong: Pointing the environment variable at a downloaded key would make code run as the service account, but distributing exported key files is an insecure pattern that the platform's managed identity model is designed to avoid, so this is not the supported approach.

Why B is wrong: A shared IAM group can align permissions, but the runtime would still execute as each personal user, so audit logs would attribute activity to individuals rather than to the single principal the lead requires.

Why C is correct: Colab Enterprise runtimes are created from runtime templates, and the template defines which service account the runtime executes as, so centralising the account there governs data access for everyone who uses that template.

Why D is wrong: Forcing the default Compute Engine account would centralise execution onto one over-privileged identity shared by unrelated workloads, which defeats least privilege and is not how a dedicated, scoped account is assigned to a notebook.

Other domains in this exam

See also the PMLE cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by Google Cloud. Original, blueprint-aligned practice material only.