Prepare and test your skills
Prepare and test your skills
Modernization of compute and application frameworks is the practice of evolving legacy virtual machine (VM)-based monoliths into cloud-native microservices that are more scalable and agile. A large monolithic application is refactored or rearchitected into several independent microservices that run on managed container or serverless platforms. In Google Cloud, this architecture commonly uses Google Kubernetes Engine (GKE) (opens in a new tab) or Cloud Run (opens in a new tab), which remove undifferentiated infrastructure work while supporting automated scaling and operations.
Refactoring a monolith means moving the application and improving its structure so tightly coupled components become independent microservices. A cloud-native application built this way is scalable, resilient, manageable, and observable through containers, service meshes, microservices, immutable infrastructure, and declarative APIs. Google Cloud supports this model with GKE, Cloud Run, Cloud Service Mesh, Logging, and Monitoring, so teams can run services without building their own platform for deployment, networking, and observability.
A practical path is phased migration, where teams start with lift-and-shift or replatforming and then refactor or rearchitect as the next step. Lifting and shifting first helps optimize from an infrastructure perspective, and after applications run in the cloud it is easier to integrate cloud services and adopt cloud-first capabilities. During the transition, modernized services can still communicate with systems in other environments over a hybrid network connection.
Choosing a migration path means matching each workload or application tier to the approach that fits its dependencies, constraints, and business value. It is not necessary to use one approach for everything, and different tiers of the same stack can follow different paths. For example, a backend self-hosted MySQL database can be replatformed to Cloud SQL (opens in a new tab), frontend VMs can be refactored to containers on GKE Autopilot, where Google manages nodes, scaling, security, and other preconfigured settings, and hardware load balancing plus web application firewall (WAF) capabilities can be replaced with Cloud Load Balancing and Google Cloud Armor.
A decision tree that starts with a workload and branches on its fit criteria to recommend rehost (lift and shift), refactor (move and improve), or rebuild (rip and replace), with Google Cloud examples for each path.
The fit criteria for rehost, refactor, and rebuild guide that choice:
Exam tip: Choose rehost when the workload can move as-is with few dependencies, and choose refactor when dependencies, unsupported operating systems, inefficient resource use, or manual deployments must be fixed to run well in the cloud.
Cloud-managed compute provides a consistent runtime layer so development, operation, and scaling work the same way across cloud and edge locations. Containers and Kubernetes abstract away differences among environments because Kubernetes provides a common runtime layer, which lets teams develop, run, and operate workloads consistently and move workloads between the edge and the cloud. To simplify hybrid operation, Google Distributed Cloud connected (opens in a new tab) can host GKE clusters outside Google Cloud while keeping centralized management and monitoring in the cloud.
For application tiers, managed services reduce operational work while improving elasticity. Frontend and integration tiers can benefit from capabilities such as Firebase, Pub/Sub, Apigee, Cloud CDN, App Engine, or Cloud Run, depending on whether the need is user interfaces, messaging, API exposure, caching, or serverless execution. Adopting microservices with containers on a cloud-managed platform like GKE also enables microfrontend patterns, which extend microservices to frontend components for teams that share one application:
Decoupling legacy and modern services means placing a managed API and service-communication layer between clients and backend microservices. An API gateway or proxy acts as a unifying facade that serves as a centralized control point, implements additional security measures, shields client apps from backend code changes, facilitates audit trails for cross-environment communication, and acts as an intermediate communication layer between legacy and modernized services. Apigee (opens in a new tab) and Apigee Hybrid let teams host and manage enterprise-grade gateways across on-premises environments, edge, other clouds, and Google Cloud environments.
Cloud-managed API proxies specifically decouple the app-facing API from backend services such as microservices, so existing frontend patterns like backend for frontend (BFF) and microfrontend continue to work while backends change. For service-to-service traffic inside a microservices system, Cloud Service Mesh maintains quality of service while managing authentication, authorization, and encryption between services. Together, Apigee exposes services for consumption as APIs, while Cloud Service Mesh secures and controls how those distributed services communicate with each other.
Operating modern architectures means treating clusters and releases as automated, repeatable, and observable rather than as manually maintained servers. GKE clusters should be designed to be fungible, so provisioning and configuration are automated and an upgrade can be performed by provisioning a new upgraded cluster, deploying workloads there automatically, and decommissioning the old cluster. Consistent tooling and continuous integration and continuous delivery (CI/CD) pipelines across cloud and edge environments further increase operational efficiency and reduce drift between environments.
Performance and cost improve through automated scaling at both the cluster and workload layers. GKE supports cluster autoscaling with node auto-provisioning to resize the cluster according to demand, plus workload scaling based on metrics, Horizontal Pod autoscaling to change the number of Pods, and Vertical Pod autoscaling to adjust resource requests and limits. Modernization also requires adopting Site Reliability Engineering (SRE) or DevOps principles, which is more of a transformation than a purely technical change and typically requires procedural and cultural changes starting with leadership buy-in, because software systems must be continually refined, simplified, and improved as products, patterns, and user demands evolve.
Optimization of operational efficiency and fiscal sustainability is the practice of keeping Google Cloud architectures resilient, high-performing, and economical as requirements change. Operational efficiency comes from automated deployment pipelines, codified infrastructure, and continuous monitoring, while fiscal sustainability comes from FinOps practices that tie cloud spending to business value. Together they form a continuous optimization loop where teams measure, improve, and then tune the improvement process itself.
Automated deployment pipelines are ordered workflows that build, test, and release application changes without manual handoffs. Cloud Build (opens in a new tab) creates and tests container images and artifacts from source code, and Cloud Deploy (opens in a new tab) then promotes those artifacts through defined release stages to targets such as Google Kubernetes Engine (GKE), Cloud Run, or Compute Engine. Automated testing runs inside the pipeline before any production deployment, so failed changes are blocked early and regressions do not reach users.
Pipelines typically validate changes with three complementary test levels:
Mature pipelines extend beyond basic release automation by adding monitoring for the deployment infrastructure itself, advanced patterns such as blue/green deployments to reduce user impact, and a break-glass process for emergency direct access when automation cannot proceed.
Efficient cloud operations rest on three connected habits where codified definitions enable automation and monitoring proves whether both are working. When infrastructure, policy, and operations are defined as code in version control, changes become testable, repeatable, and reversible through rollback. Code flows from version control through Cloud APIs to Google Cloud resources, so the same definition produces the same environment every time.
Monitoring data flows from workloads to dashboards, alerts, and exported sinks in Cloud Storage, Pub/Sub, or BigQuery, and hybrid and multicloud monitoring extends coverage when data must stay in specific locations. Even a small scheduled script can save hours per day and free effort for higher-value optimization.
Right-sizing and autoscaling match resource capacity to actual demand so applications avoid both costly over-provisioning and performance bottlenecks from under-provisioning. Cloud Monitoring provides real-time visibility into CPU, memory, and custom application metrics, while Recommender analyzes that history and suggests smaller machine types or reclaimed idle resources. Custom metrics and alerts trigger timely action by notifying administrators when thresholds are met, and correlation of utilization with latency and error rates confirms that a downgrade will not harm user experience.
Google Cloud autoscaling dynamically adds capacity when demand rises and removes it when demand falls:
FinOps-driven cost optimization is a collaborative operating model where engineering, finance, and business teams share accountability for balancing cost against value. Teams adopt a value-driven and total cost of ownership (TCO)-aware mindset by using value stream mapping to visualize software delivery flow, unit economics to correlate spending with business units such as revenue per customer or transaction volume, and self-service observability and resource tools so owners can provision and optimize autonomously. Billing data exported to BigQuery and analyzed with Looker supports better decisions by revealing spending patterns, trends, and forecasts.
Google Cloud discount and placement options reward different usage commitments:
| Option | How savings are earned | Choose when |
|---|---|---|
| Committed use discounts (CUDs) (opens in a new tab) | Commit to a minimum level of usage for a term in exchange for discounted prices | Usage is predictable and steady over months or years |
| Sustained use discounts | Receive automatic discounts for Compute Engine resources used for a large portion of the billing cycle | VMs run consistently without a formal commitment |
| Spot VMs | Run on unused capacity at a lower price with the tradeoff of possible preemption | Workloads are fault-tolerant, batch, or low-priority and can be interrupted or scheduled |
Exam tip: Committed use discounts require an upfront usage commitment, sustained use discounts apply automatically to consistent Compute Engine use, and Spot VMs offer the lowest price for interruptible capacity.
Accountability depends on visibility, where tags and labels applied to projects, departments, and resources flow into Cloud Billing (opens in a new tab) and Cost Management reports, budgets, and alerts. Active Assist adds intelligent recommendations for rightsizing, idle resources, and security and sustainability improvements, while regular reviews of pricing models ensure architectures shift to better-performing or lower-cost options as Google Cloud evolves.
The continuous optimization loop is a repeatable iteration that prevents uncontrolled, one-time tuning efforts by setting measurable goals and stopping each cycle when goals are met. Each execution, called an optimization iteration, follows an explicit order where measurement results determine the next transition.
A learning culture sustains the loop by turning operational experience into future improvements. Structured retrospectives after milestones, incidents, and load tests use models such as start-stop-continue to identify automation gaps, a blameless and psychologically safe environment encourages experimentation with AI, analytics, and new Google Cloud features, and conferences, training, and Google Cloud certifications keep skills current with evolving security, data, and scalability capabilities.
Integration of advanced data analytics and machine learning is the practice of combining managed data services with artificial intelligence platforms to improve business logic and prediction. In Google Cloud, BigQuery (opens in a new tab) handles large-scale analytics and forecasting, while Vertex AI (opens in a new tab) trains and serves custom predictive and generative models. Data flows from transactional and operational sources into BigQuery for analysis, and then from curated datasets into Vertex AI for training, evaluation, and serving, with automation connecting each stage.
BigQuery is the managed analytics service for storing and analyzing large datasets without managing servers. Changed data flows continuously from sources such as a MySQL database into BigQuery tables, so analytics always reflect current transactions and the split between transactional and analytics workloads stays clean. Once data lands in BigQuery, teams can run large queries, forecast multiple time series with multivariate models, and perform semantic search over graph data.
For resilience, recurrent BigQuery backups use two methods: BigQuery snapshots for in-place recovery and exports to Cloud Storage for low-cost, zone-redundant storage. This combination keeps analytical data both quickly recoverable and durably stored outside the dataset.
Vertex AI is the managed platform for building custom-trained machine learning models from customer data and code. Training and serving on Vertex AI depends on scalable infrastructure that can include Compute Engine (opens in a new tab) instances, Google Kubernetes Engine (GKE) clusters, and TPUs and GPUs. Before promotion, model inputs must be checked for quality by evaluating data bias in training data on Agent Platform and evaluating synthetic data for data quality.
This quality gate ensures that predictive improvements refine business logic instead of repeating hidden bias or poor data. Clean, representative inputs flow into training, and only validated models flow to serving.
MLOps pipelines are automated workflows that keep models accurate as data and business needs change. An MLOps pipeline moves code and models through an ordered sequence where each stage depends on the success of the prior stage:
Because CI, CD, and CT run automatically, updates reach production faster and with fewer manual errors than ad hoc retraining.
Designing AI systems for scalability means ensuring infrastructure can handle growing data volumes and user demand without bottlenecks. Capacity planning starts with business forecasts, then uses Cloud Monitoring to analyze historical resource utilization, identify trends, and project future needs, validated by regular load testing. Teams must know Google Cloud quotas for the services they use, such as Compute Engine, Agent Platform, and Cloud Storage, and proactively request quota increases through the Google Cloud console with forecasting and load-testing data.
To handle demand efficiently, rightsize resources, implement autoscaling, and use Spot VMs for fault-tolerant batch workloads, since Spot VMs offer the same machine types and performance as regular VMs at lower cost but can be preempted.
Exam tip: Choose Spot VMs when batch training or processing can tolerate preemption; do not choose them when high availability is required, because Compute Engine can reclaim their capacity.
Operating AI workloads reliably requires monitoring infrastructure health, deployment status, and business thresholds together. Infrastructure health covers Compute Engine, GKE, TPUs, and GPUs, with automated optimization recommendations from Active Assist and scaling behavior checks when autoscaling is used. Deployment status is tracked by integrating Cloud Deploy with Cloud Monitoring for canary releases and rollbacks, while Security Command Center monitors for threats and vulnerabilities.
For business-specific anomalies, custom alerting collects signals from all pipeline components:
Sustaining improvement with responsible practices means turning one-time model gains into reliable AI solutions through culture and governance. Championing automation and standardization embeds repeatable practices into every stage of the AI lifecycle, which reduces manual errors and frees teams for innovation. Prioritizing continuous learning keeps teams current with AI advances, while cultivating accountability with clear roles and success metrics creates ownership for outcomes.
Embedding AI ethics and safety at every stage, including discussion of fairness, bias, and societal impact, ensures that predictive improvements align with organizational values and build trust. Operational excellence therefore depends as much on people and principles as on pipelines and platforms.
Cloud and technology improvement connects modernization, efficiency, and intelligence into one lifecycle. Monoliths are decoupled into microservices on GKE, Cloud Run, and Apigee, those services are operated with automated pipelines, autoscaling, and FinOps accountability, and data flowing through them is refined in BigQuery and Vertex AI with MLOps and responsible monitoring to sustain value over time.
Choose rehost for as-is moves with few dependencies, refactor for moves that must fix dependencies or efficiency to run well in the cloud, and rebuild for replacement when workloads no longer meet requirements. Rehost fits workloads that are not worth or cannot feasibly be refactored before migration or are based on third-party software. Refactor fits workloads with tangled dependencies, unsupported operating systems, hardware or database systems, inefficient resource use, or manual deployments, while rebuild fits workloads that can be merged with similar applications, use end-of-life third-party technology, or carry uneconomical license fees.
Committed use discounts (CUDs) require committing to a minimum usage level for a term in exchange for discounted prices for predictable steady usage, sustained use discounts apply automatically to Compute Engine resources used for a large portion of the billing cycle without a formal commitment, and Spot VMs run on unused capacity at a lower price for interruptible workloads. Choose Spot VMs for fault-tolerant, batch, or low-priority workloads that can be interrupted, and do not choose them when high availability is required because Compute Engine can reclaim their capacity through preemption.
Compute Engine managed instance groups (MIGs) scale a managed set of virtual machines as one entity under an autoscaling policy with minimum and maximum counts and threshold conditions such as CPU utilization. Google Kubernetes Engine (GKE) autoscaling uses Cluster Autoscaler to add or remove nodes based on Pod demand, Horizontal Pod Autoscaler to change replica counts, Vertical Pod Autoscaler to tune requests and limits, and Node Auto-Provisioning to create optimized node pools, while Cloud Run scales container instances up during peaks and to near zero when idle based on incoming request traffic.
The continuous optimization loop runs in order: assess environment, teams, and loop against baselines, establish measurable requirements and goals, optimize environment and teams and re-measure, then tune the loop itself. Tuning includes codifying the workflow, automating steps that need no human decision such as checks and aggregate reports, and monitoring loop efficiency, and each iteration stops when goals are met.
An enterprise runs a legacy monolithic web application on on-premises virtual machines. The monolithic application combines API routing, background order processing, and state management into a single large codebase, resulting in slow release cycles and operational bottlenecks. During seasonal promotions, the ingress API gateway experiences major traffic spikes, forcing the organization to over-provision the entire infrastructure to maintain availability.
The team wants to modernize this architecture on Google Cloud by refactoring the monolith into loosely coupled microservices to increase release agility and ensure that the ingress and stateless service layers can scale dynamically based on workload demand.
Which modernization approach should you recommend?
Last updated