Google Cloud products, services, and solutions practice questions

Google Kubernetes Engine (GKE) with a custom container

Why wrong: Running a custom container on Google Kubernetes Engine for a one-time transformation forces the team to provision, secure, and maintain a Kubernetes cluster, including node pools and autoscaling policies, even though the job runs only once. After the job finishes, the cluster remains an idle cost unless manually torn down, adding operational overhead that defeats the purpose of serverless ephemeral processing. GKE is better suited for long-running, always-on services or complex multi-tier workloads requiring orchestration, not for a short-lived batch ETL task.

Dataproc Serverless with Spark job

Why wrong: Dataproc Serverless runs Apache Spark jobs in a fully managed, autoscaling environment that eliminates the need to create or manage a Dataproc cluster, making it the ideal choice for an occasional one-time transformation. The service launches a dedicated job execution environment, scales resources based on the workload, and shuts down automatically after completion, so the team only pays for the job's duration. Because it natively supports Spark's data processing APIs, the team can deploy an existing Spark transformation with minimal rewrites and no infrastructure management.

Cloud Functions triggered by Cloud Storage events

Why wrong: Cloud Functions is an event-driven function as a service designed for lightweight, quick tasks such as webhooks or real-time notifications, and it imposes hard limits on execution time and memory allocation that would constrain a large-scale transformation. A Cloud Storage event handler is invoked by object creation or changes, not by an explicit one-time job submission, requiring the team to stage a trigger file and work around the platform's stateless, single-function execution model. For substantial data processing, this leads to timeouts and out-of-memory failures rather than the distributed compute needed.

Schedule periodic exports to Cloud Storage and query with BigQuery

Why wrong: Not real-time and requires manual steps.

Upgrade the Cloud SQL instance to a higher machine type

Why wrong: Does not separate analytical from transactional workload.

Use BigQuery to directly query Cloud SQL via federated queries

Why wrong: Federated queries can impact performance; read replicas are purpose-built.

Custom IAM roles with fine-grained permissions

Why wrong: IAM roles can't filter rows; they grant access at the resource level.

Column-level security with classification tags

Why wrong: Column-level security controls access to columns, not rows.

Authorized views with a WHERE clause

Why wrong: Authorized views are for granting access to a view, but row-level policies are more direct.

Rebuild the application using serverless functions

Why wrong: Complete rewrite.

Refactor the application into microservices

Why wrong: Requires significant code changes.

Replatform to use Cloud Run

Why wrong: May require containerization and adjustments.

Cloud Operations Suite

Why wrong: Cloud Operations Suite (formerly Stackdriver) aggregates metrics, logs, and traces for monitoring, logging, and alerting across GCP. It observes the health of the application and infrastructure but does not execute build steps, run unit tests, or orchestrate artifact creation, so it plays no direct role in the CI/CD pipeline itself.

Cloud Deployment Manager

Why wrong: Cloud Deployment Manager is an infrastructure-as-code tool used to declaratively define GCP resources using YAML and Python templates. It provisions and manages resources like VMs, networks, and IAM roles, but it does not compile source code, run tests, or assemble container artifacts. Its scope is configuration management, not application CI/CD pipelines.

The runtime python39 is not available

Why wrong: Python 3.9 is a fully supported runtime for Cloud Functions, so the deployment command would not fail due to an unavailable runtime. As of the current environment, Cloud Functions supports Python 3.7 through 3.12, with 3.9 specifically listed in the official documentation. If the runtime were invalid, the deployment would error immediately with a message like 'Runtime specified is not supported', which does not occur here. Thus, this option is incorrect because the runtime is valid and the failure stems from a different configuration issue.

The function cannot be triggered by HTTP

Why wrong: Creating a Cloud Function with an HTTP trigger is a standard and fully supported deployment method; the gcloud command in question explicitly uses --trigger-http, which is accepted by the API. An HTTP-triggered function can be invoked via its assigned URL, and there is no restriction preventing HTTP triggers in Cloud Functions. If the trigger were unsupported, the deployment would reject the --trigger-http flag, but the command proceeds past that validation. Therefore, this option is wrong because HTTP triggering is a core feature, and the deployment failure is unrelated to the trigger type.

The timeout is too short for processing a 2-minute upload

Why wrong: The default Cloud Functions timeout is 60 seconds, but this command sets --timeout=540, which allows up to 9 minutes for execution. A typical 2-minute upload and file processing well within that 540-second window, so the timeout is not the cause of the failure. Even if processing were slow, the timeout would only trigger after 540 seconds, not after 120 seconds, meaning the function would not be prematurely terminated. Hence, this option is incorrect because the configured timeout is far more than adequate for a 2-minute workload.

