Google Cloud Products and Services practice questions

Firestore

Why wrong: Firestore is a document-oriented NoSQL database optimized for mobile and web applications with hierarchical data, not for high-throughput time-series ingestion. It enforces document size and write-rate limits per document, and its query engine is designed for flexible indexing on moderate datasets, not sustained millions of QPS. Sensor data would quickly hit contention and throttling, and the lack of native time-series row-key patterns forces inefficient composite indexes.

BigQuery

Why wrong: BigQuery is a columnar analytics data warehouse, where query latency is measured in seconds, not milliseconds, because it is optimized for scanning and aggregating massive datasets, not point lookups. Streaming ingestion is eventually consistent and not designed for per-sensor read-after-write access at IoT scale. Using BigQuery for real-time sensor retrieval would incur high cost and unacceptable latency, as its strength lies in batch analysis, not transactional or time-series point queries.

Cloud Spanner

Why wrong: Cloud Spanner is a globally distributed relational database built for strong consistency and ACID transactions, which introduces overhead like distributed Paxos consensus and transaction coordination. These mechanisms guarantee correctness for multi-row transactions but increase read latency and reduce write throughput for simple time-series appends. Its SQL and relational schema also force schema rigidity, making it a poor fit for high-velocity, schema-evolving IoT data where single-digit millisecond point reads are required.

Cloud CDN

Why wrong: Cloud CDN is a content delivery network that improves content distribution, not network connectivity, so it does not meet the hybrid cloud networking requirement.

Cloud VPC

Why wrong: Cloud VPC is a logical network within Google Cloud, not a connectivity service between on-premises and cloud, so it is not directly applicable.

Dataflow

Why wrong: Dataflow is for data processing, not for creating dashboards or reports. It is not a BI tool.

Looker

Why wrong: Looker is a paid BI platform that requires a license, so it does not meet the free requirement.

BigQuery

Why wrong: BigQuery is a data warehouse, not a dashboard/reporting tool.

BigQuery

Why wrong: BigQuery is an analytics data warehouse with query latency measured in seconds. It is not designed for millisecond lookups at IoT scale.

Cloud Spanner

Why wrong: Spanner is a globally distributed relational database optimised for ACID transactions, not single-digit ms time-series reads at millions of QPS.

Firestore

Why wrong: Firestore is a document database suited for mobile/web apps with hierarchical data. It does not scale to millions of QPS for time-series workloads.

Create a Cloud SQL read replica and run analytical queries on the replica

Why wrong: A Cloud SQL read replica maintains a near-real-time, read-only copy of the primary database using asynchronous replication, so analytical reporting queries can be executed against the replica without consuming CPU, memory, or I/O from the transactional primary. This isolates the query load, preserving write and transactional performance, and because replication is continuous, the replica is typically seconds behind, making it suitable for operational dashboards and near-real-time analytics. BigQuery and caching do not provide the same combination of low latency and load isolation for this use case.

Upgrade the primary Cloud SQL instance to a higher machine type

Why wrong: Upgrading the primary instance to a larger machine type increases its available CPU and memory, but it does not separate analytical workloads from the transactional path; the same instance still executes all queries, and a large aggregation or big table scan can saturate resources and contend with writes for locks, buffer pool, and I/O. This approach only delays the problem, scales linearly with cost, and is not a durable solution for predictable performance isolation.

Enable Cloud SQL query caching on the primary instance

Why wrong: Enabling query caching on the primary instance only returns cached results when the exact same SQL query is re-executed, so it does nothing to offload the processing of complex, ad-hoc analytical queries that touch large datasets or use non-deterministic functions. MySQL's query cache was also removed as of MySQL 8.0, so it is not a viable long-term solution on Cloud SQL; even when available, it adds overhead on writes and does not protect the primary from heavy scan workloads.

App Engine Standard environment

Why wrong: App Engine Standard environment is a sandboxed, language-restricted PaaS that only supports a fixed set of languages and specific runtime versions (e.g., Java 11, Python 3.9). It does not permit custom runtimes, Docker containers, or system-level dependencies, making it unsuitable for a web application that requires a custom runtime or native libraries. Its tight integration with Google services and automatic scaling are valuable, but the lack of runtime flexibility makes it the wrong choice here.

App Engine Flexible environment

Why wrong: App Engine Flexible environment is a fully managed PaaS that runs custom containers on Google-managed VMs, allowing you to use any language or system library by supplying your own Dockerfile. It automatically scales, provides load balancing, health checks, and, importantly, supports session affinity, making it well-suited for a traditional web application. Compared to App Engine Standard, it sacrifices some sandbox constraints for greater runtime flexibility, and compared to Cloud Run, it offers a more conventional PaaS experience with persistent instances and connection-oriented features.

Cloud Functions

