How many Troubleshooting Scenario Questions questions are on this page?

This page has 15 Troubleshooting Scenario Questions scenario questions for the PCD exam, each with detailed explanations and wrong-answer analysis.

How should I approach PCD scenario questions?

Read the full scenario before looking at the answer options. Identify the constraint or requirement in the scenario, then eliminate options that are generally true but wrong for this specific case. Scenario questions reward careful reading over pattern matching.

← Back to Google Professional Cloud Developer questions

Scenario-based practice

Troubleshooting Scenario Questions

Practise Google Professional Cloud Developer practice questions — original exam-style scenarios covering every exam domain, with detailed explanations, wrong-answer analysis, and common exam traps.

Start full practice test Read exam guide

scenario questions

PCD

exam code

Google Cloud

vendor

Scenario guide

How to approach troubleshooting scenario questions

These questions describe a network symptom and ask you to identify the root cause or the correct fix. They appear across all certification exams and reward systematic thinking over memorisation. The best candidates follow a consistent troubleshooting framework even under time pressure.

Quick answer

Troubleshooting Scenario Questions questions test whether you can apply the concept in context, not just recognise a definition.

How the topic appears in realistic exam-style scenarios.

Which detail in the question changes the correct answer.

How to eliminate plausible but wrong options.

How to connect the question back to the wider exam objective.

Practice scenarios

Question 1easymultiple choice

Full question →

A developer deploys the above app.yaml to App Engine standard environment. The deployment succeeds, but the application fails to connect to the database. What is the most likely reason?

Exhibit

Refer to the exhibit.
```
# app.yaml for App Engine standard environment
runtime: python39
entrypoint: gunicorn -b :$PORT main:app
env_variables:
  DATABASE_URL: "postgresql://user:pass@localhost/mydb"
```

A
The runtime 'python39' is not supported in App Engine standard environment.
Why wrong: Python 3.9 is a supported runtime.
B
The $PORT environment variable is not set in App Engine standard environment.
Why wrong: App Engine sets the PORT environment variable.
C
The application is trying to connect to a local database on localhost, which is not available in the App Engine sandbox.
App Engine standard does not allow connections to localhost; use Cloud SQL.
D
The entrypoint command is incorrect because gunicorn is not allowed.
Why wrong: gunicorn is allowed as an entrypoint.

Full breakdown with real-world context →

Question 2hardmultiple choice

Full question →

You are troubleshooting a web application deployed on Compute Engine instances behind a target pool. Users report intermittent timeouts when accessing the application via the forwarding rule's IP address. Based on the exhibit, what is the most likely cause of the issue?

Network Topology

A
The forwarding rule is missing a backend service.
Why wrong: Target pools do not use backend services.
B
The target pool lacks health checks, causing traffic to be sent to unhealthy instances.
Target pools rely on health checks to stop routing to unhealthy instances; without them, traffic may be routed to failed instances.
C
The port range is set to 80-80, which restricts traffic to port 80 only.
Why wrong: Port 80 is correct for HTTP; this would not cause timeouts.
D
The forwarding rule should use a backend service instead of a target pool for HTTP traffic.
Why wrong: Target pools can handle HTTP traffic, but health checks are still needed.

Full breakdown with real-world context →

Question 3mediummultiple choice

Full question →

During a deployment to App Engine flexible environment, the new version fails to start and the logs show 'Container failed to start: context deadline exceeded'. The previous version remains serving traffic. What is the most likely cause?

A
The health check is misconfigured, causing the instance to be considered unhealthy.
Why wrong: Health check failures cause instance replacement but not 'context deadline exceeded'.
B
The app requires an environment variable that is not set.
Why wrong: Missing env vars cause runtime errors, not a delay in startup.
C
The container startup time exceeds the 10-minute timeout.
App Engine flexible environment has a 10-minute startup timeout; if the container takes longer, it fails with this error.
D
The Dockerfile has a syntax error that prevents the container from building.
Why wrong: Build errors occur before deployment, not a startup timeout.

Full breakdown with real-world context →

Question 4mediumdrag order

Full question →

Drag and drop the steps to troubleshoot a failed Cloud Build in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps

Order

1Step 1

2Step 2

3Step 3

4Step 4

5Step 5

Question 5easymultiple choice

Full question →

Refer to the exhibit. A developer writes the above Dockerfile for a Cloud Run service. The service fails to start. The logs indicate that the container exited immediately. What is the most likely cause?

Network Topology