Replatform to App Engine Flexible Environment

Why wrong: Replatforming to App Engine Flexible Environment is misaligned with a minimal-change goal because App Engine dictates a specific execution model: the application must conform to the platform's runtime, health-check, and deployment conventions, and often requires rewiring to use App Engine-specific services or environmental expectations. Even a monolithic app would need code alterations for startup, session handling, or filesystem access, converting a supposedly simple rehosting into a platform-specific refit.

Refactor to microservices on GKE

Why wrong: Refactoring the monolithic application into microservices on GKE is a re-architecture project, not a migration: it requires decomposing the codebase into separate services, redefining data ownership, reworking inter-process communication, and adopting service discovery and configuration mechanisms. That level of change is the opposite of minimal—it involves a substantial rewrite, new operational tooling, and a longer timeline, even though GKE can host the end result.

Use Cloud SQL's automated backups with a backup schedule every 4 hours.

Why wrong: Cloud SQL automated backups are designed to restore data after corruption or accidental deletion, not to serve as an active disaster recovery path. With a 4-hour frequency, they cannot meet a sub-5-minute RPO; the maximum data loss could be hours. Backups are also taken within the same regional scope unless copied elsewhere, so a regional outage would leave restore targets dependent on infrastructure that is down. Cross-region replication, not scheduled backups, provides near-continuous recovery.

Store container images in a regional registry in the same region.

Why wrong: Storing container images only in a regional registry in the same region as the primary GKE cluster means the images are unavailable if that region experiences a full outage. DR requires the ability to deploy workloads in a different region, and you cannot pull images from a registry that is down. Although Artifact Registry can be configured to replicate to another region, this option does not do that; it only adds an image copy, not a database failover mechanism. The critical state still lacks cross-region replication, so this does not help meet RPO/RTO.

Use Cloud CDN to cache static content.

Why wrong: Cloud CDN only caches static or commonly requested content at edge locations to reduce latency and egress costs; it does not replicate dynamic data or compute resources. In an outage scenario, CDN would serve stale cached objects if the origin is unreachable, but it cannot fail over applications or databases. A comprehensive DR plan still depends on cross-region replication and redundant compute infrastructure, while CDN merely improves availability and performance of cached assets. Relying on CDN to satisfy RPO/RTO is fundamentally a cache, not a recovery mechanism.

Use a managed instance group with autoscaling based on CPU utilization.

Why wrong: Not suitable for a single batch job; CPU utilization may not reflect job progress.

Redesign the pipeline to run on Cloud Dataflow and use streaming mode.

Why wrong: Streaming mode is for continuous data, not daily batch processing.

Increase the memory of the existing instance to a larger machine type.

Why wrong: Does not address varying data volumes and may not be cost-effective.

Migrate the application to Compute Engine with SQL Server on Windows VMs. Use Cloud SQL for SQL Server but keep the database on-premises for compliance.

Why wrong: Keeping the database on-premises while moving the application to Compute Engine introduces a hybrid topology that still requires a dedicated connection such as Cloud VPN or Interconnect, adding latency to every database call. This approach forfeits the operational benefits of Cloud SQL for SQL Server—such as automated backups, high availability, and patch management—while also complicating compliance because data residency and encryption controls remain split across environments. For a financial services company, the underlying concern should be addressed with a managed database that offers customer-managed encryption keys rather than retaining on-premises infrastructure.

Containerize the application and deploy on GKE with SQL Server in a container. Use Cloud SQL for SQL Server with encryption.

Why wrong: Containerizing the application and deploying on GKE introduces significant rework for a legacy monolith, including building Docker images, orchestrating sidecars, and redesigning configuration and networking. Running SQL Server itself in a container on GKE is not recommended for production because it adds stateful storage complexity, licensing overhead, and operational burden that a managed Cloud SQL instance would eliminate. Moreover, the option bizarrely pairs a containerized SQL Server with Cloud SQL for SQL Server, which is contradictory—you can use Cloud SQL or, if you insist on GKE, use a managed database such as Cloud SQL without hosting SQL Server in a container.

Migrate the application to Compute Engine instances with SQL Server on Windows VMs. Use Cloud VPN for connectivity. Enable encryption on the VMs and use SSL for SQL connections.