Why wrong: Cloud Functions is a FaaS (Function-as-a-Service) offering designed for small, event-driven code snippets that run in response to triggers (e.g., HTTP calls, Pub/Sub messages, Cloud Storage events). It imposes strict limits on execution time, memory, and concurrency, and it is inherently stateless, with no support for persistent connections, WebSockets, or session stickiness. As such, it is not capable of hosting a complete, stateful web application, making it an incorrect choice for a continuous web service.

Standard

Why wrong: Standard storage (GCS Standard) is optimized for frequently accessed 'hot' data, with no minimum retention period and no data-retrieval fees. For backup data that is accessed approximately once per year, the higher per-GB storage price makes Standard unnecessarily expensive. Even though retrieval is instant, the ongoing storage cost would exceed that of Archive storage by a wide margin, so it is not the most economical choice.

Nearline

Why wrong: Nearline storage is intended for data accessed less than once a month, carrying a 30-day minimum storage duration and per-GB retrieval fees. For a yearly access pattern, Nearline's per-GB price is significantly higher than Archive storage, so it would overpay for storage that remains mostly idle. Since the backup is rarely touched, the lower monthly cost of Archive storage makes it the better value.

Archive

Why wrong: Archive storage is Google Cloud's lowest-cost storage class for long-term backup and archival data, designed for access less than once a year. It has a 365-day minimum storage duration and charges retrieval fees, but the substantially lower per-GB price minimizes total cost for data retained for years. Although retrieval is not instant like Standard and incurs additional charges, the infrequent yearly restore makes Archive the most cost-effective choice.

Cloud Functions must be associated with a VPC to access Pub/Sub.

Why wrong: Cloud Functions accesses Pub/Sub through the standard Google Cloud API endpoint, which does not require a VPC. You can add Serverless VPC Connector or Gen 2 VPC egress settings for private networking, but this is optional and only when you want to avoid the public internet. The statement is false because VPC association is not a mandatory prerequisite.

Cloud Functions can run for up to 60 minutes per invocation in all generations.

Why wrong: The maximum invocation timeout for Cloud Functions is 540 seconds (9 minutes), not 60 minutes. Functions that run longer than this limit are terminated and may return an error to the caller. This timeout applies to both background functions and HTTP triggers, and it cannot be set beyond the platform's hard limit.

Cloud Functions can be used to pull messages from a Pub/Sub subscription synchronously.

Why wrong: Cloud Functions uses push subscriptions only, so it cannot synchronously pull messages from a Pub/Sub subscription. Pub/Sub pushes each message to the function's HTTP endpoint immediately after publication. Pull subscriptions require clients to send synchronous pull requests to the Pub/Sub API, which is not the model Cloud Functions implements.

Looker

Why wrong: Looker is an enterprise BI platform, but it requires BigQuery underneath for data storage.

BigQuery

Why wrong: BigQuery can analyze Workspace data if exported, but not directly integrated without ETL.

Dataflow

Why wrong: Dataflow is for data processing pipelines, not ad hoc analysis.

Local SSD

Why wrong: Local SSD is ephemeral and cannot be resized.

Cloud Storage

Why wrong: Cloud Storage is object storage, not block storage.

Filestore

Why wrong: Filestore is a managed NFS file system, not block storage.

Firestore

Why wrong: Firestore is a serverless, document-oriented NoSQL database designed for mobile/web applications with hierarchical, object-like data and real-time sync, not high-ingest time-series. It lacks Bigtable's per-node linear throughput scaling for sustained writes of petabytes of sensor data, and its query model (indexed document collections) is less efficient for wide range scans over timestamp-ordered key designs. Firestore has limits on write throughput per database (though it scales, not to millions of QPS with single-digit ms for this IoT pattern).

BigQuery

Why wrong: BigQuery is a serverless columnar data warehouse optimized for analytical SQL queries over massive datasets, with query latency often in seconds, not milliseconds. It is built for batch and interactive analytics, not for serving hot paths that require single-digit millisecond point lookups or high QPS writes from IoT streams. While it can store petabytes, using it as an operational time-series backend would incur excessive cost/latency; it is better suited to analyzing the data after Bigtable or Pub/Sub ingests it.

Cloud Spanner

Why wrong: Cloud Spanner is a globally distributed relational database that provides strong consistency and ACID transactions across regions, with SQL semantics. That relational/transactional machinery incurs overhead and is misaligned for high-volume, append-heavy time-series workloads that don't need cross-row transactions; single-row key lookups are fast, but sustained millions of QPS of sensor writes with petabytes scale is better served by Bigtable's simpler key-value model. Spanner's horizontal scaling is also more complex to tune and costs more per node than Bigtable for this use case.

Firestore