A
The WORKDIR is set to a directory that doesn't exist
Why wrong: WORKDIR creates the directory if it doesn't exist; this is not the cause.
B
The server.js file is missing from the build context
If server.js is not copied into the image (e.g., it's in a different directory or excluded by .dockerignore), the container has no entrypoint and exits immediately.
C
The CMD instruction is incorrectly formatted
Why wrong: The CMD is correctly written as JSON array; this is not the issue.
D
The EXPOSE 8080 instruction is unnecessary and may cause conflicts
Why wrong: EXPOSE is just documentation; it does not affect container startup.

Full breakdown with real-world context →

Question 6mediummultiple choice

Full question →

A developer is troubleshooting a deployment on Cloud Run. The service fails with 'Container failed to start' error. The container image is built from a Dockerfile that uses CMD ['npm', 'start']. What is the most likely cause?

A
The Dockerfile uses CMD instead of ENTRYPOINT.
Why wrong: Both are acceptable; CMD is fine when used with ENTRYPOINT or alone.
B
The container image is too large and exceeds the memory limit.
Why wrong: This would cause a different error or timeout, not a container start failure.
C
The application does not listen on the port specified by the PORT environment variable.
Cloud Run expects the container to listen on the port defined by the PORT env var (default 8080). If the app listens on another port, it fails.
D
The Cloud Run service does not have permission to pull the image from Container Registry.
Why wrong: That would cause an image pull error, not a container start failure.

Full breakdown with real-world context →

Question 7mediummultiple choice

Full question →

After updating the image to v2, users report that the frontend application returns errors because it cannot reach the backend service. The backend service is running on GKE with the name 'backend-service' in the same namespace. What is the most likely cause?

Exhibit

Refer to the exhibit.
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: gcr.io/my-project/frontend:v2
        ports:
        - containerPort: 8080
        env:
        - name: BACKEND_URL
          value: "http://backend-service:8080"
      terminationGracePeriodSeconds: 30
```

A
The selector labels do not match the pods.
Why wrong: The exhibit shows the selector matches the pod labels, so this is not the issue.
B
The application expects the backend URL from an environment variable named BACKEND_SERVICE_URL, but the deployment sets BACKEND_URL.
Variable name mismatch is a common cause of application misconfiguration.
C
The backend service is not listening on port 8080.
Why wrong: The port expected by the frontend matches the service port, so this is unlikely.
D
The termination grace period is too short causing connection drops.
Why wrong: Termination grace period affects shutdown, not connectivity issues.

Full breakdown with real-world context →

Question 8hardmultiple choice

Full question →

Refer to the exhibit. A team is deploying a Cloud Function that needs to connect to a Cloud SQL instance in a VPC. They have set up a VPC connector. After deployment, the function fails to connect to the database. What is the most likely cause?

Exhibit

resource "google_cloudfunctions_function" "function" {
  name        = "my-function"
  runtime     = "python39"
  entry_point = "hello_world"
  source_archive_bucket = google_storage_bucket.bucket.name
  source_archive_object = "function.zip"
  event_trigger {
    event_type = "google.storage.object.finalize"
    resource   = google_storage_bucket.bucket.name
  }
  vpc_connector = google_vpc_access_connector.connector.id
  vpc_connector_egress_settings = "ALL_TRAFFIC"
  environment_variables = {
    DB_HOST = "10.0.0.4"
  }
}

A
The VPC connector is in a different region than the function
The VPC connector and Cloud Function must be in the same region.
B
The function's service account does not have permissions to use the VPC connector
Why wrong: The default service account usually has the VPC Access user role.
C
The environment variable DB_HOST is misspelled
Why wrong: The variable name appears correct in the exhibit.
D
The database firewall rules do not allow traffic from the VPC connector's subnet
Why wrong: Cloud SQL private IP does not use firewall rules; it uses VPC peering.

Full breakdown with real-world context →

Question 9mediummultiple choice

Full question →

An application deployed on Google Kubernetes Engine is experiencing intermittent latency spikes. The team has enabled Cloud Trace and sees that a specific gRPC call to a backend service occasionally takes >500ms. However, the backend service's logs show no errors. What is the most likely cause that the team should investigate further?

A
The Cloud Trace sampling rate is too low, causing statistical noise.
Why wrong: Sampling rate affects which requests are traced, not the actual latency of individual requests.
B
The gRPC client is not using connection pooling, causing frequent TLS handshakes.
Correct: without connection pooling, each call may require a new handshake, adding latency especially during bursts.
C
The backend service is under-provisioned and experiencing resource contention only during peak traffic.
Why wrong: Under-provisioning would typically cause increased latency across all requests, not just occasional spikes, and likely log errors.
D
The network latency between the client and backend is high due to a misconfigured VPC firewall.
Why wrong: Firewall rules do not add latency; they either allow or block traffic.

Full breakdown with real-world context →

Question 10mediummultiple choice

Full question →

Refer to the exhibit. A Cloud Run service is unable to connect to a Cloud SQL instance. The log entry shows the following. What is the most likely cause?

Exhibit

{
  "resource.type": "cloud_run_revision",
  "severity": "ERROR",
  "textPayload": "Error: [project:us-central1:myinstance] cannot connect: connection refused"
}

A
The Cloud Run service account lacks the Cloud SQL Client role.
Without the cloudsql.client role, the VPC connector cannot authorize the connection, leading to a connection refused error.
B
The database user credentials are incorrect.
Why wrong: Incorrect credentials result in an authentication error, not a connection refused at the network level.
C
The Cloud SQL instance is in a different region than the Cloud Run service.
Why wrong: Cross-region connections are possible; the error would typically be a timeout, not a connection refused.
D
The Cloud SQL instance has a public IP assigned.
Why wrong: A public IP would not cause a connection refused by itself; the service would still try to connect, and if allowed, it would succeed.

Full breakdown with real-world context →

Question 11mediummulti select

Full question →

You are troubleshooting a performance issue in a microservices application. Which TWO tools from Google Cloud's operations suite would you use to trace a request across services and identify the slowest component?

A
Cloud Monitoring
Cloud Monitoring can display latency heatmaps and service graphs that help visualize the slowest component in a distributed trace.
B
Error Reporting
Why wrong: Error Reporting aggregates errors but does not trace performance latency across services.
C
Cloud Profiler
Why wrong: Cloud Profiler profiles code-level CPU and memory usage, not request traces across services.
D
Cloud Logging
Why wrong: Cloud Logging provides individual log entries but does not directly trace a request's full path across services.
E
Cloud Trace
Cloud Trace is the primary tool for distributed tracing, capturing end-to-end latency for each request and showing spans for each service call.

Full breakdown with real-world context →

Question 12mediummultiple choice

Full question →

A developer deploying a new version of a microservice sees a sudden increase in error logs in Cloud Logging. The errors are 500 responses from the service. What is the most efficient way to investigate the root cause?

A
Use Cloud Trace to view the trace of failed requests
Cloud Trace records traces for each request, including errors, allowing you to see the exact step that failed.
B
Revert to the previous version immediately
Why wrong: Rollback may restore service but fails to identify the root cause, risking recurrence.
C
Check the CPU and memory metrics in Cloud Monitoring
Why wrong: Resource metrics may show saturation but do not directly explain the logic errors causing 500 responses; they are less efficient for this symptom.
D
Analyze the error logs using Log Analytics and create a log-based metric
Why wrong: While log analysis can reveal error patterns, it is slower than tracing and does not provide the full request context.

Full breakdown with real-world context →

Question 13hardmultiple choice

Full question →

Refer to the exhibit. A developer runs the above command to deploy a Cloud Function triggered by Pub/Sub. The function fails to execute when a message is published. The logs show: "Function execution took 60001 ms, finished with status: 'timeout'". What should the developer do?

Network Topology

A
Change the trigger to HTTP
Why wrong: Changing the trigger type changes the event source but doesn't fix the timeout issue.
B
Reduce the number of function instances
Why wrong: Instance count affects concurrency, not execution time per request.
C
Check the function code for long-running operations
The timeout indicates the function is taking too long; the proper fix is to optimize the code to complete within the allowed time.
D
Increase the function timeout to 9 minutes
Why wrong: Increasing timeout is a temporary fix; the root cause is the slow code that should be optimized.

Full breakdown with real-world context →

Question 14mediummultiple choice

Read the full network assurance explanation →

A company has a legacy monolithic application running on Compute Engine that is being migrated to microservices on GKE. During the migration, they need to maintain performance monitoring across both environments. The legacy application uses Stackdriver Logging and Monitoring agents (now Ops Agent) and exports logs to Cloud Logging. The new microservices are instrumented with OpenTelemetry for traces and metrics. The team wants a unified view of performance across both environments, including distributed traces from the new services and log-based metrics from the legacy app. They also want to correlate logs and traces for troubleshooting. Which solution should they implement?

A
Keep monitoring separate and use separate dashboards for legacy and new.
Why wrong: Separate dashboards do not provide a unified view and hinder correlation.
B
Use a third-party APM tool that supports both environments.
Why wrong: While possible, it's not leveraging native Google Cloud tools and may add complexity.
C
Use Cloud Monitoring dashboards and ingest OpenTelemetry metrics into Cloud Monitoring, while using Cloud Logging log-based metrics from legacy app.
This approach unifies metrics and logs from both environments, enabling correlation.
D
Rewrite the legacy app to use OpenTelemetry.
Why wrong: Rewriting is costly and time-consuming, not necessary.

Full breakdown with real-world context →

Question 15hardmultiple choice

Full question →

You are a developer for an e-commerce platform running on Google Kubernetes Engine (GKE) with a Cloud SQL backend. The application uses Cloud Memorystore for Redis for session caching. During a flash sale, you notice that the application latency spikes and some users are unable to complete checkout. You suspect the Redis instance is overwhelmed. The Redis instance is currently a Standard tier instance with 5 GB of memory. You need to increase throughput without significant architectural changes. You have the following options: A) Migrate to a Memorystore Basic tier instance with a larger memory size. B) Enable for Redis clustering on the existing instance to distribute load across shards. C) Switch to a Memorystore Standard tier instance with a higher capacity and enable scaling. D) Use client-side caching to reduce load on the Redis instance. Which option should you choose?

A
Use client-side caching to reduce load on the Redis instance.
Why wrong: Client-side caching can help but is not a quick fix for an overwhelmed instance and adds complexity.
B
Switch to a Memorystore Standard tier instance with a higher capacity and enable scaling.
Standard tier supports vertical scaling and provides higher throughput and high availability.
C
Migrate to a Memorystore Basic tier instance with a larger memory size.
Why wrong: Basic tier has lower throughput and no replication, which could worsen performance during peak load.
D
Enable for Redis clustering on the existing instance to distribute load across shards.
Why wrong: Memorystore for Redis does not support clustering; you would need a different product.

Full breakdown with real-world context →

These PCD practice questions are part of Courseiva's free Google Cloud certification practice question bank. Courseiva provides original exam-style PCD questions with detailed explanations, topic-based practice, mock exams, readiness tracking, and study analytics.

Troubleshooting Scenario Questions

How to approach troubleshooting scenario questions

Quick answer

Related PCD topic practice pages

Designing highly scalable, available, and reliable cloud-native applications practice questions

Building and testing applications practice questions

Deploying applications practice questions

Integrating Google Cloud services practice questions

Managing application performance monitoring practice questions

PCD fundamentals practice questions

PCD scenario practice questions

PCD troubleshooting practice questions

Practice scenarios

A developer deploys the above app.yaml to App Engine standard environment. The deployment succeeds, but the application fails to connect to the database. What is the most likely reason?

Exhibit

You are troubleshooting a web application deployed on Compute Engine instances behind a target pool. Users report intermittent timeouts when accessing the application via the forwarding rule's IP address. Based on the exhibit, what is the most likely cause of the issue?

During a deployment to App Engine flexible environment, the new version fails to start and the logs show 'Container failed to start: context deadline exceeded'. The previous version remains serving traffic. What is the most likely cause?

Drag and drop the steps to troubleshoot a failed Cloud Build in the correct order.

Refer to the exhibit. A developer writes the above Dockerfile for a Cloud Run service. The service fails to start. The logs indicate that the container exited immediately. What is the most likely cause?

A developer is troubleshooting a deployment on Cloud Run. The service fails with 'Container failed to start' error. The container image is built from a Dockerfile that uses CMD ['npm', 'start']. What is the most likely cause?

After updating the image to v2, users report that the frontend application returns errors because it cannot reach the backend service. The backend service is running on GKE with the name 'backend-service' in the same namespace. What is the most likely cause?

Exhibit

Refer to the exhibit. A team is deploying a Cloud Function that needs to connect to a Cloud SQL instance in a VPC. They have set up a VPC connector. After deployment, the function fails to connect to the database. What is the most likely cause?

Exhibit

Refer to the exhibit. A Cloud Run service is unable to connect to a Cloud SQL instance. The log entry shows the following. What is the most likely cause?

Exhibit

You are troubleshooting a performance issue in a microservices application. Which TWO tools from Google Cloud's operations suite would you use to trace a request across services and identify the slowest component?

A developer deploying a new version of a microservice sees a sudden increase in error logs in Cloud Logging. The errors are 500 responses from the service. What is the most efficient way to investigate the root cause?

Refer to the exhibit. A developer runs the above command to deploy a Cloud Function triggered by Pub/Sub. The function fails to execute when a message is published. The logs show: "Function execution took 60001 ms, finished with status: 'timeout'". What should the developer do?