You save $69.98
Professional Cloud Architect Premium Bundle
- Premium File 370 Questions & Answers
- Last Update: Nov 8, 2026
- Training Course 63 Lectures
- Study Guide 491 Pages
You save $69.98
A developer turns on verbose request-body logging to diagnose an API timeout, accidentally placing customer secrets in Cloud Logging. What should the architect recommend as the primary implementation decision?
The architecture should capture limited structured diagnostics and traces with sensitive-field redaction and access-controlled log retention. This addresses the scenario directly because useful observability does not require persisting raw secrets; telemetry is another data store subject to access and retention controls. The implementation is acceptable only if the team demonstrates: A diagnostic test captures the timeout path without sensitive token values and only authorized responders can read the logs.
Enable Cloud Logging for all raw HTTP bodies and compensate with a shorter retention window. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: A developer turns on verbose request-body logging to diagnose an API timeout, accidentally placing customer secrets in Cloud Logging. The decisive dependency is that useful observability does not require persisting raw secrets; telemetry is another data store subject to access and retention controls. The better complete recommendation is: Capture limited structured diagnostics and traces with sensitive-field redaction and access-controlled log retention. Source-case challenge: Shorter raw-request retention still allows customer secrets to be ingested, viewed or copied before expiration.
Mask token values only in the user interface while retaining raw copies in exported logs. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, useful observability does not require persisting raw secrets; telemetry is another data store subject to access and retention controls. The defensible decision is: Capture limited structured diagnostics and traces with sensitive-field redaction and access-controlled log retention. An implementation must be judged against: a diagnostic test captures the timeout path without sensitive token values and only authorized responders can read the logs.
Give all developers Log Viewer but rely on secrecy policies not to inspect credentials. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: A developer turns on verbose request-body logging to diagnose an API timeout, accidentally placing customer secrets in Cloud Logging. Capture limited structured diagnostics and traces with sensitive-field redaction and access-controlled log retention. is stronger because useful observability does not require persisting raw secrets; telemetry is another data store subject to access and retention controls.
A retailer needs complex ad-hoc SQL over terabytes of historical orders but does not need low-latency per-row OLTP updates. Which architecture recommendation best addresses the stated requirements and constraints?
The architecture should load curated analytical data into BigQuery with suitable partitioning and clustering, then manage query cost controls. This addresses the scenario directly because columnar analytical warehouses optimize large scans and aggregations, unlike transactional databases designed for record-by-record updates. The implementation is acceptable only if the team demonstrates: A benchmark completes representative analytic joins within cost and freshness constraints without affecting checkout transactions.
Move terabytes into a small Cloud SQL instance and optimize only transaction indexes. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: A retailer needs complex ad-hoc SQL over terabytes of historical orders but does not need low-latency per-row OLTP updates. The decisive dependency is that columnar analytical warehouses optimize large scans and aggregations, unlike transactional databases designed for record-by-record updates. The better complete recommendation is: Load curated analytical data into BigQuery with suitable partitioning and clustering, then manage query cost controls.
Keep ad-hoc reports on the production checkout database to avoid a separate analytical pipeline. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, columnar analytical warehouses optimize large scans and aggregations, unlike transactional databases designed for record-by-record updates. The defensible decision is: Load curated analytical data into BigQuery with suitable partitioning and clustering, then manage query cost controls. An implementation must be judged against: a benchmark completes representative analytic joins within cost and freshness constraints without affecting checkout transactions. Source-case challenge: Using production OLTP for heavy exploratory joins couples historical analytics load to business-critical checkout.
Store order history as objects and require analysts to scan individual files for SQL joins. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: A retailer needs complex ad-hoc SQL over terabytes of historical orders but does not need low-latency per-row OLTP updates. Load curated analytical data into BigQuery with suitable partitioning and clustering, then manage query cost controls. is stronger because columnar analytical warehouses optimize large scans and aggregations, unlike transactional databases designed for record-by-record updates.
A payments team maintains two application releases that share one database schema and wants a rollback-safe deployment without interrupting transactions. Which solution balances the business and technical requirements most defensibly?
The architecture should use an expand-migrate-contract database change sequence and verify both old and new app versions before final schema cleanup. This addresses the scenario directly because forward-and-backward-compatible schema changes keep a previous app version usable during a canary rollback. The implementation is acceptable only if the team demonstrates: Both release versions operate during an overlap test; traffic rollback succeeds and schema cleanup occurs only after old consumers retire.
Drop the old database column at the same moment the new application release is deployed. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: A payments team maintains two application releases that share one database schema and wants a rollback-safe deployment without interrupting transactions. The decisive dependency is that forward-and-backward-compatible schema changes keep a previous app version usable during a canary rollback. The better complete recommendation is: Use an expand-migrate-contract database change sequence and verify both old and new app versions before final schema cleanup.
Use application traffic rollback only, without maintaining compatible schema changes. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, forward-and-backward-compatible schema changes keep a previous app version usable during a canary rollback. The defensible decision is: Use an expand-migrate-contract database change sequence and verify both old and new app versions before final schema cleanup. An implementation must be judged against: both release versions operate during an overlap test; traffic rollback succeeds and schema cleanup occurs only after old consumers retire. Source-case challenge: Traffic rollback alone cannot restore old consumers after the shared database drops fields they still require.
Migrate the shared schema directly in production before testing both active client versions. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: A payments team maintains two application releases that share one database schema and wants a rollback-safe deployment without interrupting transactions. Use an expand-migrate-contract database change sequence and verify both old and new app versions before final schema cleanup. is stronger because forward-and-backward-compatible schema changes keep a previous app version usable during a canary rollback.
An analytics application must access a managed Google API privately and the network team assumes a lack of public VM IPs is enough to enforce private service access. How should the team demonstrate the intended security or reliability outcome?
The acceptance evidence is: A private subnet workload reaches the approved API without external VM IPs, while unauthorized service calls remain denied and logged. This validates the important boundary or service outcome rather than relying on a design assertion. The technical reason for requiring this evidence is: Private endpoint routing avoids exposing a VM directly, but service identity and DNS still determine which APIs are actually reachable.
The VM can resolve a public API hostname without making an authorized service request. That observation can be collected, but it does not exercise the service-level or security outcome named in the requirement. More direct end-to-end acceptance evidence is: A private subnet workload reaches the approved API without external VM IPs, while unauthorized service calls remain denied and logged.
A firewall rule exists but the workload cannot reach the intended API endpoint. This is a limited configuration or proxy signal and could be green while the requested outcome still fails. A representative successful test instead requires: A private subnet workload reaches the approved API without external VM IPs, while unauthorized service calls remain denied and logged. The causal issue is: Private endpoint routing avoids exposing a VM directly, but service identity and DNS still determine which APIs are actually reachable. Source-case challenge: A firewall policy document does not show that the actual workload can successfully invoke its authorized API.
A system status page is green while denied API calls are never exercised. The outcome being observed is not equivalent to the original user requirement for a transaction, control or recovery property. The specific proof must show: A private subnet workload reaches the approved API without external VM IPs, while unauthorized service calls remain denied and logged.
An API intermittently returns 503 errors and the operations team wants to upgrade every VM without collecting evidence. After the recommended changes, which residual risk is most directly relevant?
The sampled traces may miss a low-frequency race condition in a different code path. Even when the immediate design intervention succeeds, a later condition can still invalidate its assumptions. This scenario requires monitoring that specific dependency rather than a generic project concern.
A trace-sampling configuration may increase observability storage costs during an incident. That is a conceivable secondary concern, but the most direct residual after the proposed change is tied to the remaining unaddressed dependency: The sampled traces may miss a low-frequency race condition in a different code path. The scenario is specifically: An API intermittently returns 503 errors and the operations team wants to upgrade every VM without collecting evidence.
An API support client may still use obsolete retry behavior after the targeted fix. It deserves normal operating controls, yet it is less directly evidenced by this case than: The sampled traces may miss a low-frequency race condition in a different code path. The relevant technical boundary is: Failure isolation requires evidence from the request path, otherwise capacity changes can conceal an unhealthy dependency. Source-case challenge: An outdated client retry policy may need work, but the demonstrated residual after targeted diagnosis is a new or hidden 503 root in another path.
A redesigned dashboard could make it harder for responders to compare p99 latencies across versions. This could matter in a different release or configuration, but it is not the strongest case-supported unresolved exposure. The sampled traces may miss a low-frequency race condition in a different code path is more specifically connected to the architecture because failure isolation requires evidence from the request path, otherwise capacity changes can conceal an unhealthy dependency.
A batch-image renderer can checkpoint its progress and must minimize compute cost, but management expects frequent capacity preemptions. Which solution balances the business and technical requirements most defensibly?
The architecture should use suitable Spot VMs with checkpointing, bounded retries and fallback for deadlines rather than assume fixed VM uptime. This addresses the scenario directly because spot VM capacity is discounted because it is interruptible; checkpointing prevents loss of all progress when an instance ends. The implementation is acceptable only if the team demonstrates: A simulated termination resumes from a recorded checkpoint and completes the batch within the cost and deadline constraints.
Use standard on-demand VMs for every batch even when long interruptions are tolerable. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: A batch-image renderer can checkpoint its progress and must minimize compute cost, but management expects frequent capacity preemptions. The decisive dependency is that spot VM capacity is discounted because it is interruptible; checkpointing prevents loss of all progress when an instance ends. The better complete recommendation is: Use suitable Spot VMs with checkpointing, bounded retries and fallback for deadlines rather than assume fixed VM uptime.
Run interruptible Spot VMs without writing checkpoints or accounting for retries. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, spot VM capacity is discounted because it is interruptible; checkpointing prevents loss of all progress when an instance ends. The defensible decision is: Use suitable Spot VMs with checkpointing, bounded retries and fallback for deadlines rather than assume fixed VM uptime. An implementation must be judged against: a simulated termination resumes from a recorded checkpoint and completes the batch within the cost and deadline constraints. Source-case challenge: Using Spot VMs without checkpoints can force all work to restart after preemption and erase expected cost savings.
Place the batch exclusively on one Spot instance with no fallback for a contractual deadline. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: A batch-image renderer can checkpoint its progress and must minimize compute cost, but management expects frequent capacity preemptions. Use suitable Spot VMs with checkpointing, bounded retries and fallback for deadlines rather than assume fixed VM uptime. is stronger because spot VM capacity is discounted because it is interruptible; checkpointing prevents loss of all progress when an instance ends.
A news subscription business wants readers in three continents to see articles quickly, but content editors require consistent publication permissions and a predictable monthly budget. What remaining exposure should the architecture review continue to track?
Breaking news can remain stale briefly if invalidation or cache-control rules are incorrect. Even when the immediate design intervention succeeds, a later condition can still invalidate its assumptions. This scenario requires monitoring that specific dependency rather than a generic project concern.
An edge POP might briefly have higher latency than the origin during network congestion. That is a conceivable secondary concern, but the most direct residual after the proposed change is tied to the remaining unaddressed dependency: Breaking news can remain stale briefly if invalidation or cache-control rules are incorrect. The scenario is specifically: A news subscription business wants readers in three continents to see articles quickly, but content editors require consistent publication permissions and a predictable monthly budget. Source-case challenge: An edge POP slow period is a CDN network concern; incorrect invalidation directly undermines the breaking-news freshness requirement.
The centralized editorial identity provider might become unavailable during a publishing shift. It deserves normal operating controls, yet it is less directly evidenced by this case than: Breaking news can remain stale briefly if invalidation or cache-control rules are incorrect. The relevant technical boundary is: Serving immutable read-heavy assets from edge caches reduces origin load without granting distributed readers editorial write authority.
Published media could increase egress charges beyond the initial forecast despite a sound cache policy. This could matter in a different release or configuration, but it is not the strongest case-supported unresolved exposure. Breaking news can remain stale briefly if invalidation or cache-control rules are incorrect is more specifically connected to the architecture because serving immutable read-heavy assets from edge caches reduces origin load without granting distributed readers editorial write authority.
An API team pages engineers whenever CPU exceeds 50 percent despite no corresponding customer failures and frequent alert noise. Which future condition could invalidate the proposed solution despite its initial success?
An SLI missing one critical customer journey can underreport genuine business failures. Even when the immediate design intervention succeeds, a later condition can still invalidate its assumptions. This scenario requires monitoring that specific dependency rather than a generic project concern.
A future SLO revision may require a different alert burn-rate window. That is a conceivable secondary concern, but the most direct residual after the proposed change is tied to the remaining unaddressed dependency: An SLI missing one critical customer journey can underreport genuine business failures. The scenario is specifically: An API team pages engineers whenever CPU exceeds 50 percent despite no corresponding customer failures and frequent alert noise.
The team's staffing calendar may need updating to cover overnight pages. It deserves normal operating controls, yet it is less directly evidenced by this case than: An SLI missing one critical customer journey can underreport genuine business failures. The relevant technical boundary is: User-impact signals make alerts actionable; resource thresholds alone do not prove a service objective is failing.
A reporting client could demand a different unit for displayed latency metrics. This could matter in a different release or configuration, but it is not the strongest case-supported unresolved exposure. An SLI missing one critical customer journey can underreport genuine business failures is more specifically connected to the architecture because user-impact signals make alerts actionable; resource thresholds alone do not prove a service objective is failing. Source-case challenge: Staffing calendars change operational readiness, but excluding a critical user path from SLIs directly underreports customer failures.
A financial API sees poor tail latency although mean latency is acceptable and compute utilization is moderate. What should the architect recommend as the primary implementation decision?
The architecture should define an end-to-end latency SLI, use distributed traces and dependency timing, then optimize the demonstrated critical path before resizing infrastructure. This addresses the scenario directly because averages hide a long tail caused by specific downstream waits, so changing VM size before finding the bottleneck wastes capacity. The implementation is acceptable only if the team demonstrates: Repeated percentiles and spans show the offending dependency improved while error rate and cost remain within objectives.
Upgrade every VM's CPU allocation without investigating requests at the slow tail. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: A financial API sees poor tail latency although mean latency is acceptable and compute utilization is moderate. The decisive dependency is that averages hide a long tail caused by specific downstream waits, so changing VM size before finding the bottleneck wastes capacity. The better complete recommendation is: Define an end-to-end latency SLI, use distributed traces and dependency timing, then optimize the demonstrated critical path before resizing infrastructure. Source-case challenge: Increasing VM CPUs without traces assumes a compute bottleneck contradicted by moderate utilization and poor p99.
Track average latency only and close the incident while p99 stays above target. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, averages hide a long tail caused by specific downstream waits, so changing VM size before finding the bottleneck wastes capacity. The defensible decision is: Define an end-to-end latency SLI, use distributed traces and dependency timing, then optimize the demonstrated critical path before resizing infrastructure. An implementation must be judged against: repeated percentiles and spans show the offending dependency improved while error rate and cost remain within objectives.
Add more load-balancer instances before tracing the slow downstream dependency. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: A financial API sees poor tail latency although mean latency is acceptable and compute utilization is moderate. Define an end-to-end latency SLI, use distributed traces and dependency timing, then optimize the demonstrated critical path before resizing infrastructure. is stronger because averages hide a long tail caused by specific downstream waits, so changing VM size before finding the bottleneck wastes capacity.
A multi-region mobile application stores account settings in a single regional database, and a disaster-recovery workshop reveals no tested route to surviving a region outage. What underlying technical principle most directly explains this architecture risk?
Replication alone cannot ensure recoverability if DNS, secrets, authorization and promotion procedures do not follow the target region. That causal principle explains the original failure and supports the recommended intervention: Define regional recovery topology, RPO/RTO budgets, data replication, application failover and runbook ownership; rehearse full dependencies. An observed effect alone is not a substitute for the mechanism.
Data replication alone restores end-to-end service after regional DNS and identity failure. It offers an appealing simple explanation but attributes the problem to a condition not established by the source-case facts. The mechanism that actually connects the requirement to the architecture is: Replication alone cannot ensure recoverability if DNS, secrets, authorization and promotion procedures do not follow the target region. Source-case challenge: Replicating data does not restore the DNS, identity, secrets, promotion authority, and app routing needed for whole-system service.
A second region automatically assumes application leadership without a promotion protocol. This overstates an architectural component or confuses a convenient symptom with its cause. The case instead depends on: replication alone cannot ensure recoverability if DNS, secrets, authorization and promotion procedures do not follow the target region. This is why the appropriate intervention is: Define regional recovery topology, RPO/RTO budgets, data replication, application failover and runbook ownership; rehearse full dependencies.
A healthy replica proves every authorization and API dependency can run in the secondary region. The claim would leave the essential causal condition unexplained for this scenario: A multi-region mobile application stores account settings in a single regional database, and a disaster-recovery workshop reveals no tested route to surviving a region outage. The correct underlying technical relationship is: Replication alone cannot ensure recoverability if DNS, secrets, authorization and promotion procedures do not follow the target region.
A retailer needs complex ad-hoc SQL over terabytes of historical orders but does not need low-latency per-row OLTP updates. What underlying technical principle most directly explains this architecture risk?
Columnar analytical warehouses optimize large scans and aggregations, unlike transactional databases designed for record-by-record updates. That causal principle explains the original failure and supports the recommended intervention: Load curated analytical data into BigQuery with suitable partitioning and clustering, then manage query cost controls. An observed effect alone is not a substitute for the mechanism.
OLTP row indexes always outperform columnar scans for terabyte-scale aggregations. It offers an appealing simple explanation but attributes the problem to a condition not established by the source-case facts. The mechanism that actually connects the requirement to the architecture is: Columnar analytical warehouses optimize large scans and aggregations, unlike transactional databases designed for record-by-record updates. Source-case challenge: Transaction-oriented indexes do not necessarily accelerate huge columnar scans and cross-row aggregations.
Keeping reports on the checkout database eliminates analytic isolation risk. This overstates an architectural component or confuses a convenient symptom with its cause. The case instead depends on: columnar analytical warehouses optimize large scans and aggregations, unlike transactional databases designed for record-by-record updates. This is why the appropriate intervention is: Load curated analytical data into BigQuery with suitable partitioning and clustering, then manage query cost controls.
Partition filters cannot reduce the amount of historical data scanned by BigQuery. The claim would leave the essential causal condition unexplained for this scenario: A retailer needs complex ad-hoc SQL over terabytes of historical orders but does not need low-latency per-row OLTP updates. The correct underlying technical relationship is: Columnar analytical warehouses optimize large scans and aggregations, unlike transactional databases designed for record-by-record updates.
or Guarantee your success by buying the full version which covers the full latest pool of questions. (370 Questions, Last Updated on Nov 8, 2026)
Please check your mailbox for a message from support@examlabs.com and follow the directions.