Why wrong: Firestore is a NoSQL document database, not a relational one, so it lacks the global ACID transactions and SQL querying needed for this platform. While Firestore can be multi-region, its default multi-region mode uses eventual consistency, and even its strong consistency mode is limited to single-region or potentially a specific region for documents, not globally. Furthermore, Firestore's availability SLA (99.99%) falls short of the required 99.999%, so it cannot meet the platform's global consistency and uptime requirements.

Cloud SQL

Why wrong: Cloud SQL is a regional, managed relational database service (MySQL, PostgreSQL, SQL Server) that does not support global replication or multi-writer configurations across continents. Its maximum availability SLA is 99.99% for high-availability configurations, not the 99.999% required, and it cannot maintain strong consistency across geographic regions because it is designed for a single region. This makes it unsuitable for a globally distributed platform.

Bigtable

Why wrong: Bigtable is a NoSQL wide-column key/value store, not a relational database, so it cannot support SQL queries, joins, or multi-row ACID transactions needed for a transactional e-commerce backend. While it offers high scalability, it provides eventual consistency across its replicated clusters unless you choose single-cluster routing, and its availability SLA is 99.99%, below the required 99.999%. It is better suited for time-series or analytical workloads than for global transactional consistency.

Push subscription with retry policy

Why wrong: Push subscriptions can have retry policies but do not natively provide exactly-once delivery; they are at-least-once by default.

Push subscription with acknowledgment deadline extended

Why wrong: Extending acknowledgment deadline prevents premature redelivery but does not guarantee exactly-once.

Pull subscription with a dead letter topic

Why wrong: Dead letter topics handle undeliverable messages, not duplicate prevention.

Google Kubernetes Engine (GKE)

Why wrong: Google Kubernetes Engine (GKE) is a container orchestration platform that requires you to manage the control plane, node pools, and cluster upgrades, which introduces significant operational overhead and contradicts the requirement for no server management. While GKE can certainly run a legacy monolith in containers, the need to handle cluster autoscaling, monitoring, and maintenance makes it heavier than a fully managed platform. For a team migrating away from a monolith and seeking to reduce ops burden, GKE is not the optimal choice.

Cloud Run

Why wrong: Cloud Run is a serverless container platform that executes stateless, request-driven containers and scales aggressively, even to zero, which makes it ideal for individual microservices or event-driven workloads. However, a legacy monolith often holds state in memory, has long-running background processes, or expects persistent connections—patterns that conflict with Cloud Run's per-instance concurrency model and request timeout limits. App Engine Flexible Environment offers a more traditional runtime environment with sustained instance availability, making it a better fit for the monolith than Cloud Run.

Cloud Functions

Why wrong: Cloud Functions is designed for small, single-purpose, event-driven functions that scale instantly and execute in response to triggers, with no server management. A legacy monolithic application by definition consists of many tightly coupled business logic components, database interactions, and UI rendering, which cannot be decomposed into independent functions without significant refactoring. Deploying a monolith to Cloud Functions would require rewriting it as a serverless function, which is neither practical nor aligned with the migration goal of minimal changes.

Use Cloud SQL's Database Migration Service for one-time migration

Why wrong: Cloud SQL's Database Migration Service is designed to move external databases into Cloud SQL, not to alter schema on an already-existing Cloud SQL instance. It performs a one-time data copy with minimal downtime, but it cannot be used to apply DDL changes to an instance that is already the source of truth. For a schema migration on an existing primary, the DMS would not even accept the target as an internal source; it lacks the ability to synchronize ongoing changes from a Cloud SQL primary. Thus, while DMS is a useful migration tool, it is the wrong mechanism for this use case.

Schedule a maintenance window during the migration

Why wrong: Scheduling a maintenance window is a standard operational practice to control when Cloud SQL applies patches or upgrades, but it does not reduce the downtime required for a schema change. During a schema migration, a maintenance window merely ensures that the change happens at a designated time; it does not prevent the primary from being locked or from experiencing availability impact while the schema is altered. A read replica approach is what actually achieves near-zero downtime by offloading the schema change to a separate instance that can failover independently. Therefore, a maintenance window alone is insufficient for minimizing downtime during the migration.

Configure manual scaling with a larger machine type

Why wrong: App Engine Standard environment uses a sandboxed runtime with predefined instance classes such as B4 or B8; you cannot choose a virtual machine type as you would on Compute Engine. Manual scaling lets you set a fixed number of instances but offers no larger machine type for handling spikes, and a fixed count does not adapt to traffic. Thus this option would not solve latency spikes without code changes and is conceptually invalid in the Standard environment.

Migrate to App Engine Flexible Environment

Why wrong: Migrating to App Engine Flexible Environment requires deploying to a different runtime with Docker containers, so you must modify your Python app's entrypoint, dependencies, and possibly networking configuration. That is a substantial code and deployment change, contradicting the constraint of 'without changing code.' While Flexible allows custom machine types, the migration itself is the very thing the company wants to avoid, making this option unsuitable.

