PMLE domain - 12% of the exam

Architecting Low-Code AI Solutions

Architecting Low-Code AI Solutions is 12% of the PMLE exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

31
Practice questions
2
Objectives
31
Medium

Where people go wrong

  • Treating OCR as structured document extraction

    The wrong answers offer Vision API text detection, Translate or label detection for invoices and claim forms, and they offer Document AI for photographs of signs. The Vision API does general image understanding and returns raw detected text. Document AI parses document layout and returns labelled entities, key-value pairs and totals with confidence scores. The boundary is the task, so arbitrary images with no fixed layout go to Vision.

    See it in a sample question
  • Using sampling and output settings to cut input cost

    When the bill is dominated by a repeated prompt prefix, the wrong answers raise temperature, change the output-token limit, switch to a cheaper model or turn off streaming. None of these changes how many input tokens are reprocessed on each call, so the unchanged prefix is still billed in full every time. Context caching stores the repeated prefix once, bills the cached tokens at a reduced rate and skips their recomputation, so only the short per-call text is charged as fresh input.

    See it in a sample question
  • Confusing prompt-time context with changing the weights

    The wrong answers fine-tune weekly to keep answers current, describe grounding as fine-tuning, or pack thousands of examples into one prompt to teach labelling conventions. Retrieval and grounding fetch current passages at inference time and leave the weights untouched, so revised documents appear immediately. Supervised fine-tuning updates the model from prompt and target pairs, which is what lets a model learn house style or routing labels.

    See it in a sample question
  • Matching a BigQuery ML model type to the wrong task

    The wrong answers pick clustering for a churn label, ARIMA_PLUS for per-customer revenue, logistic regression for unlabelled segmentation, and boosted trees for a time series. The model type follows the target. A labelled yes-or-no outcome needs logistic regression, a continuous value needs linear regression, unlabelled grouping needs k-means, and a series over time needs ARIMA_PLUS, which models seasonality and holidays itself.

    See it in a sample question
  • Keeping preprocessing outside the model

    To stop training-serving skew, the wrong answers keep manual SQL, a shared lookup table, a training-only pipeline or hand-coded steps. Each leaves two code paths that can drift apart. Defining standardisation and encoding in the TRANSFORM clause of CREATE MODEL stores the preprocessing with the model, so ML.PREDICT reapplies the identical steps automatically.

    See it in a sample question

Objectives in this domain

Sample questions from this domain

Free sampleArchitecting Low-Code AI Solutionsmedium

An insurer wants to extract named fields such as policy number, claimant name, and total amount from millions of scanned claim PDFs that follow a small set of fixed layouts. The team needs structured key-value output, high accuracy on these specific forms, and the lowest ongoing per-document cost rather than free-form reasoning. Which Google Cloud approach best fits this requirement?

  • APrompt a general Gemini model with each page image and ask it to return the fields as JSON, relying on its multimodal reasoning over the scans.
  • BTrain a Document AI custom extractor on the known layouts so it returns the policy fields as structured key-value pairs per document. Correct
  • CUse the Vision API text detection feature to read all characters, then write rules to locate each field by its position on the page.
  • DTranslate every document with the Translate API first to normalise the text, then apply a keyword search to pull out the required values.
Choose Document AI custom extractors for high-accuracy structured field extraction from fixed-layout documents at scale. Fixed-layout, high-volume field extraction is exactly what Document AI custom extractors are trained for: they learn the form structure and output typed key-value entities, giving better accuracy and lower per-document cost than general multimodal prompting or raw OCR plus hand-written positional rules.

Why A is wrong: Gemini can read documents, but per-document inference on millions of pages is costly and its general reasoning is less consistent for fixed-layout field extraction than a model trained on those forms, so it does not meet the accuracy-and-cost goal best.

Why B is correct: Document AI custom extractors are purpose-built to learn fixed layouts and emit structured key-value entities with high accuracy at a predictable per-page price, which directly satisfies the structured-output, accuracy, and low-cost requirements.

