Exam Bundle

A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals. That observed result would support another specific correction: Combine workload utilization and resource allocation signals with cost attribution to evaluate the capacity trade-off. The other scenario concerns: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. The current Timberline Foods problem is: A team treats OpenTelemetry as a proprietary replacement for every monitoring backend and locks telemetry to one vendor. The evidence required here is: The same application instrumentation sends representative traces or metrics to an alternative approved backend.

The report computes the observed success ratio and compares it to the documented SLO and remaining error budget. That observed result would support another specific correction: Define a measurable SLI, its target over a time window as an SLO, and track the error budget against that target. The other scenario concerns: A monitoring team defines an SLO as a chart title and cannot explain how to tell whether a reliability goal is met. The current Timberline Foods problem is: A team treats OpenTelemetry as a proprietary replacement for every monitoring backend and locks telemetry to one vendor. The evidence required here is: The same application instrumentation sends representative traces or metrics to an alternative approved backend.

The architecture maps metric scraping to Prometheus and Pod scheduling to Kubernetes rather than treating them as one component. That observed result would support another specific correction: Explain that Prometheus collects and queries metrics while Kubernetes controllers and schedulers manage workload placement. The other scenario concerns: An engineer expects Prometheus to be a container runtime that schedules observability agents onto workers. The current Timberline Foods problem is: A team treats OpenTelemetry as a proprietary replacement for every monitoring backend and locks telemetry to one vendor. The evidence required here is: The same application instrumentation sends representative traces or metrics to an alternative approved backend.

Define a measurable SLI, its target over a time window as an SLO, and track the error budget against that target. That choice addresses a different foundational issue: A monitoring team defines an SLO as a chart title and cannot explain how to tell whether a reliability goal is met. The issue at Juniper Media is instead: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. It does not establish the required correction; the decisive verification would be: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

Explain that Prometheus collects and queries metrics while Kubernetes controllers and schedulers manage workload placement. That choice addresses a different foundational issue: An engineer expects Prometheus to be a container runtime that schedules observability agents onto workers. The issue at Juniper Media is instead: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. It does not establish the required correction; the decisive verification would be: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

Use bounded-cardinality metric dimensions and keep per-request identifiers in logs or traces instead. That choice addresses a different foundational issue: A cluster team creates a separate high-cardinality metric label for each request ID and overwhelms time-series storage. The issue at Juniper Media is instead: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. It does not establish the required correction; the decisive verification would be: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

The report computes the observed success ratio and compares it to the documented SLO and remaining error budget. That observed result would support another specific correction: Define a measurable SLI, its target over a time window as an SLO, and track the error budget against that target. The other scenario concerns: A monitoring team defines an SLO as a chart title and cannot explain how to tell whether a reliability goal is met. The current Juniper Media problem is: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. The evidence required here is: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

A single trace connects the three service spans and its associated sanitized log events. That observed result would support another specific correction: Propagate trace context and correlation identifiers through the service chain using supported observability instrumentation. The other scenario concerns: A distributed request fails between three microservices and operators cannot match the separate service logs to one request. The current Juniper Media problem is: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. The evidence required here is: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

A brief harmless spike no longer pages the on-call team while a sustained service failure still alerts. That observed result would support another specific correction: Define actionable alert conditions with suitable persistence and user-impact context rather than raw instantaneous spikes. The other scenario concerns: An alert sends a page to operators for every short-lived CPU peak even though no service impairment occurs. The current Juniper Media problem is: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. The evidence required here is: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

Explain that Prometheus collects and queries metrics while Kubernetes controllers and schedulers manage workload placement. That choice addresses a different foundational issue: An engineer expects Prometheus to be a container runtime that schedules observability agents onto workers. The issue at Meadowbrook Finance is instead: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. It does not establish the required correction; the decisive verification would be: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

Use bounded-cardinality metric dimensions and keep per-request identifiers in logs or traces instead. That choice addresses a different foundational issue: A cluster team creates a separate high-cardinality metric label for each request ID and overwhelms time-series storage. The issue at Meadowbrook Finance is instead: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. It does not establish the required correction; the decisive verification would be: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

Measure service-level indicators such as successful request rate and latency in addition to individual container restarts. That choice addresses a different foundational issue: An operator declares an outage whenever one Pod restarts despite end-user traffic remaining healthy across other replicas. The issue at Meadowbrook Finance is instead: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. It does not establish the required correction; the decisive verification would be: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

The same application instrumentation sends representative traces or metrics to an alternative approved backend. That observed result would support another specific correction: Use OpenTelemetry instrumentation and supported exporters to collect telemetry with backend-independent interfaces. The other scenario concerns: A team treats OpenTelemetry as a proprietary replacement for every monitoring backend and locks telemetry to one vendor. The current Meadowbrook Finance problem is: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. The evidence required here is: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

