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 generative AI support bot receives user-uploaded PDFs and may invoke a tool that queries confidential support cases. What underlying technical principle most directly explains this architecture risk?
Prompt filtering helps detect malicious content, but only the tool authorization boundary prevents untrusted text from borrowing privileged access. That causal principle explains the original failure and supports the recommended intervention: Apply untrusted-input handling, Model Armor or suitable prompt-injection safeguards, and independent authorization on each tool call. An observed effect alone is not a substitute for the mechanism.
A natural-language safety filter guarantees a tool cannot access data outside the user's entitlement. 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: Prompt filtering helps detect malicious content, but only the tool authorization boundary prevents untrusted text from borrowing privileged access. Source-case challenge: Moderation is not an authorization gate; privileged tools must independently recheck each caller's approved scope.
A user-uploaded document can safely override a system instruction when it claims higher priority. This overstates an architectural component or confuses a convenient symptom with its cause. The case instead depends on: prompt filtering helps detect malicious content, but only the tool authorization boundary prevents untrusted text from borrowing privileged access. This is why the appropriate intervention is: Apply untrusted-input handling, Model Armor or suitable prompt-injection safeguards, and independent authorization on each tool call.
Content moderation on output text replaces access checks before privileged tool execution. The claim would leave the essential causal condition unexplained for this scenario: A generative AI support bot receives user-uploaded PDFs and may invoke a tool that queries confidential support cases. The correct underlying technical relationship is: Prompt filtering helps detect malicious content, but only the tool authorization boundary prevents untrusted text from borrowing privileged access.
A document approval service runs on Cloud Run and has sporadic traffic; the first request after idle is too slow for a 300-millisecond interactive target. Which design choice most directly closes the demonstrated gap?
The architecture should set and measure appropriate Cloud Run minimum instances and optimize cold initialization, balancing reserved warm capacity against the latency SLO. This addresses the scenario directly because keeping a minimum pool warm can reduce scale-from-zero startup latency, although it adds idle cost and does not cure slow request handlers. The implementation is acceptable only if the team demonstrates: Cold-period synthetic requests meet the target and measured idle-instance cost stays inside the approved budget.
Increase the maximum instance limit but allow the service to scale all the way to zero. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: A document approval service runs on Cloud Run and has sporadic traffic; the first request after idle is too slow for a 300-millisecond interactive target. The decisive dependency is that keeping a minimum pool warm can reduce scale-from-zero startup latency, although it adds idle cost and does not cure slow request handlers. The better complete recommendation is: Set and measure appropriate Cloud Run minimum instances and optimize cold initialization, balancing reserved warm capacity against the latency SLO. Source-case challenge: Raising maximum instances changes upper capacity rather than keeping workers warm before the first request after inactivity.
Switch to a permanently running GKE cluster without measuring startup delay or total cost. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, keeping a minimum pool warm can reduce scale-from-zero startup latency, although it adds idle cost and does not cure slow request handlers. The defensible decision is: Set and measure appropriate Cloud Run minimum instances and optimize cold initialization, balancing reserved warm capacity against the latency SLO. An implementation must be judged against: cold-period synthetic requests meet the target and measured idle-instance cost stays inside the approved budget.
Add a CDN cache for authenticated approval POST operations rather than address cold initialization. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: A document approval service runs on Cloud Run and has sporadic traffic; the first request after idle is too slow for a 300-millisecond interactive target. Set and measure appropriate Cloud Run minimum instances and optimize cold initialization, balancing reserved warm capacity against the latency SLO. is stronger because keeping a minimum pool warm can reduce scale-from-zero startup latency, although it adds idle cost and does not cure slow request handlers.
A government contractor uses separate production and test projects but gives both projects the same powerful service account. Which mechanism best explains the failure mode in this situation?
A shared identity collapses isolation between environments; a compromise in testing can gain production permissions through the reused account. That causal principle explains the original failure and supports the recommended intervention: Create workload-specific service accounts with resource-scoped permissions and separation of duties, then remove cross-environment role inheritance. An observed effect alone is not a substitute for the mechanism.
Different project labels restrict a shared service account's permissions automatically. 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: A shared identity collapses isolation between environments; a compromise in testing can gain production permissions through the reused account. Source-case challenge: A shared service account retains role bindings across resources regardless of the project label on its name.
A single service account acquires less privilege when its key is used in testing. This overstates an architectural component or confuses a convenient symptom with its cause. The case instead depends on: a shared identity collapses isolation between environments; a compromise in testing can gain production permissions through the reused account. This is why the appropriate intervention is: Create workload-specific service accounts with resource-scoped permissions and separation of duties, then remove cross-environment role inheritance.
Restricting human users removes machine-identity access inherited across environments. The claim would leave the essential causal condition unexplained for this scenario: A government contractor uses separate production and test projects but gives both projects the same powerful service account. The correct underlying technical relationship is: A shared identity collapses isolation between environments; a compromise in testing can gain production permissions through the reused account.
A healthcare practice wants structured fields extracted from varied scanned forms while preserving human review for uncertain handwriting. What remaining exposure should the architecture review continue to track?
A new form layout or handwriting population can reduce extraction accuracy after deployment. 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 newly introduced form layout might require additional labeled evaluation examples. That is a conceivable secondary concern, but the most direct residual after the proposed change is tied to the remaining unaddressed dependency: A new form layout or handwriting population can reduce extraction accuracy after deployment. The scenario is specifically: A healthcare practice wants structured fields extracted from varied scanned forms while preserving human review for uncertain handwriting.
Clinical abbreviations could need specialty-specific extraction postprocessing. It deserves normal operating controls, yet it is less directly evidenced by this case than: A new form layout or handwriting population can reduce extraction accuracy after deployment. The relevant technical boundary is: Specialized document processing returns structured extraction results and quality signals, but low-confidence forms require escalation to avoid silently wrong records.
An institutional privacy policy might require a different manual reviewer role for sensitive forms. This could matter in a different release or configuration, but it is not the strongest case-supported unresolved exposure. A new form layout or handwriting population can reduce extraction accuracy after deployment is more specifically connected to the architecture because specialized document processing returns structured extraction results and quality signals, but low-confidence forms require escalation to avoid silently wrong records. Source-case challenge: Reviewer role governance is important, but a new form layout or handwriting style can undermine extraction accuracy after initial acceptance.
A VM web farm receives monthly patches by logging into each server manually and often serves inconsistent binaries. What remaining exposure should the architecture review continue to track?
A faulty common startup script can break every new instance even when the rollout mechanism works. 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.
The application could require a backward-compatible session format across rolling replacements. That is a conceivable secondary concern, but the most direct residual after the proposed change is tied to the remaining unaddressed dependency: A faulty common startup script can break every new instance even when the rollout mechanism works. The scenario is specifically: A VM web farm receives monthly patches by logging into each server manually and often serves inconsistent binaries.
A new startup dependency may lengthen readiness checks beyond their old threshold. It deserves normal operating controls, yet it is less directly evidenced by this case than: A faulty common startup script can break every new instance even when the rollout mechanism works. The relevant technical boundary is: Immutable templates and managed rollout prevent silent per-VM drift and allow controlled replacement of unhealthy instances. Source-case challenge: Session compatibility may need review, but a faulty shared startup script could break every new instance after a rollout.
The instance template may need a revised boot-disk size for a larger service image. This could matter in a different release or configuration, but it is not the strongest case-supported unresolved exposure. A faulty common startup script can break every new instance even when the rollout mechanism works is more specifically connected to the architecture because immutable templates and managed rollout prevent silent per-VM drift and allow controlled replacement of unhealthy instances.
A European research institution has a legal requirement to keep patient data in named regions, but architects suggest a globally replicated database without mapping replica locations. Which test provides the strongest evidence that the proposed remedy succeeded?
The acceptance evidence is: An inventory and data-flow test show every persisted copy and backup stays in permitted locations under a reviewed contract and policy. This validates the important boundary or service outcome rather than relying on a design assertion. The technical reason for requiring this evidence is: High availability replication improves fault tolerance but can violate data-residency obligations if replicas or backups cross prohibited borders.
The primary database displays a permitted location in Cloud Console. 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: An inventory and data-flow test show every persisted copy and backup stays in permitted locations under a reviewed contract and policy.
A query response originates near the user without a copy-location inventory. This is a limited configuration or proxy signal and could be green while the requested outcome still fails. A representative successful test instead requires: An inventory and data-flow test show every persisted copy and backup stays in permitted locations under a reviewed contract and policy. The causal issue is: High availability replication improves fault tolerance but can violate data-residency obligations if replicas or backups cross prohibited borders.
The application encrypts data but the backup region is not checked. The outcome being observed is not equivalent to the original user requirement for a transaction, control or recovery property. The specific proof must show: An inventory and data-flow test show every persisted copy and backup stays in permitted locations under a reviewed contract and policy. Source-case challenge: Ciphertext storage without a replica inventory cannot establish that every persisted copy meets the named-region obligation.
A global inventory service requires externally consistent transactions across regions while its analysts query transactions frequently from several countries. Which observation should drive production signoff for the revised architecture?
The acceptance evidence is: A concurrency test verifies correct cross-region inventory invariants, query performance and measured write p99 latency within the business budget. This validates the important boundary or service outcome rather than relying on a design assertion. The technical reason for requiring this evidence is: Spanner distributed replication supports strongly consistent transactional access, but cross-region commit quorum increases write latency compared with nearby replicas.
Cross-region SELECT queries return values without concurrent writes. 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 concurrency test verifies correct cross-region inventory invariants, query performance and measured write p99 latency within the business budget.
One regional transaction commits quickly with no partition or failover simulation. 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 concurrency test verifies correct cross-region inventory invariants, query performance and measured write p99 latency within the business budget. The causal issue is: Spanner distributed replication supports strongly consistent transactional access, but cross-region commit quorum increases write latency compared with nearby replicas. Source-case challenge: One fast regional transaction hides cross-region quorum latency and cannot validate global invariants under concurrency.
A dashboard shows high availability without verifying global inventory invariants. 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 concurrency test verifies correct cross-region inventory invariants, query performance and measured write p99 latency within the business budget.
A company shares Terraform state over email so two teams can apply incompatible production plans simultaneously. What design property is most important to understand before changing the implementation?
Concurrent state changes and unmanaged secrets in state files can corrupt infrastructure intent or expose credentials. That causal principle explains the original failure and supports the recommended intervention: Use a controlled remote state backend with locking, version control and approval-gated `terraform plan`/`apply` workflows. An observed effect alone is not a substitute for the mechanism.
Terraform automatically serializes concurrent apply operations across emailed state files. 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: Concurrent state changes and unmanaged secrets in state files can corrupt infrastructure intent or expose credentials.
A shared state copy ensures two independent writers cannot race. This overstates an architectural component or confuses a convenient symptom with its cause. The case instead depends on: concurrent state changes and unmanaged secrets in state files can corrupt infrastructure intent or expose credentials. This is why the appropriate intervention is: Use a controlled remote state backend with locking, version control and approval-gated `terraform plan`/`apply` workflows. Source-case challenge: Two copies of state do not prevent concurrent applies to the same live infrastructure without enforced state locking.
Local state modifications never affect production if the source code is versioned. The claim would leave the essential causal condition unexplained for this scenario: A company shares Terraform state over email so two teams can apply incompatible production plans simultaneously. The correct underlying technical relationship is: Concurrent state changes and unmanaged secrets in state files can corrupt infrastructure intent or expose credentials.
An e-commerce application publishes a new image to an old container tag and cannot identify which version caused increased checkout failures. Which design choice most directly closes the demonstrated gap?
The architecture should deploy immutable image digests into versioned revisions, expose them incrementally and automate rollback on SLO regression. This addresses the scenario directly because versioned artifacts make release provenance and rollback deterministic; overwriting a mutable tag hides which bytes are running. The implementation is acceptable only if the team demonstrates: A failing canary is traced to one digest and traffic returns to an approved revision with restored checkout success.
Keep overwriting the latest tag and store only the release date in a spreadsheet. This option changes a visible part of the architecture, but its scope is insufficient for the actual constraints: An e-commerce application publishes a new image to an old container tag and cannot identify which version caused increased checkout failures. The decisive dependency is that versioned artifacts make release provenance and rollback deterministic; overwriting a mutable tag hides which bytes are running. The better complete recommendation is: Deploy immutable image digests into versioned revisions, expose them incrementally and automate rollback on SLO regression.
Use image labels as the rollback identity without recording the underlying digest. The proposed shortcut does not preserve every stated business or technical boundary in this case. In particular, versioned artifacts make release provenance and rollback deterministic; overwriting a mutable tag hides which bytes are running. The defensible decision is: Deploy immutable image digests into versioned revisions, expose them incrementally and automate rollback on SLO regression. An implementation must be judged against: a failing canary is traced to one digest and traffic returns to an approved revision with restored checkout success. Source-case challenge: Image labels without immutable digest linkage do not identify which exact binary caused checkout regression.
Release the entire traffic share to every newly pushed image and inspect errors afterward. This would focus the effort on a different subsystem or presumed safeguard rather than the documented architecture need: An e-commerce application publishes a new image to an old container tag and cannot identify which version caused increased checkout failures. Deploy immutable image digests into versioned revisions, expose them incrementally and automate rollback on SLO regression. is stronger because versioned artifacts make release provenance and rollback deterministic; overwriting a mutable tag hides which bytes are running.
A company shares Terraform state over email so two teams can apply incompatible production plans simultaneously. Which unresolved concern deserves monitoring after the change?
A compromised apply identity could still change resources within its authorized Terraform permissions. 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.
The state store may need additional encryption-key rotation procedures. That is a conceivable secondary concern, but the most direct residual after the proposed change is tied to the remaining unaddressed dependency: A compromised apply identity could still change resources within its authorized Terraform permissions. The scenario is specifically: A company shares Terraform state over email so two teams can apply incompatible production plans simultaneously. Source-case challenge: Key rotation procedures are important to the backend, but a compromised apply identity can still use its legitimate change permissions.
Cross-region state backup replication might consume more egress than forecast. It deserves normal operating controls, yet it is less directly evidenced by this case than: A compromised apply identity could still change resources within its authorized Terraform permissions. The relevant technical boundary is: Concurrent state changes and unmanaged secrets in state files can corrupt infrastructure intent or expose credentials.
A new Terraform provider may change the formatting of resource diffs. This could matter in a different release or configuration, but it is not the strongest case-supported unresolved exposure. A compromised apply identity could still change resources within its authorized Terraform permissions is more specifically connected to the architecture because concurrent state changes and unmanaged secrets in state files can corrupt infrastructure intent or expose credentials.
A manufacturer plans to replace a 20-year-old factory scheduling system while contracts prohibit interrupting its plant interfaces during peak season. Which mechanism best explains the failure mode in this situation?
A strangler-style phased replacement limits disruption because dependent factory integrations keep a stable interface during incremental modernization. That causal principle explains the original failure and supports the recommended intervention: Document integration contracts, group features by business value and risk, and migrate behind a compatibility boundary with phased acceptance gates. An observed effect alone is not a substitute for the mechanism.
A full cutover is safer because factory integration failures occur only during transition. 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: A strangler-style phased replacement limits disruption because dependent factory integrations keep a stable interface during incremental modernization.
Replacing a database schema automatically preserves every plant's binary interface. This overstates an architectural component or confuses a convenient symptom with its cause. The case instead depends on: a strangler-style phased replacement limits disruption because dependent factory integrations keep a stable interface during incremental modernization. This is why the appropriate intervention is: Document integration contracts, group features by business value and risk, and migrate behind a compatibility boundary with phased acceptance gates. Source-case challenge: Changing the schema cannot by itself retain binary protocol compatibility with legacy factory equipment.
A compatibility adapter can be removed before any downstream plant has migrated. The claim would leave the essential causal condition unexplained for this scenario: A manufacturer plans to replace a 20-year-old factory scheduling system while contracts prohibit interrupting its plant interfaces during peak season. The correct underlying technical relationship is: A strangler-style phased replacement limits disruption because dependent factory integrations keep a stable interface during incremental modernization.
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.