Why C is wrong: Vision text detection returns raw characters without document structure, so brittle position rules are needed to recover key-value pairs; this tempts teams who think OCR alone is enough but it lacks the form understanding Document AI provides.

Why D is wrong: Translate changes language and does nothing to detect layout or extract structured fields, so it is the wrong service entirely for a same-language field-extraction task even though it sounds like a preprocessing step.

Free sampleArchitecting Low-Code AI Solutionsmedium

A legal-tech team sends every Gemini request on Vertex AI with the same 30-page contract-review playbook as a system preamble, followed by a short, unique clause to assess. The playbook is identical across thousands of calls each hour and dominates the input-token count, while the per-call clause is tiny. The team wants to stop paying full input-token price for re-sending the unchanged playbook on every call, while still treating each clause independently. Which change to the request configuration most directly cuts the repeated input-token cost?

  • ALower the maximum output token limit on each call so the model returns shorter assessments and the overall token bill falls.
  • BRegister the playbook as cached context with a time-to-live, then reference that cache on each request so only the short clause is charged as fresh input tokens. Correct
  • CSwitch the calls to a smaller, cheaper Gemini model variant so each token of the playbook costs less to process.
  • DRaise the request temperature so the model converges on answers faster and consumes fewer tokens per call.
Context caching bills a large unchanged prompt prefix once at a reduced rate, cutting cost when the same context is reused across many calls. Gemini context caching persists a fixed prefix server-side under a TTL; calls referencing the cache pay a reduced cached-input rate for that prefix and full price only for the new per-request tokens, directly removing the redundant cost of re-sending an identical large playbook.

Why A is wrong: Capping output tokens is tempting because it does trim the bill, but the cost here is dominated by repeated input tokens from the playbook, and output limits leave that input re-send untouched.

Why B is correct: Context caching stores the large unchanged prefix once and bills subsequent calls that reference it at a reduced cached rate, so only the small per-call clause is charged as full input, which is exactly the repeated-prefix cost driver here.

Why C is wrong: A cheaper model lowers the unit price but you still pay to re-process the entire playbook on every call, and it may degrade the assessment quality, so it does not target the redundant re-sending.

Why D is wrong: Temperature controls output randomness, not token accounting, so it has no effect on the input-token cost of resending the playbook and is a misunderstanding of what the parameter does.

Free sampleArchitecting Low-Code AI Solutionsmedium

A support team needs Gemini to answer customer questions strictly from their internal policy documents, which run to tens of thousands of pages and are revised weekly. The team has little machine-learning expertise, wants answers to reflect the latest revisions without retraining, and must keep responses grounded in the source text. Which approach should the team adopt to meet these constraints?

  • AFine-tune a Gemini model on the full policy corpus each week so the latest wording is absorbed into the model weights before queries arrive.
  • BPaste the entire policy corpus into a single very large prompt for every question so the model always sees the complete current text.
  • CBuild a retrieval-augmented generation pipeline that fetches the relevant policy passages and passes them to Gemini as grounding context at query time. Correct
  • DSelect a larger model from Model Garden and raise its temperature so it draws on broader knowledge when policies change.
Adopt retrieval-augmented generation to keep Gemini answers grounded and current without retraining when source documents change often. When source content is large and frequently revised, retrieval-augmented generation supplies the relevant up-to-date passages as context at inference time, so the model grounds its answer in the latest text without any retraining, which fine-tuning, prompt-stuffing, and model swaps cannot achieve.

Why A is wrong: Weekly fine-tuning on a huge corpus is expensive, demands ML skill the team lacks, and bakes facts into weights that still go stale between runs, so it fails the low-effort, always-current, and grounded requirements.

Why B is wrong: Tens of thousands of pages exceed practical context limits and would make each call slow and costly; stuffing the whole corpus per query is tempting because it is simple but it does not scale and wastes tokens on irrelevant material.