Why wrong: Migrating to Compute Engine instances for both application and SQL Server means you run your own SQL Server installation, requiring you to patch, back up, and manage HA yourself, which is a heavy operational lift for a financial services firm. Using Cloud VPN only addresses network connectivity between environments; it does nothing to provide a managed database or automated encryption, because encryption on VMs and SSL for SQL connections are still self-managed controls you must configure and maintain. The alternative of moving the database to Cloud SQL for SQL Server reduces this operational overhead and improves security posture uniformly.

Traffic is split evenly between the old and new revision.

Why wrong: Cloud Run's traffic splitting is defined through spec.traffic with weighted percentages. Since the configuration here explicitly pins traffic to a single revision with no split directive, the old revision continues to receive 100% of requests. A new revision is created but receives 0% traffic, so there is no even distribution between old and new.

The service becomes unavailable until the new revision is ready.

Why wrong: Cloud Run performs rolling deployments that preserve service availability. While the new revision is being prepared, the old revision remains active and continues to serve all incoming requests. Only after the new revision is healthy and ready does Cloud Run perform a cutover, so the service never becomes unavailable during the update.

Cloud Run automatically creates a new revision and routes traffic to it.

Why wrong: By default, Cloud Run automatically sets the latest ready revision to receive all traffic. However, an explicit traffic section that names a specific revision disables this automatic behavior. Therefore, although Cloud Run does create a new revision on deployment, it does not route any traffic to it because the traffic section overrides the default latest-revision routing.

Traffic continues to go to the old revision until the traffic section is updated.

Why wrong: When a Cloud Run service has a traffic section that explicitly specifies a revisionName, that revision becomes the sole recipient of traffic. New revisions created by later deployments are not automatically promoted; they stay at 0% until the traffic section is updated to include them or to change the assignment. This deterministic routing ensures that the old revision keeps serving until the configuration is deliberately modified.

Increase the HPA scale-up stabilization window to 10 minutes to prevent thrashing.

Why wrong: Increasing the HPA scale-up stabilization window to 10 minutes directly delays the controller's response to rising CPU utilization. During a latency spike, the HPA would wait for the full window before adding replicas, allowing pods to remain saturated and latency to worsen. Scale-up stabilization is rarely needed to prevent thrashing; that concern applies primarily to scale-down, where a longer window avoids flapping as load ebbs.

Enable session affinity on the backend service to keep users on the same pod.

Why wrong: Enabling session affinity on the backend service only routes a given client's requests to the same pod for the duration of the session. It has no effect on HPA decision-making, CPU utilization, or replica count, and it can actually worsen the bottleneck by creating hot spots where certain pods receive disproportionate load. This option addresses stickiness, not the underlying scaling latency or resource exhaustion.

Use a CronJob to proactively scale the backend service before expected peak hours.

Why wrong: A CronJob can only execute on a fixed schedule and cannot detect or react to an unpredicted spike that occurs between scheduled runs. It may be useful for expected peak hours, but the problem describes sudden, unpredictable load that requires a reactive autoscaler. Relying on CronJobs would leave the service unprotected outside those predefined windows and does not address the existing CPU-based scaling latency.

Cloud SQL

Why wrong: Cloud SQL is a managed relational database service for MySQL, PostgreSQL, and SQL Server, focused on online transaction processing (OLTP) with full ACID guarantees. It has limited storage capacity (typically a few terabytes) and relies on vertical scaling, making it impractical for petabyte-scale analytics or complex queries across billions of rows. Even though it supports SQL, it lacks columnar storage and the distributed execution engine needed for data warehouse workloads.

Cloud Bigtable

Why wrong: Cloud Bigtable is a wide-column NoSQL database engineered for high-throughput, low-latency point reads and writes, ideal for IoT and time-series data. It uses key-value access patterns and lacks SQL support, so it cannot perform joins, subqueries, or other complex analytical operations. Although it can store huge volumes, it is not a substitute for a data warehouse because analytics require application-level aggregation and scanning across rows.

Cloud Spanner

Why wrong: Cloud Spanner is a globally distributed relational database that offers horizontal scaling, strong consistency, and ACID transactions across regions, but it is designed for OLTP workloads. Its row-based storage and indexing prioritize low-latency single-row lookups and writes, not the scanning and aggregation of billions of rows required by analytics. While it supports SQL, its query engine is not built for the massive parallelism or columnar processing that BigQuery provides.

Google Kubernetes Engine (GKE)

Why wrong: GKE is a managed Kubernetes service, but "managed" means Google manages the control plane, not the entire experience. You still define clusters, node pools, resource requests/limits, and autoscaling policies for pods and nodes. Even GKE Autopilot does not scale the entire cluster to zero because it must run system components and kube-system workloads, making it heavier than Cloud Run.