The metric series count stays within the configured budget while individual requests remain traceable elsewhere. That observed result would support another specific correction: Use bounded-cardinality metric dimensions and keep per-request identifiers in logs or traces instead. The other scenario concerns: A cluster team creates a separate high-cardinality metric label for each request ID and overwhelms time-series storage. The current Meadowbrook Finance problem is: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. The evidence required here is: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

The architecture maps metric scraping to Prometheus and Pod scheduling to Kubernetes rather than treating them as one component. That observed result would support another specific correction: Explain that Prometheus collects and queries metrics while Kubernetes controllers and schedulers manage workload placement. The other scenario concerns: An engineer expects Prometheus to be a container runtime that schedules observability agents onto workers. The current Meadowbrook Finance problem is: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. The evidence required here is: A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals.

Favor open, interoperable interfaces and supported APIs while evaluating any documented gap before adding proprietary abstractions. That choice addresses a different foundational issue: A platform team builds a bespoke orchestration API despite existing Kubernetes declarative APIs and supported open standards meeting the need. The issue at Eastshore Energy is instead: A cloud-native design assumes a microservice must share memory with another service to scale it independently. It does not establish the required correction; the decisive verification would be: One service version can be rolled out without rebuilding or restarting the unrelated service.

Explain Envoy's role as a high-performance network proxy that can support service-mesh or gateway traffic. That choice addresses a different foundational issue: A new teammate treats Envoy as a container scheduler and expects it to assign Pods to nodes. The issue at Eastshore Energy is instead: A cloud-native design assumes a microservice must share memory with another service to scale it independently. It does not establish the required correction; the decisive verification would be: One service version can be rolled out without rebuilding or restarting the unrelated service.

Distinguish north-south API ingress responsibilities from service mesh capabilities such as service-to-service identity and traffic policy. That choice addresses a different foundational issue: A software architect uses an API gateway for all internal mutual authentication needs and assumes this provides a service mesh automatically. The issue at Eastshore Energy is instead: A cloud-native design assumes a microservice must share memory with another service to scale it independently. It does not establish the required correction; the decisive verification would be: One service version can be rolled out without rebuilding or restarting the unrelated service.

An example workload uses managed execution but still documents timeouts, concurrency limits and billing drivers. That observed result would support another specific correction: Explain serverless as abstracting server management while execution limits, scaling behavior and cost still need design. The other scenario concerns: An engineer claims serverless eliminates all infrastructure and always removes the need for concurrency or cost planning. The current Eastshore Energy problem is: A cloud-native design assumes a microservice must share memory with another service to scale it independently. The evidence required here is: One service version can be rolled out without rebuilding or restarting the unrelated service.

The design identifies the correct gateway entry point and separate internal service communication controls when required. That observed result would support another specific correction: Distinguish north-south API ingress responsibilities from service mesh capabilities such as service-to-service identity and traffic policy. The other scenario concerns: A software architect uses an API gateway for all internal mutual authentication needs and assumes this provides a service mesh automatically. The current Eastshore Energy problem is: A cloud-native design assumes a microservice must share memory with another service to scale it independently. The evidence required here is: One service version can be rolled out without rebuilding or restarting the unrelated service.

The same conceptual deployment pattern can be implemented on more than one conformant Kubernetes environment. That observed result would support another specific correction: Explain cloud native as an approach emphasizing modular architecture, automation, containers and resilience rather than vendor lock-in. The other scenario concerns: A team claims cloud native means an application must run on only one named public cloud provider. The current Eastshore Energy problem is: A cloud-native design assumes a microservice must share memory with another service to scale it independently. The evidence required here is: One service version can be rolled out without rebuilding or restarting the unrelated service.

Distinguish north-south API ingress responsibilities from service mesh capabilities such as service-to-service identity and traffic policy. That choice addresses a different foundational issue: A software architect uses an API gateway for all internal mutual authentication needs and assumes this provides a service mesh automatically. The issue at Alpine Healthcare is instead: A cloud-native design assumes a microservice must share memory with another service to scale it independently. It does not establish the required correction; the decisive verification would be: One service version can be rolled out without rebuilding or restarting the unrelated service.

Explain Envoy's role as a high-performance network proxy that can support service-mesh or gateway traffic. That choice addresses a different foundational issue: A new teammate treats Envoy as a container scheduler and expects it to assign Pods to nodes. The issue at Alpine Healthcare is instead: A cloud-native design assumes a microservice must share memory with another service to scale it independently. It does not establish the required correction; the decisive verification would be: One service version can be rolled out without rebuilding or restarting the unrelated service.

