GCP Cert Prep Coach prompts

Act as a senior Google Cloud architect explaining concepts to a junior engineer studying for the <CERT_CODE_E_G_ACE_PCA_PDE_PCSE_PCNE_PMLE_PCD_CDL> exam.

Topic: <GCP_SERVICE_OR_CONCEPT>
My current level: <BEGINNER | INTERMEDIATE | RUSTY>
My use case: <WHAT_I_AM_TRYING_TO_BUILD_OR_LEARN_IT_FOR>

Explain it in 4 layers:
1. The 1-sentence elevator pitch — what problem it solves.
2. The 3-bullet mental model — how it actually works, and CRITICALLY where it lives in the GCP resource hierarchy (Organization / Folder / Project / Resource) and whether it is global, multi-regional, regional or zonal. This matters more on GCP than on AWS/Azure because VPC is global, subnets are regional, GCE instances are zonal, and Cloud Storage buckets are multi-regional or regional at creation time — mixing them up is the #1 exam trap.
3. A concrete worked example with numbers, a tiny ASCII diagram, AND the equivalent `gcloud` CLI command to provision it (include `--project` and `--region`/`--zone` flags where they matter).
4. The 2-3 most common exam traps for this concept — for example: Basic IAM roles (Owner/Editor/Viewer) being too broad and forbidden in production, Cloud Run vs Cloud Run for Anthos, GKE Standard vs Autopilot node-management responsibility, Service Account impersonation vs key-file auth, Cloud SQL vs Cloud Spanner vs AlloyDB, App Engine Standard vs Flex cold-start, or any legacy-name pitfall (Stackdriver → Cloud Operations, AI Platform → Vertex AI, Datastore → Firestore).

Keep it under 350 words. No fluff. If something is commonly misunderstood — especially anything renamed or re-scoped in the last 24 months, or anything marked ‘Legacy’ in the docs — call it out as ⚠️ TRAP.

Generate 10 multiple-choice questions in the style of the Google Cloud <CERT_CODE_E_G_ACE_PCA_PDE_PCSE_PCNE_PMLE_PCD_CDL> exam, all on the topic of <DOMAIN_OR_SERVICE>.

Rules:
- Each question has exactly 4 options labeled A/B/C/D. NO ‘choose two’ or ‘choose three’ — Google Cloud exams are single-answer only (this is an easy way to spot AI-generated garbage that copies the Microsoft format).
- 8 must be scenario-based (Cymbal Superstores, Cymbal Bank, TerramEarth, Mountkirk Games — the recurring case-study companies Google uses — or a similar concrete situation with constraints), not definition recall.
- Include 2 questions where multiple options look correct but only one satisfies a stated non-functional requirement (latency budget, RTO/RPO, cost cap, compliance region, data residency). The wrong-but-plausible options should each miss a DIFFERENT requirement.
- Include 1 question with a legacy answer (Deployment Manager for greenfield, Cloud IoT Core, App Engine Flex, basic IAM Editor role, AI Platform notebooks, Stackdriver naming) so I learn to spot stale content that still floats around old training material.
- Use current 2026 service names — Cloud Operations (not Stackdriver), Vertex AI (not AI Platform), Firestore (not Datastore), Cloud Run gen2 execution env, BigQuery editions (Standard/Enterprise/Enterprise Plus, not flat-rate), Security Command Center Enterprise (not just SCC Premium).
- For PCA / PDE / PCSE especially, at least 3 questions should force a Well-Architected framework tradeoff — reliability vs cost, security vs performance, or operational excellence vs velocity. Name the pillar in the explanation.
- After ALL 10 questions, give me an answer key in a separate code block (so I can hide it while drilling) with 1-2 sentence explanations and the doc URL pattern (`cloud.google.com/<product>/docs/<page>` — you don't need an exact URL, the pattern is fine).

I just got this Google Cloud practice question wrong. Diagnose what I'm missing.

Question: <PASTE_QUESTION>

Options:
A) <OPT_A>
B) <OPT_B>
C) <OPT_C>
D) <OPT_D>

My answer: <MY_ANSWER>
Correct answer: <CORRECT_ANSWER>

