Prepare and test your skills
Prepare and test your skills
Establishing key performance indicators (KPIs) for business alignment means turning business goals into measurable technical targets. A KPI connects system behavior to organizational value such as revenue, cost, risk, or satisfaction. Effective KPIs give architecture teams clear direction, make progress trackable over time, and help justify funding for performance work.
Aligning technology metrics with business goals means linking each technical initiative to a business objective and its key results. Business objectives include increasing revenue or profit, reducing costs, mitigating risk, and improving customer or employee satisfaction. Technical work should be prioritized by its system-level impact on those outcomes, not by separate budgets such as change-the-bank versus run-the-bank or front-office versus back-office.
This alignment shapes funding and design trade-offs in the cloud. A risk-analytics system that cuts calculation time from hours to minutes, for example, helps meet compliance requirements while letting traders offer tighter spreads and better client conversations. Optimizing end-to-end performance at the system level often creates more business value than tuning one server or component. The decision rule is to optimize first the components that most directly affect core business functions and user experience.
Core KPIs that link performance to business outcomes include technical measures and business-value measures that must be tracked together. Technical KPIs include latency, throughput, error rates, resource utilization, and availability. Business KPIs include total revenue, costs, conversion rate, retention or churn rate, customer satisfaction, and employee satisfaction. Cloud Monitoring (opens in a new tab) collects metrics for availability, performance, and latency so both types of indicators can be observed together.
The following options show how three common technical areas connect to organizational goals:
| KPI Area | What It Measures | Business Impact |
|---|---|---|
| System availability | Share of time the service is reachable and working, such as 99.9% availability | Protects revenue, trust, and contractual commitments when downtime would block users or transactions |
| Transaction throughput | Volume of work completed over time, such as transactions per second or model predictions served | Supports growth and peak demand, such as payroll days or high trading volumes, without over-provisioning |
| User engagement | How users adopt, return to, and succeed with the application | Signals satisfaction and value realization, which drive retention, conversion, and continued investment |
Throughput and availability determine whether the system can handle required load, while engagement shows whether that capacity creates real business use. When throughput drops or errors rise, engagement and revenue typically fall because users cannot complete tasks reliably. Tracking the three areas together helps architects spot bottlenecks, justify scaling, and prioritize fixes with the largest business effect.
Defining clear performance objectives means setting specific, measurable targets for each critical component based on its architecture and requirements. Targets often include response times, error rates, and resource utilization thresholds that define the required level of service. These targets are expressed as service level objectives (SLOs), such as 99.9% availability or average response time less than 200 milliseconds, and they are measured over time with service level indicators (SLIs).
Objectives are most useful when they follow SMART criteria, which make expectations realistic and time-bound:
Realistic objectives also distinguish quality from performance when both matter for success. Quality describes inherent characteristics that determine value, such as prediction accuracy, recall, or F1 score for a fraud-detection model. Performance describes how efficiently the system carries out its purpose, such as p90 inference latency less than 100 milliseconds at peak volume. Translating a business goal into both types of requirements prevents choosing a highly accurate model that is too slow or costly to run in production.
Exam tip: An SLI is the measured metric, such as availability percentage or latency, while an SLO is the target for that metric, such as 99.9% or less than 200 milliseconds.
Measuring user experience and system health requires combining infrastructure signals with user-centered feedback. Infrastructure signals include CPU utilization, memory usage, network traffic, disk I/O, and application response times that reveal bottlenecks and resource constraints. Google Cloud Observability (opens in a new tab) provides a unified platform for collecting, analyzing, and visualizing metrics, logs, and traces, while Network Intelligence Center (opens in a new tab) visualizes network topology to help identify high-latency paths. Alerts on these signals help teams catch and fix issues before users are affected.
User-centered measurement captures happiness and success over time through the HEART framework:
Tracking HEART categories alongside latency, throughput, and error rates shows whether technical improvements actually improve the user experience. Continuous monitoring with logs, tracing, metrics, and alerts lets teams reassess requirements as applications grow. Teams can then redesign parts that no longer meet business needs.
Service level reliability metrics turn business success into measurable engineering targets. A key performance indicator (KPI) describes the business outcome, a service-level indicator (SLI) measures system performance from the user perspective, a service-level objective (SLO) sets the desired value for that SLI over time, and a service-level agreement (SLA) is the contractual commitment the architecture must support. In Google Cloud, Cloud Monitoring (opens in a new tab) collects metrics, derives SLIs, evaluates SLOs, and tracks the remaining error budget for compliance.
A top-down hierarchy showing how a business KPI flows to a contractual SLA, then to an SLO target, then to the SLI that measures it, and finally to the error budget computed as 1 minus the SLO, with Cloud Monitoring shown as a side annotation that collects metrics and evaluates compliance.
Reliability goals connect each KPI to the technical behavior that affects that business outcome. If the KPI is customer satisfaction with a conversational AI assistant, the corresponding reliability metrics can include request success rate, response latency such as time to first token (TTFT) and token streaming, rate of irrelevant or harmful responses, and rate of successful task completion. For AI training, reliability metrics can include model FLOPS utilization (MFU), iterations per second, tokens per second, and tokens per device. Quantifying these metrics as SLO targets focuses engineering effort on the behavior that most affects users and the business.
Concrete SLO targets make reliability actionable for engineering teams. Examples include 99.9% of API calls must return a successful response, 95th percentile inference latency must be below 300 ms, TTFT must be below 500 ms for 99% of requests, and rate of harmful output must be below 0.1%. The SLO target plus its compliance period defines what counts as good service. Teams can then judge whether reliability work is protecting the KPI or whether risk can be accepted for faster change.
A service-level indicator (SLI) is a measurement of performance built from metrics collected by Cloud Monitoring. The Google SRE practice recommends watching the four golden signals for a user-facing system:
Infrastructure metrics across CPU, GPU, TPU, memory, network throughput and latency, and disk I/O provide context for those four signals. Because a single average can hide wide imbalances, the metric distribution should be considered, where the 99th percentile is often more informative than the average or median. For services with request-count and response-latency metrics, standard SLIs are expressed as ratios.
An availability SLI is the ratio of successful responses to all responses, and a latency SLI is the ratio of calls below a latency threshold to all calls. Performance metrics are automatically identified for known service types including Cloud Service Mesh, Istio on Google Kubernetes Engine (GKE), and App Engine, and a custom service type can be defined with its own selected metrics. Many Google Cloud services expose monitoring metrics that can be used directly as SLIs, including request-response services such as Cloud Endpoints, Cloud Run, Cloud Run functions, App Engine, and GKE, storage services such as Cloud Storage, Bigtable, Spanner, and Datastore, and data-processing services such as Dataflow and Managed Service for Apache Spark.
SLIs fall into two measurement styles that count goodness differently:
| SLI type | Unit counted | What counts as good | Example |
|---|---|---|---|
| Request-based SLI | Atomic units of service | Number of good events divided by total events | Share of successful HTTP requests |
| Windows-based SLI | Time periods, or windows | Number of good windows where a criterion was met | Share of minutes with latency below threshold |
Choose a request-based SLI when every request matters equally for the user experience. Choose a windows-based SLI when sustained behavior over time better reflects what users feel. Application-specific SLIs can also be built from logs-based metrics, Prometheus metrics including Google Cloud Managed Service for Prometheus, OpenCensus, and custom metrics, which is useful for specialized frameworks such as vLLM or NVIDIA Triton Inference Server.
A service-level objective (SLO) is a target value for an SLI measured over a compliance period. Each SLO in Cloud Monitoring combines an SLI that measures performance, a performance goal that states the desired level, and a compliance period such as a rolling 30-day period or a calendar week. Example requirements are that latency can exceed 300 ms in only 5 percent of requests over a rolling 30-day period, and that the system must have 99% availability measured over a calendar week. You can create up to 500 SLOs for each service in Cloud Monitoring.
A useful SLO targets less than 100% because the gap below 100% creates the error budget. SLOs are often described as a number of nines, such as 99% with two nines and 99.9% with three nines, and higher nines generally cost more in operational complexity and resources. For example, 99.9% availability allows about 86 seconds of downtime in a 24-hour day, while 99% allows about 864 seconds, which is ten times more downtime.
Exam tip: An SLO must target less than 100%, and the documented maximum you can set in Cloud Monitoring is 99.9%.
An error budget starts at 1 minus the SLO and declines as actual performance misses the SLO. The error budget therefore shows how much risk remains before the compliance period fails, and changes in SLO compliance can signal an onset of failure before it cascades. Cloud Monitoring service monitoring evaluates the SLI against the SLO over the compliance period, and alerting policies on error-budget burn rate notify teams when the budget is being consumed too fast.
Monitoring for SLO compliance depends on health and end-to-end signals that reflect what users experience. End-to-end monitoring tests externally visible behavior the way a user sees it, which can uncover errors or latency that finer-grained monitoring misses. Health checks pull status from an endpoint so traffic can be sent elsewhere when a resource is unhealthy, and the load balancer uses its health check to decide which virtual machine instances should continue to receive traffic and to autoheal managed instance groups by recreating unhealthy machines. On Kubernetes, liveness and readiness probes help the orchestrator decide how to manage pods and requests, so applications should expose health through appropriate endpoints.
Supporting tools in Google Cloud Observability add context around the SLI data. Cloud Logging (opens in a new tab) collects detailed logs from applications and infrastructure for troubleshooting, Cloud Trace (opens in a new tab) follows request flows across distributed microservices to pinpoint latency, and Cloud Profiler (opens in a new tab) identifies bottlenecks within function blocks to optimize resource use and execution time. Cloud Monitoring retains metrics for several weeks for real-time health checks and recent investigations, while longer-term export supports outage analysis, capacity planning, architecture refinement, and validation of performance during high-traffic periods.
Return on investment (ROI) measures the business value returned for money spent on cloud resources, while total cost of ownership (TCO) measures the full cost of running a workload in the cloud compared with the current environment. A complete analysis connects the two because TCO establishes the true cost baseline for migration or native deployment, and ROI-focused KPIs show whether that spending creates revenue growth, cost reduction, customer satisfaction, or efficiency. Cost-optimization strategies and resource-utilization data then demonstrate financial value to stakeholders over time.
ROI-focused objectives align technical choices in cloud projects with strategic business goals such as revenue growth, cost reduction, customer satisfaction, and efficiency. Objectives should be specific, measurable, attainable, relevant, and time-bound (SMART), and they should be defined with stakeholders so progress can be tracked. For example, a SMART objective is to reduce chat handling time for customer support by 15% in 6 months by using an AI chatbot.
To measure progress toward business goals and ROI, KPIs are defined in distinct categories that separate efficiency from value:
Cost metrics can be tracked with Cloud Billing (opens in a new tab) reports and Cloud Monitoring dashboards, while business-value metrics can be tracked with BigQuery (opens in a new tab) analytics and Looker dashboards. Adopting FinOps principles ensures each project has estimated costs, measured actual costs throughout its lifecycle, and assigned owners with clear accountability for both costs and benefits.
A TCO model compares the full cost of Google Cloud with the full cost of the current environment after resource needs are understood. The on-premises side must include hardware and software plus all operational costs of running a data center, such as power, cooling, maintenance, and other support services. The cloud side must include elastic scalability, which typically makes it easier to reduce costs than a rigid on-premises data center, and it should be estimated with the Google Cloud price calculator.
A commonly overlooked TCO factor is the cloud network and intelligent scaling. In a data center, routers, switches, and cabling are one-time purchases that allow use of the entire network capacity, while in the cloud there are many ways to be billed for network utilization. For data-intensive workloads or workloads that generate large amounts of network traffic, new architectures and network flows may be needed to lower networking costs. Intelligent scaling options in Compute Engine (opens in a new tab) also have a large impact on TCO, including rightsizing during migration with Migrate for Compute Engine, applying sizing recommendations after virtual machines (VMs) are already running, and building autoscaling groups of instances.
Exam tip: TCO includes power, cooling, maintenance, support, and cloud network usage charges — not only hardware and software licenses.
Cost visibility turns raw spending data into accountability for who spent money and for what purpose. Resources are organized in a hierarchy of organizations, folders, and projects that reflects organizational structure and workflows, and tags and labels such as team=banking_appdev attach business metadata to resources. Detailed Cloud Billing data exported to BigQuery and monitoring data provide granular usage and cost data, while custom dashboards and reports visualize spending trends, forecast costs, and track KPIs toward cost-optimization goals. The target is to allocate 100% of cloud costs to the source of spending, starting lower in practice because the metadata structure is complex to build.
Accountability depends on allocation, budgeting, and regular review of spending. Cost allocation and chargeback assign costs to specific teams, projects, or individuals, which fosters ownership, encourages responsible resource management, and lets the organization recover costs from internal customers. Budgets define spending limits for teams or projects, and Cloud Billing budgets and alerts provide real-time insight into spending and notify stakeholders of potential overruns before significant deviations occur. Regularly reviewing tags, labels, dashboards, and reports, plus conducting cost postmortems or proactive cost reviews, helps identify unexpected increases and underlying factors by time period or resource type.
Cost-optimization strategies improve ROI by lowering the billing rate and by matching resource allocation to actual utilization. Utilization improvements include autoscaling to avoid overprovisioning, rightsizing instances, using custom machine types, and applying product-specific controls such as Object Lifecycle Management and Autoclass for storage and capacity-based pricing for analytics. Managed services can also improve long-term TCO because they reduce dedicated engineering effort for patching, scaling, security hardening, and disaster recovery. Unit economics strengthens the value story by correlating cloud spending with business units such as revenue per customer or transaction volume, which distinguishes healthy scaling from operational inefficiency.
Discounts lower the billing rate when usage is predictable or flexible, and the central FinOps team can aggregate requirements to maximize commitment-based savings. Spot VMs (opens in a new tab) use unused VM capacity with no long-term commitment and are more than 80% cheaper than regular VMs, but they fit only fault-tolerant and flexible workloads:
| Discount option | Commitment | Scope and use |
|---|---|---|
| Enterprise discounts | Minimum total spend on Google Cloud | Negotiated reduced billing rate; commitment-based discounts can add further savings on top |
| Resource-based committed use discounts (CUDs) | Minimum quantity of Compute Engine resources for one year or three years | Specific region; shared across projects in most Cloud Billing accounts |
| Spend-based CUDs | Minimum spend on a particular product for one year or three years | Billing-account level; applied regionally or globally depending on product |
| Spot VMs | No long-term commitment; uses unused VM capacity | More than 80% cheaper than regular VMs; choose only for fault-tolerant and flexible workloads |
Pricing models change over time, so regularly reviewing pricing, considering alternative features, and choosing regions that balance cost with latency and compliance requirements keeps the architecture cost-effective. This ongoing review prevents paying for capacity or features that no longer match demand.
Proofs of concept (PoCs) and continuous review validate ROI hypotheses before full migration or large-scale deployment. A PoC for each workload category should include a comprehensive list of use cases with uncommon cases and corner cases, all requirements for each use case such as performance, scalability, consistency, failover, and network needs, and a list of technologies and products to investigate and test. Each experiment needs a precise validity context, scope, expected outputs, and measurable business impact, such as showing a 95% reduction in workload scale-up time or comparing the same business logic on on-premises databases versus managed options to identify the right solution across benchmarks and operating costs.
ROI validation continues after deployment through an iterative cycle that starts with pilot projects:
This cycle keeps spending aligned with business goals because application teams use contextualized knowledge to decide whether spending is generating value. For example, teams can judge whether money spent on a data analytics pipeline is generating value or whether re-architecting could improve efficiency without reducing performance.
A key performance indicator (KPI) describes the business outcome, a service-level indicator (SLI) measures system performance from the user perspective, a service-level objective (SLO) sets the desired value for that SLI over time, and a service-level agreement (SLA) is the contractual commitment the architecture must support. In Google Cloud, Cloud Monitoring collects metrics, derives SLIs, evaluates SLOs, and tracks the remaining error budget for compliance.
Use a request-based service-level indicator (SLI) when every request matters equally for the user experience, such as the share of successful HTTP requests. Use a windows-based service-level indicator (SLI) when sustained behavior over time better reflects what users feel, such as the share of minutes with latency below threshold.
Total cost of ownership (TCO) compares the full cost of Google Cloud with the full cost of the current environment, including hardware and software plus power, cooling, maintenance, support, and cloud network usage charges. The cloud side should be estimated with the Google Cloud price calculator and should account for elastic scalability and network utilization, which may require new architectures and network flows for data-intensive workloads.
An enterprise is planning to migrate its large on-premises data center environment—consisting of hundreds of virtualized Linux and Windows application servers alongside relational databases—to Google Cloud.
Executive leadership and finance stakeholders require a comprehensive Total Cost of Ownership (TCO) and Return on Investment (ROI) evaluation over a 5-year projection before approving the migration budget. The financial assessment must accurately account for on-premises operational overheads, dynamic resource right-sizing rather than static over-provisioned allocations, and cost-optimization strategies like long-term usage commitments.
Which approach should the cloud architect recommend to generate this financial assessment and demonstrate value to stakeholders?
Last updated