Enable Cloud CDN in front of the app

Why wrong: Cloud CDN caches responses at Google's edge PoPs, but dynamic, per-user session endpoints in a Python App Engine app typically send Cache-Control: private, so CDN misses and passes requests to backend. Even for cacheable content, the CDN reduces egress latency, not the App Engine instance startup time or scaling latency during traffic spikes. Therefore, enabling CDN does not address the underlying instance-to-server warm-up problem.

Deployment Manager

Why wrong: Deployment Manager is used for deploying Google Cloud resources, not for managing Kubernetes YAML configurations. It does not fit the requirement of managing Kubernetes manifests.

Cloud Source Repositories

Why wrong: Cloud Source Repositories is a source code repository, not for storing container images or managing Kubernetes configs.

Cloud Run

Why wrong: Cloud Run is a serverless compute platform, not directly related to GKE or managing Kubernetes configurations.

Cloud Scheduler

Why wrong: Cloud Scheduler is a fully managed cron service that triggers jobs on a fixed schedule, not in response to events. It would fire a notification email at a predetermined time regardless of whether a file was actually uploaded, making it unsuitable for event-driven workflows. Since the startup's need is triggered by Cloud Storage object changes, a time-based scheduler cannot detect or react to those asynchronous events.

Cloud Tasks

Why wrong: Cloud Tasks is a distributed task queue designed to manage asynchronous workload execution, typically by creating tasks that invoke HTTP endpoints. It does not inherently listen to event streams; instead, tasks must be explicitly enqueued by a producer, so it cannot directly respond to a Storage object's finalization event. While it could later be used to send the email, it is not the event trigger itself.

Cloud Run

Why wrong: Cloud Run is a serverless container service, but its primary invocation mode is HTTP requests rather than direct event subscriptions. To make it event-driven, you must connect an event source via Eventarc, which transforms the event into an HTTP push and adds operational complexity. This indirection means Cloud Run is not the natural first choice for a simple, direct event triggering and email notification flow.

Cloud Pub/Sub

Why wrong: Cloud Pub/Sub is a message broker that decouples event producers from consumers and can receive a Storage event to asynchronously fan out, which may ultimately trigger a Cloud Function to send an email. However, Pub/Sub alone does not execute any code or send messages itself; it merely transports events. For this startup, it is the middle layer in a larger event-driven pipeline, not the component that directly reads the event and sends email.

BigQuery

Why wrong: BigQuery is a serverless, columnar SQL data warehouse optimized for analytical queries that scan massive datasets, with typical query latencies in the seconds. It is not designed for point lookups or high-QPS single-row reads from IoT devices; its per-query cost model and architecture make it prohibitively expensive and slow for operational time-series retrieval, which demands single-digit millisecond responses.

Cloud Spanner

Why wrong: Cloud Spanner is a globally distributed relational database that offers external consistency and ACID transactions, with synchronous replication across regions. That transactional overhead and the complexity of multi-region consensus mean individual point reads are not consistently single-digit milliseconds at millions of QPS, and it is architecturally overkill for simple time-series append patterns that do not require relational joins or strong cross-row transaction guarantees.

Firestore

Why wrong: Firestore is a document-oriented NoSQL database designed for mobile and web applications with real-time sync, offline persistence, and hierarchical data structures. It lacks the columnar, append-optimized storage or distributed sorting of a dedicated time-series store, and its throughput and latency are not architected for millions of concurrent IoT sensor writes and reads per second, so it would become a bottleneck and a cost problem at this scale.

Use zonal Persistent Disk and snapshot to Cloud Storage every hour

Why wrong: A zonal Persistent Disk is confined to a single zone; if that zone fails, the disk becomes unreachable. Snapshotting it to Cloud Storage every hour is only a backup mechanism, not real-time replication. In a failover you'd restore the last snapshot, losing up to an hour of committed writes, and the restore process adds minutes of downtime. Therefore it cannot meet critical RPO/RTO requirements.

Use Cloud Load Balancing without any disk changes

Why wrong: Cloud Load Balancing operates at Layer 4/7, routing traffic to healthy backend instances, but it does not synchronize their storage. Each instance would continue using its own zonal or local disk, so state written by one instance is invisible to others, causing true-state divergence. Unless the application already has a shared storage layer, adding a load balancer alone provides neither data consistency nor automatic failover for a stateful application.

Use a regional managed instance group with a multi-regional bucket for state

Why wrong: A multi-regional Cloud Storage bucket is object storage, not a block device, so it cannot be mounted as a disk for an application that expects a standard filesystem. While a regional managed instance group can span zones, it does not create shared storage; the bucket would be separate and would require the application to use object I/O semantics, such as via GCSFuse, with different consistency and performance characteristics. Thus this option does not satisfy the application's requirement for a persistent disk.