mediumMultiple Select
Google PCA Practice Question: Moving a legacy monolithic application to a…
A company is moving a legacy monolithic application to a microservices architecture on Google Cloud. They want to minimize operational overhead and automatically scale each service independently. Which TWO compute services should they consider? (Choose two.)
⚠ Common exam trap
The trap is that GKE Standard and Compute Engine MIGs sound 'managed,' but the exam expects you to recognize that only Cloud Run and GKE Autopilot remove node-level operational overhead.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Cloud Run
Cloud Run (A) is correct because it is a fully managed serverless container platform that abstracts away all infrastructure, scales each containerized microservice automatically (including to zero), and charges only for resources used, directly minimizing operational overhead. GKE Autopilot (E) is correct because it is a fully managed Kubernetes mode where Google provisions and manages the nodes and control plane, while still providing Kubernetes orchestration that lets each microservice scale independently with minimal operational burden. Compute Engine with managed instance groups (B) is not ideal because it requires managing VMs, OS patching, and capacity planning, which increases operational overhead. GKE Standard (C) is not the best fit because, although it orchestrates containers, the cluster's nodes and infrastructure remain the customer's responsibility, adding operational overhead compared to Autopilot. Cloud Functions (D) is not appropriate here because it is an event-driven FaaS for short-lived functions, not a general platform for running long-lived containerized microservices.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✓
Cloud Run
Why this is correct
Cloud Run runs containerised services serverlessly, scaling each one independently from zero based on incoming requests. This directly satisfies the stem's constraints: minimal operational overhead, since no cluster or nodes are managed, and per-service automatic scaling, which the monolithic-to-microservices migration requires.
- ✗
Compute Engine with managed instance groups
Why it's wrong here
Managed instance groups still require you to build and patch VM images, so operational overhead stays high and per-service autoscaling is coarse. They suit lift-and-shift workloads needing VM-level control, but the stem demands minimal ops and independent service scaling, which serverless or container platforms deliver.
- ✗
Google Kubernetes Engine (GKE) Standard
Why it's wrong here
GKE Standard leaves node pool provisioning, upgrades and capacity planning to you, so operational overhead is not minimised. It is the right choice when you need node-level control or custom networking, but the stem's low-overhead requirement points to a fully managed serverless container runtime instead.
- ✗
Cloud Functions
Why it's wrong here
Cloud Functions runs single-purpose event handlers with tight execution timeouts and no persistent service process, so it cannot host long-running microservice workloads. It is correct for event-driven glue code, but the stem needs independently scalable always-on services, which container platforms provide.
- ✓
Google Kubernetes Engine (GKE) Autopilot
Why this is correct
GKE Autopilot provisions and manages the node infrastructure itself, so the platform team avoids patching and capacity planning, directly satisfying the minimal-operational-overhead constraint. Per-pod resource requests drive independent horizontal scaling of each microservice, meeting the requirement to scale services separately without managing a node pool.
Quick reference
Cloud Service Model Comparison
| Model | You Manage | Provider Manages | Examples |
|---|---|---|---|
| IaaS | OS, runtime, apps, data | Hardware, hypervisor, networking | EC2, Azure VMs, GCP Compute Engine |
| PaaS | Apps and data | OS, runtime, middleware, hardware | Elastic Beanstalk, Azure App Service |
| SaaS | Data and settings only | Everything else | Microsoft 365, Salesforce, Workday |
| FaaS / Serverless | Function code only | Infra, scaling, runtime | Lambda, Azure Functions, Cloud Run |
| CaaS | Containers and apps | Kubernetes, OS, hardware | EKS, AKS, GKE |
Go deeper
Related to this question
Learn chapter
Virtual Machine Instances in Compute Engine
Key term
Service
A service is a software component or system that performs a specific function and is available to be used by other programs or users over a network.
Key term
GKE Autopilot
GKE Autopilot is a managed mode of Google Kubernetes Engine that automatically handles node provisioning, scaling, and maintenance so you only pay for your running pods.
About these practice questions
One of 807 original PCA practice questions on Courseiva, each with a full explanation and wrong-answer analysis — not exam dumps or protected exam content. Learn why practice questions differ from exam dumps →
JA
Written and reviewed by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
Last reviewed September 2026 · checked against the official Google Cloud exam blueprint
This PCA practice question is part of Courseiva's free Google Cloud certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the PCA exam.