Do this:
1. In 2 sentences, explain why my answer was wrong — but specifically name which GCP concept I'm confusing (e.g. ‘you're confusing Cloud Run services with Cloud Run jobs’, ‘you're confusing a Predefined role like roles/storage.objectViewer with the Basic role Viewer’, ‘you're confusing VPC Peering with a Shared VPC — peering does not share IAM’, ‘you're confusing Cloud Spanner with AlloyDB — Spanner is horizontally scaled with external strong consistency, AlloyDB is Postgres-compatible with read pools’), not just ‘because X is correct’.
2. In 2 sentences, explain why the correct answer is right and which Google Cloud Architecture Framework pillar it leans on (Operational Excellence / Security & Compliance / Reliability / Performance Optimization / Cost Optimization / Sustainability — remember, GCP has 6 pillars, not Azure's 5).
3. Give me the 1 sentence I should memorize about this concept to never miss it again.
4. List the 2 sibling services / editions / features that are commonly confused with this one, with a 1-line differentiator each. Include at least one renamed-service trap if relevant (Stackdriver → Cloud Operations, AI Platform → Vertex AI, Datastore → Firestore, BigQuery flat-rate → editions, App Engine Flex → Cloud Run).

No recap of the question. No fluff. Diagnostic mode.

I'm evaluating which Google Cloud service fits this scenario. Help me decide.

Scenario: <DESCRIBE_USE_CASE_INCLUDING_CONSTRAINTS_LIKE_LATENCY_COMPLIANCE_BUDGET_TEAM_SIZE_EXISTING_STACK_AND_DATA_RESIDENCY>
Region / compliance constraints: <E_G_EUROPE_WEST9_PARIS_GDPR_DATA_RESIDENCY_OR_NONE>
Candidates I'm choosing between: <SERVICE_1>, <SERVICE_2>, <SERVICE_3>, <SERVICE_4>

For each candidate, give me:
- One-line fit-score: 🟢 ideal / 🟡 workable / 🔴 wrong tool
- The single feature that makes it fit or not (be specific — ‘Spanner gives external strong consistency at global scale, AlloyDB does not’, ‘Cloud Run scales to zero, GKE Autopilot has a minimum node cost’, ‘Bigtable is petabyte-scale wide-column with single-digit-ms reads, BigQuery is columnar analytics not OLTP’)
- The hidden cost or constraint people forget (egress across regions, per-request billing minimums, sustained-use vs committed-use discounts, quota walls, cold-start on gen1 Functions, per-slot BigQuery pricing, Spanner minimum PU billing, GKE Autopilot per-pod pricing model)

Then give me your final pick + the Google Cloud Architecture Framework pillar that supports it (Operational Excellence / Security & Compliance / Reliability / Performance Optimization / Cost Optimization / Sustainability).

If two candidates are tied, name a concrete sub-scenario where each one wins. If one is a legacy path I should never pick on a 2026 exam (Deployment Manager for greenfield, App Engine Flex when Cloud Run fits, Datastore in Datastore mode when Firestore Native fits, AI Platform Notebooks when Vertex AI Workbench fits, Cloud IoT Core), say so explicitly.

Build me an exam-grade edition / tier comparison table for Google Cloud <SERVICE_NAME>, in the context of the <CERT_CODE_E_G_ACE_PCA_PDE_PCSE> exam.

Format (markdown table, one row per edition / tier / storage-class, no paragraphs):

| Edition / tier | Use it when | Don't use it when | Cost shape | Exam trap |

Rules:
- Cover every edition / tier / storage class that's still on a 2026 exam blueprint. Mark any deprecated or legacy option with ⚠️ and a 1-line ‘never pick on the exam’ note (e.g. BigQuery flat-rate is retired in favour of editions with autoscaling since 2023 — old training material still mentions it).
- ‘Cost shape’ is one line — what dimension drives the bill (per-slot-hour, per-GiB-stored, per-GiB-scanned, per-request, per-vCPU-hour, per-PU-hour, egress free / same-region-egress free / cross-region egress charged, retrieval fee, minimum storage duration, committed-use vs sustained-use discount eligibility).
- ‘Exam trap’ is the single misconception this edition/tier triggers (e.g. ‘Coldline has a 90-day minimum storage duration — early delete is charged as if you kept it 90 days’, ‘BigQuery Enterprise edition needs manual reservation config, Enterprise Plus adds autoscaling’, ‘Nearline retrieval fee applies even for a single object read’, ‘GKE Autopilot is billed per pod-vCPU/memory, not per node — a scaled-down deployment can still be pricier than Standard for steady workloads’, ‘Spanner PU pricing has a minimum of 100 PU per instance in production regions’, ‘Vertex AI online prediction bills per node-hour even at zero traffic on the classic endpoint — use rawPredict on newer endpoints if you need scale-to-zero’).

After the table, give me:
1. The default I should pick when the scenario gives no constraints.
2. The 2 scenario keywords that flip the answer (‘accessed monthly’ → Nearline; ‘accessed once a year’ → Coldline or Archive; ‘global writes with external consistency’ → Spanner regardless of cost; ‘steady 24/7 analytics workload with predictable slots’ → BigQuery Enterprise reservation; ‘bursty ad-hoc analytics’ → BigQuery on-demand or Enterprise autoscaling).
3. The single sentence I should memorize for this service.

Translate this Google Cloud provisioning task across all 4 surfaces so I can recognize it in any exam question format.

Task in plain English: <DESCRIBE_TASK_EXACTLY_E_G_CREATE_A_REGIONAL_CLOUD_STORAGE_BUCKET_IN_EUROPE_WEST9_WITH_UNIFORM_BUCKET_LEVEL_ACCESS_ENABLED_AND_PUBLIC_ACCESS_PREVENTION_ENFORCED>
Target exam: <CERT_CODE_E_G_ACE_PCA_PDE>

Give me, in this order:

1. **Console clickpath** — the exact navigation: ‘Console → Navigation menu → <PRODUCT> → CREATE → tab <TAB> → field <FIELD> = <VALUE>’. Name the tabs and the fields, not screenshots. Include which project selector I need at the top (‘Ensure the active project is <PROJECT_ID>’).
2. **gcloud one-liner** — the smallest `gcloud <group> <subcommand>` that produces the same result. No `gcloud auth login`, no project bootstrap unless it's part of the task. Include the flags the Console sets by default (`--uniform-bucket-level-access`, `--public-access-prevention=enforced`, `--location`, `--storage-class`, `--project`) so the result really matches the Console outcome. Show me any `--format` or `--filter` I would use to verify afterwards.
3. **Terraform (google provider)** — a self-contained `.tf` snippet with `provider "google" { project = var.project_id }`, the `resource` block, and any outputs the exam typically asks for. Match the Console defaults one-for-one in arguments. Explicitly note if you had to switch to the `google-beta` provider for a preview feature (this is a common exam trap — the beta provider is the tell that a feature is preview and may not be exam-answer material yet).
4. **Config Connector (K8s-style YAML for Config Connector)** — the equivalent `kind: <ProductResource>` manifest with the same fields. Note if the Config Connector CRD lags behind the API (e.g. new fields land in gcloud/Terraform first) — this is an exam trap that has caught PCA candidates.
5. **The 3 implicit defaults** the Console sets but the CLI / Terraform / Config Connector forms make you think about (e.g. ‘Console defaults uniform bucket-level access ON since 2022, gcloud still defaults it OFF unless you pass --uniform-bucket-level-access’, ‘Console enables public access prevention by default at the org level via org policy, gcloud does NOT unless --public-access-prevention=enforced’, ‘Console defaults customer-managed encryption to Google-managed keys unless you attach a CMEK — Terraform makes you spell it out or you get GMEK silently’). These are the highest-frequency exam traps.
6. **The verify command** — one `gcloud <product> describe` (or `bq show`, `kubectl get` for Config Connector) command that proves the resource was created with the right config (so you can spot a wrong-default exam question).

No lectures on what the service does. Treat me like I've passed the practice quizzes and I'm drilling cross-format fluency.