Compute Engine

Why wrong: Compute Engine provides raw virtual machine instances, meaning you are responsible for provisioning VMs, maintaining the guest OS, installing the container runtime, and configuring autoscaling and load balancing yourself. An unmanaged VM obviously cannot scale to zero; even if you use a managed instance group with autoscaling, you must manage instance templates, health checks, and minimum instance count, and you are billed per VM rather than per request. This is operational overhead that violates the serverless, zero-infrastructure requirement.

App Engine Standard

Why wrong: App Engine Standard is a fully managed serverless platform that does scale to zero, but it is designed for source code written in specific supported runtimes, not arbitrary containers. You must adapt your application to App Engine's runtime environment and use their SDKs/APIs for services like memcache or datastore. If your container ships as-is, App Engine Standard cannot simply run it, while Cloud Run directly executes any standard OCI container.

BigQuery ML

Why wrong: BigQuery ML enables SQL-based model creation directly within BigQuery, but it lacks the infrastructure for custom model training and deployment at scale using Python or TensorFlow, which the team’s ML expertise requires. It is tempting because it offers a serverless, pre-built ML environment for simple regression or classification tasks directly on warehouse data, and would be correct if the team wanted to build models using only SQL queries without managing compute clusters.

Cloud AI Platform Notebooks (now Vertex AI Workbench)

Why wrong: Vertex AI Workbench (formerly Cloud AI Platform Notebooks) is a managed Jupyter notebook service designed for interactive model development, not for operating the full ML lifecycle. It provides pre-configured environments with common frameworks, but you must manually orchestrate training jobs, track experiments, and set up serving infrastructure. It lacks Vertex AI's unified components like the Model Registry, Feature Store, and autoscaling prediction endpoints, so it cannot by itself provide the managed training and serving pipeline the team needs.

Cloud Dataflow

Why wrong: Cloud Dataflow is a managed service for executing Apache Beam pipelines, primarily for stream and batch data processing, ETL, and data integration. It does not provide capabilities for training machine learning models (e.g., distributed GPU/TPU training loops) or for hosting serving endpoints. While Dataflow can be part of an ML pipeline for preprocessing or inference at scale, it is not an ML platform and would leave the team to build and manage all training and serving infrastructure themselves.

Persistent Disk

Why wrong: Persistent Disk is block storage that is attached to Compute Engine VMs as virtual hard drives, providing raw, low-latency storage for the VM's operating system, applications, and databases. It is zonal or regional, and each disk can be attached to at most a few VMs, which means it is not accessible over the internet or shared globally. While it can store any file type at the filesystem level, it is not an object store; it lacks HTTP-based APIs, global redundancy, and object-level metadata and security features.

Cloud Filestore

Why wrong: Cloud Filestore is a managed Network File System (NFS) service that provides POSIX-compliant file storage for applications running on Compute Engine VMs or Google Kubernetes Engine (GKE) clusters. While it can store arbitrary data, it is fundamentally a file system that requires mounting and is accessible only from within a VPC network, not via globally reachable HTTP endpoints. It is optimized for high-performance shared file workloads, such as analytics or home directories, and is not a distributed object store like Cloud Storage.

Cloud Spanner

Why wrong: Cloud Spanner is a fully managed, horizontally scalable relational database service that offers strong consistency, SQL queries, and ACID transactions across regions. It stores structured data in tables with rows and columns, and its optimized engine is for transactional workloads, not for arbitrary unstructured objects like images or videos. Storing large blobs in Spanner would be inefficient and cost-prohibitive, and it does not provide the object lifecycle management, content addressing, or multimedia delivery features of Cloud Storage.

Vertex AI Workbench

Why wrong: Vertex AI Workbench is a managed Jupyter notebook environment designed for data scientists and ML engineers to run interactive code, train models, and perform experiment tracking. It is not a business intelligence tool: it lacks native drag-and-drop dashboarding, scheduled report distribution, and no-code visualization widgets that non-technical stakeholders can consume. Although notebooks can render charts, those visuals are not shareable as live, refreshable BI reports with governed access controls. For a BI dashboard requirement, this service targets a technical audience and a different stage of the data lifecycle.

Cloud Dataprep by Trifacta