Favor open, interoperable interfaces and supported APIs while evaluating any documented gap before adding proprietary abstractions. That choice addresses a different foundational issue: A platform team builds a bespoke orchestration API despite existing Kubernetes declarative APIs and supported open standards meeting the need. The issue at Alpine Healthcare is instead: A cloud-native design assumes a microservice must share memory with another service to scale it independently. It does not establish the required correction; the decisive verification would be: One service version can be rolled out without rebuilding or restarting the unrelated service.

A fresh Pod reproduces the approved application version without hidden changes from a previously edited container. That observed result would support another specific correction: Replace workloads from versioned declarative artifacts instead of relying on persistent manual mutations to live instances. The other scenario concerns: A platform designer assumes immutable infrastructure means directly patching a running production container until it matches the desired version. The current Alpine Healthcare problem is: A cloud-native design assumes a microservice must share memory with another service to scale it independently. The evidence required here is: One service version can be rolled out without rebuilding or restarting the unrelated service.

The same conceptual deployment pattern can be implemented on more than one conformant Kubernetes environment. That observed result would support another specific correction: Explain cloud native as an approach emphasizing modular architecture, automation, containers and resilience rather than vendor lock-in. The other scenario concerns: A team claims cloud native means an application must run on only one named public cloud provider. The current Alpine Healthcare problem is: A cloud-native design assumes a microservice must share memory with another service to scale it independently. The evidence required here is: One service version can be rolled out without rebuilding or restarting the unrelated service.

The architecture places Envoy in the traffic path and the Kubernetes scheduler in the workload placement path. That observed result would support another specific correction: Explain Envoy's role as a high-performance network proxy that can support service-mesh or gateway traffic. The other scenario concerns: A new teammate treats Envoy as a container scheduler and expects it to assign Pods to nodes. The current Alpine Healthcare problem is: A cloud-native design assumes a microservice must share memory with another service to scale it independently. The evidence required here is: One service version can be rolled out without rebuilding or restarting the unrelated service.

Distinguish north-south API ingress responsibilities from service mesh capabilities such as service-to-service identity and traffic policy. That choice addresses a different foundational issue: A software architect uses an API gateway for all internal mutual authentication needs and assumes this provides a service mesh automatically. The issue at Brookside Manufacturing is instead: A team claims cloud native means an application must run on only one named public cloud provider. It does not establish the required correction; the decisive verification would be: The same conceptual deployment pattern can be implemented on more than one conformant Kubernetes environment.

Explain Envoy's role as a high-performance network proxy that can support service-mesh or gateway traffic. That choice addresses a different foundational issue: A new teammate treats Envoy as a container scheduler and expects it to assign Pods to nodes. The issue at Brookside Manufacturing is instead: A team claims cloud native means an application must run on only one named public cloud provider. It does not establish the required correction; the decisive verification would be: The same conceptual deployment pattern can be implemented on more than one conformant Kubernetes environment.

Replace workloads from versioned declarative artifacts instead of relying on persistent manual mutations to live instances. That choice addresses a different foundational issue: A platform designer assumes immutable infrastructure means directly patching a running production container until it matches the desired version. The issue at Brookside Manufacturing is instead: A team claims cloud native means an application must run on only one named public cloud provider. It does not establish the required correction; the decisive verification would be: The same conceptual deployment pattern can be implemented on more than one conformant Kubernetes environment.

The monitoring diagram separates collected log records from application metrics used for numeric trend alerts. That observed result would support another specific correction: Describe log pipelines and metrics systems as complementary observability components with different data types. The other scenario concerns: A team installs Fluent Bit for log collection and expects it to replace Prometheus metrics scraping and alert queries entirely. The current Brookside Manufacturing problem is: A team claims cloud native means an application must run on only one named public cloud provider. The evidence required here is: The same conceptual deployment pattern can be implemented on more than one conformant Kubernetes environment.

The architecture places Envoy in the traffic path and the Kubernetes scheduler in the workload placement path. That observed result would support another specific correction: Explain Envoy's role as a high-performance network proxy that can support service-mesh or gateway traffic. The other scenario concerns: A new teammate treats Envoy as a container scheduler and expects it to assign Pods to nodes. The current Brookside Manufacturing problem is: A team claims cloud native means an application must run on only one named public cloud provider. The evidence required here is: The same conceptual deployment pattern can be implemented on more than one conformant Kubernetes environment.

A client can use the documented standard API on another conformant implementation for the same basic operation. That observed result would support another specific correction: Favor open, interoperable interfaces and supported APIs while evaluating any documented gap before adding proprietary abstractions. The other scenario concerns: A platform team builds a bespoke orchestration API despite existing Kubernetes declarative APIs and supported open standards meeting the need. The current Brookside Manufacturing problem is: A team claims cloud native means an application must run on only one named public cloud provider. The evidence required here is: The same conceptual deployment pattern can be implemented on more than one conformant Kubernetes environment.