The organization is the top-level resource tied to a company identity domain. Folders group projects by team, environment, or business unit. Projects are the main isolation and billing boundary where APIs, IAM bindings, quotas, and resources live. Mature GCP design uses folders and projects to separate ownership, environments, and blast radius.
02
Question 2Medium
How does a service account differ from a user account in GCP?
A user account represents a human identity. A service account represents a workload identity used by VMs, GKE, Cloud Run, Cloud Build, or automation. Service accounts should be granted least-privilege IAM roles and used through workload identity or impersonation rather than downloaded long-lived keys.
03
Question 3Medium
What is Private Google Access and when do you use it?
Private Google Access lets VMs without external IP addresses reach Google APIs over internal Google network paths when subnet and DNS/routing are configured correctly. Use it for private workloads that need services like Cloud Storage, Artifact Registry, or BigQuery without public internet egress.
04
Question 4Hard
How do you design a production GKE cluster for least privilege?
Use private clusters where appropriate, Workload Identity for pod-to-service-account mapping, namespace isolation, RBAC, network policies, limited node service account roles, Binary Authorization or admission policies for image control, and separate node pools for workloads with different trust or resource profiles.
05
Question 5Hard
A Cloud SQL database must support production failover. What controls matter beyond enabling HA?
You need tested failover behavior, connection pooling, backup/PITR verification, maintenance windows, alerting, application retry handling, schema migration controls, and restore drills. HA reduces zonal failure impact, but it does not replace backup validation or application-level resilience.
06
Question 6Hard
GCP incident: Users in one region see 502s while backends in another region are healthy. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Cloud Load Balancing backend health, URL maps, firewall rules, NEG status, and Cloud Logging. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Validate backend health per region, firewall source ranges, URL map routing, CDN/cache behavior, and failover policy. Keep direct backend access closed.
07
Question 7Hard
GCP architecture scenario: Design global HTTPS load balancing for multi-region services. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Validate backend health per region, firewall source ranges, URL map routing, CDN/cache behavior, and failover policy. Keep direct backend access closed.
08
Question 8Medium
GCP security scenario: Backend services expose instances directly. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Validate backend health per region, firewall source ranges, URL map routing, CDN/cache behavior, and failover policy. Keep direct backend access closed.
09
Question 9Hard
GCP release scenario: Move from regional ingress to global load balancing. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Validate backend health per region, firewall source ranges, URL map routing, CDN/cache behavior, and failover policy. Keep direct backend access closed.
10
Question 10Medium
GCP reliability/cost scenario: Cross-region egress costs are higher than expected. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Validate backend health per region, firewall source ranges, URL map routing, CDN/cache behavior, and failover policy. Keep direct backend access closed.
11
Question 11Hard
GCP incident: A Cloud Run service works locally but fails to access Pub/Sub in production. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Cloud Audit Logs, Policy Troubleshooter, IAM bindings, service account impersonation checks, and denied permission messages. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Use one service account per workload, grant resource-level roles where possible, avoid project Editor, and use impersonation for CI/CD instead of downloaded keys.
12
Question 12Hard
GCP architecture scenario: Design least-privilege service account access. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Use one service account per workload, grant resource-level roles where possible, avoid project Editor, and use impersonation for CI/CD instead of downloaded keys.
13
Question 13Medium
GCP security scenario: Broad project-level roles grant excessive access. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Use one service account per workload, grant resource-level roles where possible, avoid project Editor, and use impersonation for CI/CD instead of downloaded keys.
14
Question 14Hard
GCP release scenario: Replace Editor roles with scoped predefined or custom roles. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Use one service account per workload, grant resource-level roles where possible, avoid project Editor, and use impersonation for CI/CD instead of downloaded keys.
15
Question 15Medium
GCP reliability/cost scenario: IAM sprawl makes audits slow. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Use one service account per workload, grant resource-level roles where possible, avoid project Editor, and use impersonation for CI/CD instead of downloaded keys.
16
Question 16Hard
GCP incident: A VM in a private subnet cannot reach Google APIs. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: routes, firewall rules, Private Google Access setting, Cloud NAT logs, DNS policy, and VPC Flow Logs. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Check subnet settings, DNS resolution, routes, firewall, and service-specific private access. Use Private Google Access/PSC before defaulting to internet egress.
17
Question 17Hard
GCP architecture scenario: Design private access to Google managed services. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Check subnet settings, DNS resolution, routes, firewall, and service-specific private access. Use Private Google Access/PSC before defaulting to internet egress.
18
Question 18Medium
GCP security scenario: Public IPs are added to private workloads. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Check subnet settings, DNS resolution, routes, firewall, and service-specific private access. Use Private Google Access/PSC before defaulting to internet egress.
19
Question 19Hard
GCP release scenario: Enable Private Google Access and private service connectivity. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Check subnet settings, DNS resolution, routes, firewall, and service-specific private access. Use Private Google Access/PSC before defaulting to internet egress.
20
Question 20Medium
GCP reliability/cost scenario: NAT egress costs are growing. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Check subnet settings, DNS resolution, routes, firewall, and service-specific private access. Use Private Google Access/PSC before defaulting to internet egress.
21
Question 21Hard
GCP incident: A GKE node pool upgrade disrupts critical pods. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: GKE events, PDBs, node pool surge settings, scheduler events, and cluster autoscaler logs. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Use PDBs, surge upgrades, workload identity, namespace isolation, cluster autoscaling, and staging validation before production upgrades.
22
Question 22Hard
GCP architecture scenario: Design a multi-tenant GKE platform. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Use PDBs, surge upgrades, workload identity, namespace isolation, cluster autoscaling, and staging validation before production upgrades.
23
Question 23Medium
GCP security scenario: Workload Identity is not used and node service accounts are overpowered. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Use PDBs, surge upgrades, workload identity, namespace isolation, cluster autoscaling, and staging validation before production upgrades.
24
Question 24Hard
GCP release scenario: Upgrade cluster and node pools safely. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Use PDBs, surge upgrades, workload identity, namespace isolation, cluster autoscaling, and staging validation before production upgrades.
25
Question 25Medium
GCP reliability/cost scenario: Overprovisioned nodes increase monthly cost. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Use PDBs, surge upgrades, workload identity, namespace isolation, cluster autoscaling, and staging validation before production upgrades.
26
Question 26Hard
GCP incident: Cloud SQL failover causes longer downtime than expected. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Cloud SQL operations, database logs, connection count, failover events, and query insights. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Use HA for zonal failure, test failover behavior, tune connection pooling, back up and restore regularly, and separate app roles by privilege.
27
Question 27Hard
GCP architecture scenario: Design a resilient database tier on GCP. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Use HA for zonal failure, test failover behavior, tune connection pooling, back up and restore regularly, and separate app roles by privilege.
28
Question 28Medium
GCP security scenario: Application credentials have excessive database privileges. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Use HA for zonal failure, test failover behavior, tune connection pooling, back up and restore regularly, and separate app roles by privilege.
29
Question 29Hard
GCP release scenario: Enable HA and read replicas for an existing database. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Use HA for zonal failure, test failover behavior, tune connection pooling, back up and restore regularly, and separate app roles by privilege.
30
Question 30Medium
GCP reliability/cost scenario: Cloud SQL CPU and storage costs keep increasing. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Use HA for zonal failure, test failover behavior, tune connection pooling, back up and restore regularly, and separate app roles by privilege.
31
Question 31Hard
GCP incident: Messages are delivered multiple times and downstream creates duplicates. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: subscription backlog, ack deadline, delivery attempts, dead-letter metrics, and consumer logs. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Make consumers idempotent, tune ack deadlines, use dead-letter topics, avoid large sensitive payloads, and monitor oldest unacked message age.
32
Question 32Hard
GCP architecture scenario: Design event processing with at-least-once delivery. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Make consumers idempotent, tune ack deadlines, use dead-letter topics, avoid large sensitive payloads, and monitor oldest unacked message age.
33
Question 33Medium
GCP security scenario: Messages contain sensitive data without retention controls. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Make consumers idempotent, tune ack deadlines, use dead-letter topics, avoid large sensitive payloads, and monitor oldest unacked message age.
34
Question 34Hard
GCP release scenario: Add dead-letter topics and retry policies. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Make consumers idempotent, tune ack deadlines, use dead-letter topics, avoid large sensitive payloads, and monitor oldest unacked message age.
35
Question 35Medium
GCP reliability/cost scenario: Backlog growth increases processing cost. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Make consumers idempotent, tune ack deadlines, use dead-letter topics, avoid large sensitive payloads, and monitor oldest unacked message age.
36
Question 36Hard
GCP incident: P99 latency spikes after idle periods. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Cloud Run revision metrics, cold start timing, concurrency, CPU allocation, and request logs. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Tune concurrency, min instances, CPU allocation, startup work, and auth. Separate latency-sensitive APIs from background jobs.
37
Question 37Hard
GCP architecture scenario: Design serverless containers for APIs and background workers. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Tune concurrency, min instances, CPU allocation, startup work, and auth. Separate latency-sensitive APIs from background jobs.
38
Question 38Medium
GCP security scenario: Unauthenticated invocations expose internal services. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Tune concurrency, min instances, CPU allocation, startup work, and auth. Separate latency-sensitive APIs from background jobs.
39
Question 39Hard
GCP release scenario: Move a container service from GKE to Cloud Run. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Tune concurrency, min instances, CPU allocation, startup work, and auth. Separate latency-sensitive APIs from background jobs.
40
Question 40Medium
GCP reliability/cost scenario: Min instances improve latency but raise cost. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Tune concurrency, min instances, CPU allocation, startup work, and auth. Separate latency-sensitive APIs from background jobs.
41
Question 41Hard
GCP incident: Objects are accidentally made public through IAM or ACLs. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: bucket IAM, public access prevention, ACL status, access logs, lifecycle rules, and CDN logs. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Use uniform bucket-level access, public access prevention, signed URLs where needed, lifecycle policies, and CDN caching for public content.
42
Question 42Hard
GCP architecture scenario: Design secure object storage and CDN delivery. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Use uniform bucket-level access, public access prevention, signed URLs where needed, lifecycle policies, and CDN caching for public content.
43
Question 43Medium
GCP security scenario: Legacy ACLs bypass intended IAM controls. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Use uniform bucket-level access, public access prevention, signed URLs where needed, lifecycle policies, and CDN caching for public content.
44
Question 44Hard
GCP release scenario: Migrate buckets to uniform bucket-level access. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Use uniform bucket-level access, public access prevention, signed URLs where needed, lifecycle policies, and CDN caching for public content.
45
Question 45Medium
GCP reliability/cost scenario: Storage class and egress costs are high. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Use uniform bucket-level access, public access prevention, signed URLs where needed, lifecycle policies, and CDN caching for public content.
46
Question 46Hard
GCP incident: A dashboard query suddenly costs much more and runs slowly. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: query plan, bytes processed, partition filters, slot usage, audit logs, and table metadata. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Partition and cluster by access pattern, require partition filters, use authorized views or column policies, and label jobs for cost ownership.
47
Question 47Hard
GCP architecture scenario: Design governed analytics datasets. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Partition and cluster by access pattern, require partition filters, use authorized views or column policies, and label jobs for cost ownership.
48
Question 48Medium
GCP security scenario: Users can query sensitive columns directly. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Partition and cluster by access pattern, require partition filters, use authorized views or column policies, and label jobs for cost ownership.
49
Question 49Hard
GCP release scenario: Introduce partitioning, clustering, and authorized views. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Partition and cluster by access pattern, require partition filters, use authorized views or column policies, and label jobs for cost ownership.
50
Question 50Medium
GCP reliability/cost scenario: BigQuery spend is hard to attribute. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Partition and cluster by access pattern, require partition filters, use authorized views or column policies, and label jobs for cost ownership.
51
Question 51Hard
GCP incident: A bot spike overloads the backend despite autoscaling. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Cloud Armor logs, sampled requests, load balancer metrics, backend saturation, and rule match data. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Start rules in preview, tune false positives, rate limit targeted paths, combine geo/IP/user-agent signals carefully, and keep rollback procedures.
52
Question 52Hard
GCP architecture scenario: Design edge protection for public HTTP services. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Start rules in preview, tune false positives, rate limit targeted paths, combine geo/IP/user-agent signals carefully, and keep rollback procedures.
53
Question 53Medium
GCP security scenario: WAF rules block legitimate users. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Start rules in preview, tune false positives, rate limit targeted paths, combine geo/IP/user-agent signals carefully, and keep rollback procedures.
54
Question 54Hard
GCP release scenario: Move Cloud Armor rules from preview to enforce. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Start rules in preview, tune false positives, rate limit targeted paths, combine geo/IP/user-agent signals carefully, and keep rollback procedures.
55
Question 55Medium
GCP reliability/cost scenario: Abusive traffic increases backend and logging costs. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Start rules in preview, tune false positives, rate limit targeted paths, combine geo/IP/user-agent signals carefully, and keep rollback procedures.
56
Question 56Hard
GCP incident: Private workloads intermittently fail outbound connections. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Cloud NAT metrics, port allocation errors, VPC Flow Logs, route tables, and connection reuse metrics. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Tune NAT port allocation, reduce connection churn, use private access for Google APIs, and alert on dropped packets and port exhaustion.
57
Question 57Hard
GCP architecture scenario: Design reliable private outbound egress. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Tune NAT port allocation, reduce connection churn, use private access for Google APIs, and alert on dropped packets and port exhaustion.
58
Question 58Medium
GCP security scenario: NAT logs reveal sensitive destination patterns. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Tune NAT port allocation, reduce connection churn, use private access for Google APIs, and alert on dropped packets and port exhaustion.
59
Question 59Hard
GCP release scenario: Move private subnets behind Cloud NAT. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Tune NAT port allocation, reduce connection churn, use private access for Google APIs, and alert on dropped packets and port exhaustion.
60
Question 60Medium
GCP reliability/cost scenario: NAT port allocation and egress costs grow. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Tune NAT port allocation, reduce connection churn, use private access for Google APIs, and alert on dropped packets and port exhaustion.
61
Question 61Hard
GCP incident: A rotated secret breaks a deployed service. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Secret version state, IAM bindings, access logs, workload identity, and application errors. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Grant access per secret, use workload identity, cache secrets with short TTL, rotate with overlapping versions, and never bake secrets into images.
62
Question 62Hard
GCP architecture scenario: Design secret rotation across GCP workloads. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Grant access per secret, use workload identity, cache secrets with short TTL, rotate with overlapping versions, and never bake secrets into images.
63
Question 63Medium
GCP security scenario: Secrets are stored in container images or Terraform state. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Grant access per secret, use workload identity, cache secrets with short TTL, rotate with overlapping versions, and never bake secrets into images.
64
Question 64Hard
GCP release scenario: Move environment secrets into Secret Manager. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Grant access per secret, use workload identity, cache secrets with short TTL, rotate with overlapping versions, and never bake secrets into images.
65
Question 65Medium
GCP reliability/cost scenario: Secret access calls are noisy and hard to audit. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Grant access per secret, use workload identity, cache secrets with short TTL, rotate with overlapping versions, and never bake secrets into images.
66
Question 66Hard
GCP incident: An incident occurs but alerting only catches infrastructure symptoms. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Cloud Monitoring metrics, log-based metrics, Error Reporting, Trace, alert history, and log sinks. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Alert on user impact and saturation, sample verbose logs, redact sensitive fields, export long-retention logs to cheaper storage, and use SLO burn rates.
67
Question 67Hard
GCP architecture scenario: Design service-level monitoring on GCP. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Alert on user impact and saturation, sample verbose logs, redact sensitive fields, export long-retention logs to cheaper storage, and use SLO burn rates.
68
Question 68Medium
GCP security scenario: Logs contain sensitive request payloads. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Alert on user impact and saturation, sample verbose logs, redact sensitive fields, export long-retention logs to cheaper storage, and use SLO burn rates.
69
Question 69Hard
GCP release scenario: Introduce SLO burn-rate alerts. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Alert on user impact and saturation, sample verbose logs, redact sensitive fields, export long-retention logs to cheaper storage, and use SLO burn rates.
70
Question 70Medium
GCP reliability/cost scenario: Cloud Logging ingestion costs are high. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Alert on user impact and saturation, sample verbose logs, redact sensitive fields, export long-retention logs to cheaper storage, and use SLO burn rates.
71
Question 71Hard
GCP incident: Teams create resources in the wrong project and lose cost visibility. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Resource hierarchy, IAM policy, org policies, billing export, labels, and audit logs. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Use folders/projects by environment and ownership, enforce org policies, require labels, centralize billing export, and avoid dumping unrelated workloads into one project.
72
Question 72Hard
GCP architecture scenario: Design project/folder structure for environments and teams. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Use folders/projects by environment and ownership, enforce org policies, require labels, centralize billing export, and avoid dumping unrelated workloads into one project.
73
Question 73Medium
GCP security scenario: Organization policies are missing or inconsistent. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Use folders/projects by environment and ownership, enforce org policies, require labels, centralize billing export, and avoid dumping unrelated workloads into one project.
74
Question 74Hard
GCP release scenario: Move workloads into standardized projects. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Use folders/projects by environment and ownership, enforce org policies, require labels, centralize billing export, and avoid dumping unrelated workloads into one project.
75
Question 75Medium
GCP reliability/cost scenario: Shared projects make chargeback difficult. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Use folders/projects by environment and ownership, enforce org policies, require labels, centralize billing export, and avoid dumping unrelated workloads into one project.
76
Question 76Hard
GCP incident: A build can deploy to production from an untrusted branch. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Cloud Build triggers, service account roles, approval gates, Artifact Registry usage, and audit logs. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Use protected triggers, minimal deploy roles, approvals for production, artifact provenance, and retention policies for old images.
77
Question 77Hard
GCP architecture scenario: Design secure CI/CD on GCP. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Use protected triggers, minimal deploy roles, approvals for production, artifact provenance, and retention policies for old images.
78
Question 78Medium
GCP security scenario: Build service accounts have broad project permissions. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Use protected triggers, minimal deploy roles, approvals for production, artifact provenance, and retention policies for old images.
79
Question 79Hard
GCP release scenario: Move deployments to service account impersonation. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Use protected triggers, minimal deploy roles, approvals for production, artifact provenance, and retention policies for old images.
80
Question 80Medium
GCP reliability/cost scenario: Build minutes and artifact storage costs are increasing. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Use protected triggers, minimal deploy roles, approvals for production, artifact provenance, and retention policies for old images.
81
Question 81Hard
GCP incident: Deployments pull mutable image tags and rollbacks are unreliable. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: image digests, repository IAM, vulnerability scans, cleanup policies, and deploy manifests. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Promote immutable digests, scope repository IAM, enable scanning, sign artifacts where required, and apply cleanup policies by environment.
82
Question 82Hard
GCP architecture scenario: Design container artifact promotion. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Promote immutable digests, scope repository IAM, enable scanning, sign artifacts where required, and apply cleanup policies by environment.
83
Question 83Medium
GCP security scenario: Repositories allow unauthenticated or broad pull access. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Promote immutable digests, scope repository IAM, enable scanning, sign artifacts where required, and apply cleanup policies by environment.
84
Question 84Hard
GCP release scenario: Move from Container Registry to Artifact Registry. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Promote immutable digests, scope repository IAM, enable scanning, sign artifacts where required, and apply cleanup policies by environment.
85
Question 85Medium
GCP reliability/cost scenario: Old images consume storage. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Promote immutable digests, scope repository IAM, enable scanning, sign artifacts where required, and apply cleanup policies by environment.
86
Question 86Hard
GCP incident: A streaming pipeline falls behind after traffic increases. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: Dataflow backlog, system lag, worker CPU, autoscaling events, Pub/Sub metrics, and error logs. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Inspect source backlog, worker saturation, hot keys, windowing, and sink throughput. Tune autoscaling and fix data skew before simply adding workers.
87
Question 87Hard
GCP architecture scenario: Design scalable data processing on GCP. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Inspect source backlog, worker saturation, hot keys, windowing, and sink throughput. Tune autoscaling and fix data skew before simply adding workers.
88
Question 88Medium
GCP security scenario: Pipeline workers can access broader data than required. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Inspect source backlog, worker saturation, hot keys, windowing, and sink throughput. Tune autoscaling and fix data skew before simply adding workers.
89
Question 89Hard
GCP release scenario: Change worker sizing and autoscaling settings. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Inspect source backlog, worker saturation, hot keys, windowing, and sink throughput. Tune autoscaling and fix data skew before simply adding workers.
90
Question 90Medium
GCP reliability/cost scenario: Streaming costs rise faster than event volume. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Inspect source backlog, worker saturation, hot keys, windowing, and sink throughput. Tune autoscaling and fix data skew before simply adding workers.
91
Question 91Hard
GCP incident: Global users see inconsistent latency and transaction contention. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: query latency, transaction aborts, key distribution, schema design, and capacity metrics. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Choose based on consistency, access pattern, transaction needs, and scale. Avoid hot keys, test migrations, and model cost under real traffic.
92
Question 92Hard
GCP architecture scenario: Choose between Cloud SQL, Spanner, Firestore, and Bigtable. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Choose based on consistency, access pattern, transaction needs, and scale. Avoid hot keys, test migrations, and model cost under real traffic.
93
Question 93Medium
GCP security scenario: Database IAM and application roles are not separated. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Choose based on consistency, access pattern, transaction needs, and scale. Avoid hot keys, test migrations, and model cost under real traffic.
94
Question 94Hard
GCP release scenario: Migrate a workload to a globally scalable database. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Choose based on consistency, access pattern, transaction needs, and scale. Avoid hot keys, test migrations, and model cost under real traffic.
95
Question 95Medium
GCP reliability/cost scenario: Provisioned capacity is expensive for uneven traffic. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Choose based on consistency, access pattern, transaction needs, and scale. Avoid hot keys, test migrations, and model cost under real traffic.
96
Question 96Hard
GCP incident: A certificate renewal fails and HTTPS breaks. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: certificate status, DNS records, load balancer config, Certificate Manager events, and browser errors. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Use managed certificates where possible, validate DNS ownership, monitor expiry/status, and keep DNS changes reviewed with rollback.
97
Question 97Hard
GCP architecture scenario: Design managed TLS and DNS for public services. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Use managed certificates where possible, validate DNS ownership, monitor expiry/status, and keep DNS changes reviewed with rollback.
98
Question 98Medium
GCP security scenario: DNS ownership is split across teams with no change control. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Use managed certificates where possible, validate DNS ownership, monitor expiry/status, and keep DNS changes reviewed with rollback.
99
Question 99Hard
GCP release scenario: Move custom certs to managed certificates. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Use managed certificates where possible, validate DNS ownership, monitor expiry/status, and keep DNS changes reviewed with rollback.
100
Question 100Medium
GCP reliability/cost scenario: Manual certificate operations consume on-call time. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Use managed certificates where possible, validate DNS ownership, monitor expiry/status, and keep DNS changes reviewed with rollback.
101
Question 101Hard
GCP incident: A regional quota blocks autoscaling during a traffic spike. How do you investigate, recover service, and prevent the same failure?
Start by proving scope and recent change: quota metrics, autoscaler events, capacity forecasts, regional usage, and launch plan assumptions. Check logs, metrics, health checks, dependency errors, and config drift before changing anything. Recover with the smallest reversible action, then document the root cause. Prevention: Monitor critical quotas, request increases ahead of launches, distribute capacity across regions/zones, and treat quota as part of reliability design.
102
Question 102Hard
GCP architecture scenario: Design quota-aware production capacity. What design would you choose, and what tradeoffs would you call out in an interview?
Design for failure domains, rollback, observability, and least privilege first. Validate capacity, limits, network paths, and operational ownership. The practical answer is not one service or command; it is the architecture plus the runbook. For this scenario: Monitor critical quotas, request increases ahead of launches, distribute capacity across regions/zones, and treat quota as part of reliability design.
103
Question 103Medium
GCP security scenario: Emergency quota increases bypass approval. How do you harden it without breaking production?
Baseline current behavior, add guardrails in report-only or staged mode where possible, and test the highest-risk paths first. Roll out with logs, alerts, and a rollback plan. Use least privilege, explicit ownership, and automated checks. For this scenario: Monitor critical quotas, request increases ahead of launches, distribute capacity across regions/zones, and treat quota as part of reliability design.
104
Question 104Hard
GCP release scenario: Add quota monitoring before a launch. How do you ship the change safely?
Separate build, deploy, validation, and cutover. Use canary or blue/green where possible, keep the old path available until health checks pass, and define rollback before starting. Watch saturation, errors, latency, and user-facing checks. For this scenario: Monitor critical quotas, request increases ahead of launches, distribute capacity across regions/zones, and treat quota as part of reliability design.
105
Question 105Medium
GCP reliability/cost scenario: Reserved capacity increases idle cost. What signals do you inspect and what changes do you make?
Look at utilization, error rate, latency, queue depth, throttling, quota, retry volume, and recent deployment history. Optimize the bottleneck rather than guessing. Prefer rightsizing, caching, batching, and lifecycle policies before broad rewrites. For this scenario: Monitor critical quotas, request increases ahead of launches, distribute capacity across regions/zones, and treat quota as part of reliability design.
106
Question 106MediumGKE autoscaling
Why can’t CPU-only HPA wake a GKE workload from zero replicas?
With no Pods running, there is no workload CPU or memory measurement to trigger scale-up. Use an External or Object metric such as queue depth that remains available at zero replicas. Google’s current GKE guide requires control plane and nodes at version 1.37 or later, an autoscaling/v2 HPA with minReplicas: 0, and the relevant AutoscalingMetric configuration.
Verify metric access and status, then test both idle scale-down and demand-triggered wake-up. Cold starts and metric delays affect latency. Do not confuse workload replica scaling with scaling node pools, or assume this GKE feature applies to every Kubernetes cluster.
107
Question 107MediumIdentity
How do you let a CI pipeline deploy to Google Cloud without a service-account key?
GitHub Actions currently uses a JSON key stored as a secret. Security wants it gone.
Show answer+
Use Workload Identity Federation. Create a workload identity pool and an OIDC provider that trusts the CI issuer, map claims such as repository and ref to attributes, and add an attribute condition so only your repository and protected branches or environments can authenticate.
Grant roles to that federated principal directly, or let it impersonate a narrowly scoped service account. The pipeline then exchanges its OIDC token for short-lived Google credentials on every run. Delete the old key and add an organization policy that blocks new service-account key creation.
Trade-offs
Federation removes long-lived keys, but a loose attribute condition can let any repository in the org authenticate.
Common mistake
Creating the provider without an attribute condition.
Follow-up
Which claims would you use to allow production deploys only from the main branch?
108
Question 108HardSecurity
A stolen credential could copy BigQuery data to an outside project. What stops that, and what breaks first?
IAM is tight, but a leaked analyst token could still query and export data to a project the attacker controls.
Show answer+
VPC Service Controls put supported services like BigQuery and Cloud Storage inside a service perimeter. Requests that would move data across the perimeter are denied even when IAM allows them, which blocks copying to an outside project.
Roll it out in dry-run mode first and read the violation logs. The usual breakages are cross-project pipelines, CI systems and consoles calling from outside, and third-party integrations. Fix them with explicit ingress and egress rules and access levels rather than widening the perimeter.
Trade-offs
Perimeters add strong protection against exfiltration but make legitimate cross-project work harder to change quickly.
Common mistake
Enforcing a perimeter directly without dry-run and taking down data pipelines.
Follow-up
How would you allow one partner project to read a single dataset across the perimeter?
A new product team wants Kubernetes but has no one to manage node pools.
Show answer+
In Autopilot, Google manages the nodes: provisioning, scaling, upgrades and hardening. You pay mainly for the CPU, memory and storage your Pods request, and the platform enforces secure defaults, which restricts some privileged workloads.
Standard gives you node pools to configure yourself and you pay for the nodes, used or not. Choose Standard when you need node-level control: custom node settings, privileged agents Autopilot does not allow, or special hardware setups. For most application teams, Autopilot removes a lot of work; set accurate requests, because they drive both scheduling and cost.
Trade-offs
Autopilot trades node control for less operations work; Standard gives control and makes you responsible for bin-packing.
Common mistake
Moving to Autopilot with inflated resource requests and paying for capacity the Pods never use.
Follow-up
Which workloads in your cluster would not run on Autopilot without changes?
110
Question 110MediumCost
A single analyst query cost more than the whole week. How do you control BigQuery spend?
Someone ran SELECT * over a multi-terabyte events table with no date filter.
Show answer+
With on-demand pricing you pay for bytes processed, so reduce what queries scan: partition big tables by date and require a partition filter, cluster on common filter columns, and select only the columns you need. A dry run shows the bytes a query would scan before it runs.
Add guardrails: set maximum bytes billed on queries or in tools, apply custom daily quotas per user or project, and alert on costly jobs from the jobs metadata views. For steady heavy use, compare capacity-based pricing, where you pay for slots instead of bytes.
Trade-offs
Required partition filters prevent accidents but can frustrate ad-hoc analysis; give analysts summary tables too.
Common mistake
Using LIMIT to make a query cheaper; it does not reduce bytes scanned on a normal table.
Follow-up
How would you show each team its BigQuery spend weekly?