Why wrong: Cloud Dataprep by Trifacta is a visual, serverless data preparation service used to explore, clean, and transform raw data into a structured format suitable for analysis. It is a data wrangling tool that builds transformation pipelines on datasets, not a presentation layer for business metrics—it has no dashboard canvas, report layout, or shareable visual analytics. Its output feeds downstream systems like BigQuery and Looker Studio, but it does not replace the BI dashboarding component. Thus it operates upstream of the reporting need and is not the correct tool for sharing insights with non-technical stakeholders.

BigQuery Studio

Why wrong: BigQuery Studio provides an integrated SQL editor and notebook experience within BigQuery, enabling analysts to run queries, explore data, and create lightweight inline visualizations. However, these visuals are tied to the query session or notebook and are not built to serve as persistent, interactive dashboards for a broad business audience. It lacks the collaborative reporting features of a dedicated BI tool, such as scheduled email delivery, live link sharing to non-authenticated stakeholders, and drag-and-drop report composition. While it supports ad hoc exploration, it does not meet the need for a shareable dashboard for non-technical users.

Cloud Vision API

Why wrong: Cloud Vision API is a computer vision service that extracts information from images, such as object labels, OCR text, landmark detection, and face detection. It operates solely on visual input and returns structured metadata about the image content. It has no ability to process conversational text, discern user intent, or maintain dialog state, making it unsuitable for building a virtual agent.

BigQuery ML

Why wrong: BigQuery ML is a service for building and executing machine learning models directly within BigQuery using SQL queries. It supports predictive modeling tasks like regression, classification, and clustering on structured tabular data. It does not provide any natural language understanding, intent recognition, or dialog management capabilities, so it cannot power a conversational AI application.

Cloud Translation API

Why wrong: Cloud Translation API is a neural machine translation service that converts text from one language to another. It performs statistical or neural transduction of the input string but does not analyze semantic intent, extract entities, or manage multi-turn conversations. While it handles natural language as a surface form, it lacks the NLU and dialogue state management required for a conversational experience.

Cloud Tasks

Why wrong: Cloud Tasks is a task queue service that provides reliable, guaranteed delivery of one task to one worker via a push endpoint, with built-in retries and rate limiting. It facilitates asynchronous work distribution but does not support Pub/Sub's publish-subscribe model, meaning you cannot broadcast a single message to multiple independent consumers. Each task is explicitly routed to a single target, so it's best suited for background work dispatch, not event fan-out.

Cloud Scheduler

Why wrong: Cloud Scheduler is a fully managed cron service that triggers HTTP endpoints, Google Cloud Pub/Sub topics, or App Engine targets on a defined schedule. It does not buffer or coordinate service-to-service communication; it simply fires a mechanism at a specified time. While it can publish to Pub/Sub, it lacks the queue semantics, message retention, and fan-out capabilities needed for an inter-service messaging backbone.

Eventarc

Why wrong: Eventarc is a high-level eventing service that routes events from Google Cloud sources (like Cloud Audit Logs, Cloud Storage, and Pub/Sub) to Cloud Run, Cloud Functions, and other targets, with filtering and delivery management. Under the hood, it relies on Pub/Sub for bus infrastructure, but it is focused on event ingestion and routing from internal/Google sources rather than a general-purpose messaging API. For direct service-to-service, producer-agnostic fan-out, you need the native pub-sub primitives of Cloud Pub/Sub itself.

Cloud SQL (PostgreSQL)

Why wrong: Cloud SQL (PostgreSQL) is a managed relational database that supports ACID transactions and SQL, but it is deployed as a regional resource. Although you can configure cross-region read replicas or use failover, the primary database does not automatically replicate writes across multiple regions with synchronous consistency. For a global financial transaction workload requiring low-latency writes and reads from multiple locations, Cloud SQL's regional architecture creates a single point of write locality and cannot provide the same global strong consistency as Cloud Spanner.

Cloud Bigtable

Why wrong: Cloud Bigtable is a NoSQL, wide-column key-value store optimized for high-throughput, low-latency analytical and operational workloads like IoT time-series or recommendation data. It does not support SQL queries, ACID multi-row transactions, or relational joins; it only offers atomic operations on individual rows. Financial transactions and reporting require multi-item consistency and rich querying, which Bigtable fundamentally lacks, making it unsuitable for this use case.

Firestore

Why wrong: Firestore is a fully managed, globally distributed NoSQL document database that does support ACID transactions and multi-region replication with strong consistency. However, it is a document store, not a relational database, so it lacks full SQL query capabilities, complex joins, aggregations, and relational integrity constraints. Financial reporting and transaction processing often depend on ad-hoc SQL queries and normalized schemas, making Firestore a poor fit for such requirements despite its transactional guarantees.