Why C is correct: Retrieval-augmented generation injects the current source passages into the prompt at query time, so updated documents are reflected immediately without retraining and answers stay grounded in the retrieved text, matching every stated constraint.

Why D is wrong: A bigger model and higher temperature add capacity and randomness but neither grounds answers in the internal documents nor reflects weekly revisions, so the responses can drift from the authoritative source text.

Free sampleArchitecting Low-Code AI Solutionsmedium

A data team holds millions of labelled customer rows in BigQuery and wants to predict which customers will churn next quarter. They have strong SQL skills, want the model trained without moving data out of the warehouse, and need results quickly for an initial baseline. Which model type should they create to suit this requirement?

  • AA BigQuery ML k-means clustering model, because it groups customers by behavioural similarity and assigns each a churn segment automatically.
  • BA BigQuery ML ARIMA_PLUS time-series model, because churn happens over time and forecasting future values is the natural way to predict it.
  • CA BigQuery ML linear regression model, because it fits the labelled data and outputs a numeric churn score the team can threshold later.
  • DA BigQuery ML logistic regression classification model, because a binary churn outcome is a supervised classification task trained directly on the labelled rows. Correct
A binary outcome predicted from labelled rows is a supervised classification task, suited to logistic regression in BigQuery ML. Churn is a categorical yes-or-no target, so a supervised classifier such as logistic regression is appropriate; it learns from the labelled feature rows and outputs per-customer class probabilities trained in place in the warehouse.

Why A is wrong: Clustering is tempting because it does group similar customers, but k-means is unsupervised and produces segments rather than a predicted churn label, so it cannot answer a supervised yes-or-no churn question.

Why B is wrong: Forecasting sounds relevant because churn unfolds over time, but ARIMA_PLUS predicts future numeric values of a single series and cannot classify individual customers as churners using their feature columns.

Why C is wrong: Linear regression is tempting because a churn score sounds numeric, but it predicts a continuous target and is the wrong fit for a categorical churn label, which a classification model handles correctly.

Why D is correct: Predicting churn versus no-churn is a binary supervised problem, and logistic regression in BigQuery ML trains on the labelled rows in place and returns class probabilities for each customer.

Free sampleArchitecting Low-Code AI Solutionsmedium

An analyst is building a logistic regression churn classifier in BigQuery ML. Several numeric features need standardisation and one high-cardinality categorical column needs encoding. The team worries that the same preprocessing might be applied inconsistently between training and the later ML.PREDICT calls, causing skew. Which technique addresses this concern most directly?

  • ARun separate SQL update statements to standardise and encode the raw columns before each ML.PREDICT call at serving time.
  • BDefine the standardisation and encoding inside the TRANSFORM clause of the CREATE MODEL statement so they are reapplied automatically at prediction. Correct
  • CIncrease the number of training iterations so the model learns to tolerate any differences in how features are scaled.
  • DStore one precomputed lookup table of encoded values and join it manually in both the training query and the prediction query.
Use the BigQuery ML TRANSFORM clause to bake preprocessing into the model so it is reapplied identically at prediction time. The TRANSFORM clause attaches feature engineering to the model definition itself, meaning ML.PREDICT runs the same standardisation and encoding learnt at training, which removes the divergent code paths that produce training-serving skew.

Why A is wrong: This is tempting because manual SQL preprocessing is flexible and familiar, but maintaining it separately for training and serving is exactly what causes training-serving skew when the two code paths drift apart.

Why B is correct: This is correct because the TRANSFORM clause stores the preprocessing with the model, so BigQuery ML reapplies the identical standardisation and encoding during ML.PREDICT, eliminating the training-serving skew the team fears.

Why C is wrong: This is tempting because more iterations often improve fit, but extra training cannot compensate for features that are scaled or encoded differently at prediction time, and it leaves the skew untreated.

Why D is wrong: This is tempting because a shared lookup table feels like a single source of truth, but it still relies on the analyst remembering to join it identically in both queries, so the inconsistency risk remains.

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.