Retail is an industry in constant flux. In this session, Carrie Tharp, Google Cloud’s Lead of Retail Industry Solutions, provides a high-level overview of where the industry stands today. We move beyond simple cloud migration and explore how retailers are now using AI and ML to fundamentally reshape their value chains.

This lesson breaks down the top priorities keeping retail executives up at night—from the technical debt of "bolt-on" e-commerce sites to the financial reality of the "margin squeeze." You will learn why first-party data is critical for survival and how the definition of a "store" is expanding into new digital frontiers.

In this lesson, we dive into the specific Google Cloud solutions that are transforming how customers find products and how physical stores operate.

First, we explore the Product Discovery Suite, tackling the outdated search bars and navigation structures that haven't changed in 20 years. You will learn how retailers are moving away from manual business rules and implementing Google-quality search, visual recognition, and hyper-personalized AI recommendations on their own sites.

Then, we shift to the Modern Store. We discuss how the "Store of the Future" is being digitized to match the visibility of online channels. From using Google Glass for hands-free fulfillment to using computer vision for automated shelf checking, this session covers the tools that are solving the industry's "Holy Grail": reducing out-of-stocks.

When you click "Add to Cart," you are kicking off a complex digital chain reaction. In this lesson, we pull back the curtain on the invisible engine that powers the world's largest retailers, from digital natives like Etsy to retail giants like Walmart and Macy's.

We explore how Google Cloud acts as the digital backbone for the industry, managing everything from the massive traffic spikes of Black Friday to the granular inventory needs of local stores. But it goes beyond just infrastructure—this lesson reveals how "Recommendations AI" acts as a personal shopping assistant, analyzing patterns to predict exactly what you want before you even search for it.

Finally, we look at the "One Google" approach, where the lines between searching (Google Search), finding (Google Maps), and buying (Google Pay) are blurring into a single, seamless commercial experience.

Crisis often accelerates innovation. In this lesson, we explore how retailers can move from reactive "survival mode" to proactive growth using Google Cloud’s three-pillar approach: improving operational efficiency, unlocking value through data, and capturing new digital growth.

We examine real-world case studies of agility under pressure. You will learn how Albertsons managed a 500% spike in customer calls using rapid-response Virtual Agents, and how Ulta Beauty pivoted to a "Virtual Beauty Advisor" to maintain deep personalization when physical stores were closed.

Finally, we discuss the technical foundation required for this speed: moving away from brittle legacy e-commerce stacks toward flexible, containerized architectures and No-Code tools like AppSheet that allow teams to test and learn faster than ever.

In this session, Diana Britt (Lead of Retail Industry Solutions, APAC) opens the "Google Cloud on Air" series by addressing the unique challenges facing retailers in the Asia-Pacific region. As markets emerge from crisis, the path forward requires more than just stabilization—it requires a complete reframe of the business model.

We explore the "Respond, Rebuild, Reframe" recovery framework and how successful retailers are navigating the macro trends of the new economy, from shifting consumer privacy demands to the "66 days" it takes to form a new habit.

You will also get a high-level overview of the three strategic pillars Google Cloud uses to support retailers:

1. Driving Operational Improvement: Reducing costs through workforce transformation and edge computing.

2. Capturing Digital Growth: Modernizing e-commerce for stability and high demand.

3. Becoming Data-Driven: Using "Retail Common Services" to aggregate data and uncover real-time insights.

Building or modernizing an e-commerce platform is one of the most critical decisions a business can make. In this lesson, we navigate the classic trade-off between Speed and Control to help you design the perfect architectural blueprint for your needs on Google Cloud.

We walk through the "Architectural Decision Tree," breaking down the three distinct paths for those who want to build it themselves:

1. Migrate As-Is: The "express lane" for speed and low risk.

2. Migrate & Improve: The balanced approach using containers and Google Kubernetes Engine (GKE) to optimize while you move.

3. Modernize Fully: Re-architecting from the ground up using microservices for maximum agility.

Finally, we explore the Headless Commerce approach—decoupling your customer-facing storefront from your backend engine to give your marketing teams ultimate freedom.

In this lesson, we dive into Google Compute Engine (GCE), the core Infrastructure-as-a-Service (IaaS) offering of Google Cloud. We explore why GCE is the go-to choice for traditional enterprise applications and how it offers the utmost flexibility compared to containerized solutions like GKE.

You will learn how to configure your virtual hardware, from choosing between Predefined and Custom Machine Types to understanding how your choice of CPU directly dictates your network throughput.

We also break down the storage hierarchy, explaining the performance and cost trade-offs between Standard Persistent Disks, SSD Persistent Disks, and the high-performance (but ephemeral) Local SSDs. Finally, we touch on networking features, including why Google's software-defined Load Balancers never require "pre-warming."

Now that you understand the basic building blocks of Compute Engine, it is time to look at the "Day 2" operations required to manage them effectively.

In this lesson, we explore how to interact with the Metadata Server to programmatically configure instances using startup scripts—a key technique for creating scalable, non-brittle code.

We then break down the specific procedures for moving Virtual Machines. You will learn the difference between the automated gcloud move command (for changes within a region) and the manual snapshot-based process required for moving instances to a completely new region.

Finally, we deep dive into Persistent Disk Snapshots—how they differ from custom images, why their incremental nature saves you money, and how to use them to change disk types (e.g., upgrading from Standard to SSD) or resize your storage capacity on the fly.

In this lesson, we explore Managed Instance Groups (MIGs), a powerful tool for managing fleets of identical Virtual Machine instances as a single entity.

We discuss how MIGs enable autoscaling to meet demand and auto-healing to replace crashed or unhealthy instances automatically. You will learn the critical difference between Zonal and Regional Managed Instance Groups, and why the regional option provides superior protection against zonal failures.

Finally, we walk through the creation process: starting with an Instance Template (the blueprint) and defining the rules for the group, including autoscaling policies, port mapping, and health checks.

In this deep dive into Managed Instance Groups, we focus on the two automated features that make cloud computing truly "elastic": Autoscaling and Health Checks.

We explain how to configure autoscaling policies to automatically add instances during traffic spikes (graceful handling) and remove them when demand drops (cost reduction). You will learn the specific metrics used to trigger these events, such as CPU utilization, load balancing capacity, or queue-based workloads.

We then break down the anatomy of a Health Check. You will understand exactly how Google Cloud determines if a VM is "alive" using configurable parameters like Check Interval (how often to ping), Timeout (how long to wait), and Thresholds (how many failures trigger a recreate).

In this lesson, we explore the architecture of Google Cloud's HTTP(S) Load Balancer, a global, Layer 7 solution that enables sophisticated traffic routing based on the actual content of the message.

We break down the complete request flow: from a single global Anycast IP address (simplifying your DNS) through the Forwarding Rule, to the Target Proxy, and finally to the URL Map. You will learn how to route traffic to different backend services based on the URL path (e.g., sending /video requests to high-storage instances and /audio to standard ones).

We also dive into the configuration of Backend Services, covering critical settings like Session Affinity (sticky sessions), fixed Timeouts, and how to use Balancing Modes combined with Capacity Scalers to fine-tune exactly how much traffic your instances receive.

Building on our understanding of Layer 7 load balancing, this lesson focuses on the secure HTTPS variant and advanced backend configurations.

We detail the critical differences between HTTP and HTTPS load balancers, specifically the need for Signed SSL Certificates and the use of a Target HTTPS Proxy. You will learn about SSL Termination at the load balancer and the benefits of the QUIC protocol, which speeds up client connections and eliminates head-of-line blocking.

We then expand our backend options beyond simple instance groups. You will discover how to use Backend Buckets to serve static content (like images) directly from Cloud Storage while routing dynamic requests to your apps. Finally, we explore Network Endpoint Groups (NEGs), a crucial component for modern containerized and serverless applications, explaining the difference between Zonal, Internet, and Serverless NEGs.

In this lesson, we address the critical infrastructure challenges facing modern retailers. With 55% of executives now using traffic growth as their key success metric for Black Friday, the cost of downtime or slow performance has never been higher.

We examine the limitations of the traditional Three-Tier Monolithic Architecture (Web, App, Database), explaining why its tightly coupled nature leads to slow innovation, difficult scaling during peaks, and "hard-to-patch" security vulnerabilities.

Finally, we present the architectural solution: moving to a Containerized Architecture on Google Kubernetes Engine (GKE). You will learn how breaking applications into modular, loosely coupled microservices allows for independent scaling, multi-region high availability, and the agility to deploy new features without disrupting the entire storefront.

In this foundational lesson, we trace the evolution of application deployment from physical servers to the modern era of containerization.

We explain why the "one app per server" model was wasteful and how Virtual Machines (VMs) solved hardware dependency issues—while introducing new problems like slow boot times and "dependency hell."

You will learn exactly how Containers differ from VMs by virtualizing the User Space rather than the hardware. This key distinction allows containers to share the host OS kernel, making them lightweight, fast to start, and perfectly portable. We also discuss why this architecture is the ideal enabler for Microservices, allowing you to break applications into loosely coupled components that scale independently.

In this deep dive into container mechanics, we move beyond the basic definition to explore how containers actually work under the hood.

We deconstruct the relationship between an Image (read-only blueprint) and a Container (running instance). You will learn how Linux primitives—Namespaces (for visibility), Cgroups (for resource usage), and Union File Systems (for layering)—combine to create the isolation containers are famous for.

We also examine the structure of a Dockerfile and the "Layered" architecture that makes containers efficient. You will understand why modern applications use Multi-Stage Builds to keep images small and secure, and why the ephemeral nature of the Writable Layer means you must never store permanent data inside a container. Finally, we introduce Google Cloud Build, a managed service that builds your images securely without relying on local hardware.

In this lesson, we introduce Kubernetes (often abbreviated as K8s), the industry-standard platform for managing containerized applications at scale.

We explain why organizations need orchestration when moving from a few virtual machines to hundreds of lean containers. You will learn the core philosophy of Declarative Configuration—describing the "desired state" of your system (e.g., "I want 3 web servers") and letting Kubernetes handle the complex work of maintaining that state, rather than manually issuing commands.

We also cover the flexibility of Kubernetes, including its support for Stateless (web servers), Stateful (databases), and Batch workloads, as well as its ability to run anywhere—on-premise or in the cloud—preventing vendor lock-in.

In this lesson, we introduce Google Kubernetes Engine (GKE), Google's fully managed solution for deploying containerized applications.

We explain why organizations migrate from self-managed Kubernetes to GKE to reduce the operational burden of infrastructure maintenance. You will learn about key management features like Auto-upgrade (keeping K8s versions current) and Auto-repair (monitoring and fixing unhealthy nodes).

We also cover the ecosystem integrations that make GKE a powerhouse for enterprise architects: using Container-Optimized OS for performance, Cloud IAM for security, Cloud Build/Container Registry for CI/CD, and Stackdriver for monitoring. Finally, we discuss why the native GCP Console offers a more secure and low-maintenance alternative to the open-source Kubernetes Dashboard.

Maintaining the desired number of replicas is just the baseline. In this lesson, we explore the different strategies for scaling your Kubernetes Deployments to meet changing demand.

We start with Manual Scaling—using kubectl, the Cloud Console, or manifest updates to change replica counts on the fly. Then, we dive into Autoscaling, introducing the HorizontalPodAutoscaler (HPA) object. You will learn how to set minimum and maximum pod limits and define CPU utilization thresholds to handle sudden traffic spikes automatically.

Finally, we go beyond simple replica counts to discuss Vertical Pod Autoscaling (VPA) for rightsizing resource requests over time, and Multidimensional Autoscaling, which allows you to scale horizontally based on CPU and vertically based on memory simultaneously.

In this lesson, we examine the Deployment object, the standard way to manage stateless applications in Kubernetes.

We explain the declarative nature of Deployments: you define the "desired state" (e.g., 5 replicas of Nginx), and the Deployment Controller continuously works to ensure the cluster matches that state. You will learn the mechanics of how updates work under the hood—specifically, how the Deployment creates a new ReplicaSet to roll out new Pods while gradually scaling down the old ReplicaSet.

We also cover the lifecycle states of a deployment (Progressing, Complete, Failed) and why storing your YAML configuration files in a source code repository is critical for managing revision history and rollbacks effectively.

In this practical session, we break down the three distinct methods for creating a Kubernetes Deployment:

1. Declarative: Using a YAML manifest file with kubectl apply.

2. Imperative: Using the kubectl run command with inline parameters (image, replicas, ports).

3. Console-Based: Using the GKE Workloads menu in the Google Cloud Platform console.

We also explore how to inspect the state of your application using kubectl get and kubectl describe. You will learn how to interpret key status columns like Desired, Current, Up-to-Date, and Available. Finally, we share a "pro tip" on how to export a running deployment's configuration into YAML format—perfect for converting quick imperative experiments into permanent, version-controlled infrastructure code.

In standard Kubernetes operations, every single change to a Deployment (like updating an image tag or changing an environment variable) triggers an immediate automatic rollout. In this lesson, we discuss why this default behavior can be problematic for teams that release frequent, small fixes—leading to a cluttered revision history that makes troubleshooting difficult.

We introduce the solution: Pausing rollouts. You will learn how to use kubectl rollout pause to temporarily stop the deployment controller from reacting to changes. This allows you to "batch" multiple configuration updates into a single revision. We then cover how to Resume the rollout to apply all those changes at once, how to monitor the progress with kubectl rollout status, and finally, how to clean up resources using kubectl delete.

In this lesson, we explore the practical mechanics of updating applications in Kubernetes. You will learn the four distinct methods for triggering a Deployment update: using kubectl apply for file-based changes, kubectl set for quick CLI updates, kubectl edit for interactive live editing, and the GCP Console for visual management.

We then dive into the Rolling Update (Ramped) strategy—the default behavior for Kubernetes Deployments. We break down exactly how the Deployment controller creates a new ReplicaSet alongside the old one, gradually shifting Pods over to ensure zero downtime. You will also understand the trade-offs of this strategy, such as the inability to control traffic distribution between the old and new versions during the transition.

Now that you can create basic Deployments, it is time to master the strategies used to release software safely in a production environment. In this lesson, we start by defining the Kubernetes Service, the critical network abstraction that provides a stable IP address for your ephemeral Pods.

We then compare high-maturity deployment patterns. You will learn how Blue/Green Deployments offer instantaneous switchovers (at the cost of double resource usage) and how Canary Deployments minimize risk by gradually shifting traffic to a new version.

We also cover A/B Testing for validating business hypotheses based on user segmentation (e.g., location or browser) and Shadow Testing, where production traffic is mirrored to a new version to test performance without impacting the actual user experience. Finally, we review the commands necessary to Rollback updates when things go wrong.

In this lesson, we introduce the primary dataset used for the practical analysis portions of the course: a real-world e-commerce dataset from the Google Merchandise Store.

We explain why this specific dataset—containing over 1 million site hits and transaction records—was chosen. It allows you to practice writing queries that solve actual business problems, such as identifying cart abandonment, creating customer cohorts based on behavior, and tracking the effectiveness of referring sites and keywords. Importantly, because this data is recorded through Google Analytics and exported to BigQuery, the SQL techniques you learn here are directly applicable to your own organization's GA4 data.

This lesson shifts focus from architecture to hands-on data analysis using the IRS charity dataset. It explores the tools available for data exploration and deep dives into writing standardized SQL queries in BigQuery.

The retail industry is undergoing a massive digital transformation, driven by shifting consumer behaviors toward omni-channel experiences, curbside pickup, and a focus on essential safety. However, while data volume is exploding—expected to reach 181 zettabytes by 2025—retailers struggle to utilize it; less than 1% of unstructured data is currently analyzed.

In this lesson, we explore how Google Cloud helps retailers bridge this gap, focusing on Cloud Dataprep by Trifacta. You will learn how to move beyond historical performance indicators to real-time, data-led decision-making without needing to deploy complex infrastructure.

We provide a deep dive into the Cloud Dataprep architecture, a serverless, intelligent service that allows analysts to visually explore, clean, and prepare data.

We break down the comprehensive data lifecycle managed within Dataprep:

1. Discover: Finding anomalies and correlations.

2. Cleanse: Correcting inaccurate or corrupt data.

3. Structure: Changing formats (e.g., JSON to relational, string to date).

4. Enrich: Augmenting data by joining multiple sources.

5. Validate: Ensuring data quality before analysis.

Finally, you will master the terminology and workflow of Dataprep, understanding how to use Connections to ingest data, Wranglers to apply predictive transformations, and Recipes to chain these steps together into a job that executes via Cloud Dataflow. This "no-code" approach enables you to handle datasets from megabytes to petabytes with equal ease.

In this lesson, we tackle the common fear that AI is too complicated or "exclusive" for everyday retail applications. We contrast the traditional Rule-Based System—a rigid, one-size-fits-all approach where a professional chef and a student see the exact same search results—with the modern Learning System powered by AI.

You will learn how AI creates a smart feedback loop, learning from every click to transition from serving broad demographic groups to serving the individual. We explore the three key payoffs of this shift:

1. Personalized Search Results: Tailored specifically to the user's intent.

2. Smarter Recommendations: Predicting what a customer will love based on behavior.

3. Unique Discovery Suites: Curated collections built around individual needs.

Finally, we provide a practical roadmap for getting started without getting overwhelmed: start with a clear business problem, prove value in one specific area, and expand from there.

In this lesson, we revisit our team at XYZ Company as they tackle their second machine learning project. Their new requirements—specifically a dataset larger than 100GB—push them beyond the limits of Vertex AI AutoML Tables (which has a 100GB limit).

We explore why BigQuery ML (BQML) is the ideal solution for teams that have data in BigQuery and SQL skills but lack deep Python/TensorFlow expertise. You will learn how BQML accelerates the "time to production" by eliminating the need to export data for training.

We walk through the four major steps of the BQML workflow using a real-world example of predicting NYC taxi fares:

1. Extract: Write a SQL query to select training data.

2. Create Model: Use CREATE MODEL to train the model directly in BigQuery.

3. Evaluate: Use ML.EVALUATE to check model performance.

4. Predict: Use ML.PREDICT to generate results.

In this lesson, we dive deep into the catalog of BigQuery ML (BQML) models, mapping specific business problems to the correct algorithm. You will learn when to use Logistic Regression (for binary classification like "Will this flight be late?"), Linear Regression (for forecasting sales numbers), and Matrix Factorization (for building product recommendation engines).

We also cover advanced model types like Boosted Trees (XGBoost) for high performance on large datasets, K-Means Clustering for unsupervised customer segmentation, and AutoML Tables for when you want Google to automatically find the best model for you.

In the second half, we explore Hyperparameter Tuning. Unlike model parameters (coefficients) which are learned during training, hyperparameters (like learning rate or hidden units) must be set before training begins. You will see how BQML uses Vertex Vizier under the hood to automate this process, significantly improving metrics like ROC AUC (Area Under the Curve) without manual trial-and-error.

In this foundational lesson, we explore the physical infrastructure that powers Google Cloud. We break down the global network into Regions (independent geographic areas like europe-west2 or London) and Zones (deployment areas within those regions).

You will learn how the choice of location affects critical architectural metrics:

• Latency: The time it takes for data to travel to your users.

• Availability: The uptime guarantee of your application.

• Durability: The assurance that your data will not be lost.

We also examine the hierarchy of resource placement. You will understand the risks of Zonal resources (which fail if the zone goes down) versus the resilience of Regional and Multi-Regional configurations. Specifically, we look at Cloud Spanner's multi-region capability, which replicates data across vast distances to protect against natural disasters and serve global users with low latency.

In this lesson, we explore the "middle layer" of the Google Cloud infrastructure: Compute. We begin by categorizing the five main compute services based on their abstraction level:

• Compute Engine (IaaS): Virtual machines for maximum flexibility and control.

• Google Kubernetes Engine (GKE): Managed environment for containerized applications.

• App Engine (PaaS): Fully managed platform that binds code to libraries, focusing on application logic.

• Cloud Functions (FaaS): Event-driven, serverless execution (e.g., triggered by file uploads).

• Cloud Run: Fully managed, serverless platform for stateless containers that scales to zero.

We then shift focus to High-Performance Computing (HPC) for Machine Learning, using Google Photos' video stabilization as a case study. You will learn why standard CPUs and GPUs are hitting a performance wall (Moore's Law vs. AI demand) and how Google overcame this by developing the Tensor Processing Unit (TPU)—an Application-Specific Integrated Circuit (ASIC) designed specifically to accelerate matrix multiplication in ML workloads.

In this lesson, we shift our focus from compute to Storage, exploring how Google Cloud decouples these two layers to enable massive scalability.

We start by distinguishing between Unstructured Data (images, audio, documents) and Structured Data (transactional or analytical records). You will learn how to select the right storage service based on your data type and access patterns:

• Cloud Storage (Object Storage): Best for unstructured data. We cover the four storage classes—Standard (hot data), Nearline (once a month), Coldline (once a quarter), and Archive (once a year)—helping you optimize costs based on access frequency.

• Database Decision Tree: A guide to choosing the right database for structured data:

  • Transactional (OLTP) + SQL: Use Cloud SQL for regional needs or Cloud Spanner for global scale.

  • Transactional (OLTP) + NoSQL: Use Firestore for document-oriented mobile/web apps.

  • Analytical (OLAP) + SQL: Use BigQuery for petabyte-scale warehousing.

  • Analytical (OLAP) + NoSQL: Use Cloud Bigtable for high-throughput, low-latency IoT or time-series data.

In this lesson, we explore the final layer of Google Cloud infrastructure: Big Data and Machine Learning. We trace the chronological evolution of Google's internal technologies, understanding how early challenges with indexing the World Wide Web led to the modern cloud products we use today.

We follow the timeline of innovation:

• 2002 - Google File System (GFS): The foundation for scalable storage, evolving into Cloud Storage.

• 2004 - MapReduce: A paradigm shift for processing massive datasets on commodity clusters.

• 2005 - Bigtable: Created to handle millions of streaming user actions with high throughput.

• 2010 - BigQuery: The move to serverless, fully managed data warehousing (Storage + Analytics).

• 2015 - Pub/Sub: Solving for real-time streaming analytics and integration.

Finally, we cover the rapid advancement of AI, from the open-source release of TensorFlow (2015) and the groundbreaking Transformer architecture (2017), to the unified Vertex AI platform (2021) and the state-of-the-art multimodal Gemini models (2023). This history explains why the current Google Cloud portfolio—including Dataflow, Dataproc, and Looker—is so robust.

In this lesson, we organize Google Cloud's extensive portfolio of big data and machine learning products into a clear, four-stage workflow to help you select the right tool for your specific business needs.

We break down the categories as follows:

1. Ingestion & Process: Tools for digesting real-time and batch data, including Pub/Sub (messaging), Dataflow (streaming/batch processing), Dataproc (managed Hadoop/Spark), and Cloud Data Fusion (data integration).

2. Storage: The five core options: Cloud Storage (Object), Cloud SQL & Spanner (Relational), and Bigtable & Firestore (NoSQL).

3. Analytics: The powerhouse BigQuery for SQL-based data warehousing, supported by Looker and Looker Studio for visualization and business intelligence.

4. Machine Learning: Divided into the ML Development Platform (Vertex AI, AutoML, TensorFlow) and pre-packaged AI Solutions (Document AI, Contact Center AI, Retail Product Discovery) designed for specific vertical market needs.

In this lesson, we organize Google Cloud's extensive portfolio of big data and machine learning products into a clear, four-stage workflow to help you select the right tool for your specific business needs.

We break down the categories as follows:

1. Ingestion & Process: Tools for digesting real-time and batch data, including Pub/Sub (messaging), Dataflow (streaming/batch processing), Dataproc (managed Hadoop/Spark), and Cloud Data Fusion (data integration).

2. Storage: The five core options: Cloud Storage (Object), Cloud SQL & Spanner (Relational), and Bigtable & Firestore (NoSQL).

3. Analytics: The powerhouse BigQuery for SQL-based data warehousing, supported by Looker and Looker Studio for visualization and business intelligence.

4. Machine Learning: Divided into the ML Development Platform (Vertex AI, AutoML, TensorFlow) and pre-packaged AI Solutions (Document AI, Contact Center AI, Retail Product Discovery) designed for specific vertical market needs.

In this lesson, we address the critical first stage of the data pipeline: Data Ingestion. We explore the unique challenges presented by streaming data sources, particularly from the Internet of Things (IoT), where millions of sensors send high-volume, asynchronous events that must be collected reliably and securely.

We introduce Google Cloud Pub/Sub (Publisher/Subscriber), a global, serverless messaging service designed to handle this scale. You will learn how Pub/Sub "decouples" systems, allowing Publishers (like IoT sensors or HR applications) to send messages to a Topic without needing to know who receives them. Conversely, Subscribers (like Dataflow or BigQuery) can listen for relevant data independently.

We illustrate this with an HR example: a single "New Employee" event can trigger independent actions across payroll, badge activation, and IT provisioning systems without those systems ever directly communicating with one another. This architecture ensures at-least-once delivery and allows your pipeline to buffer and absorb traffic spikes without breaking downstream applications.

In this lesson, we move to the "Process" stage of the data pipeline, focusing on ETL (Extract, Transform, Load). Once data is ingested, it must be transformed before analysis. We address the challenge of building pipelines that handle both Batch (historical) and Streaming (real-time) data without writing separate codebases for each.

We introduce Apache Beam, an open-source, unified programming model that solves this problem. You will learn the three pillars of Apache Beam:

1. Unified: Use a single programming model for both batch and streaming data.

2. Portable: Write pipelines in Java, Python, or Go, and run them on multiple execution environments (Runners) like Spark or Flink.

3. Extensible: Write and share your own connectors and transformation libraries.

Finally, we define Google Cloud Dataflow as the fully managed "Runner" that executes your Apache Beam pipelines at scale, handling the provisioning and management of resources automatically.

In this lesson, we examine the execution engine for Apache Beam pipelines: Google Cloud Dataflow. While Apache Beam provides the code/model, Dataflow provides the fully managed, serverless environment to run that code.

We discuss the operational benefits of using Dataflow, specifically its NoOps (No Operations) nature. You will learn how Dataflow abstracts away infrastructure management by automatically handling:

• Resource Provisioning: Setting up the necessary compute instances.

• Auto-Scaling: adjusting resources based on data volume.

• Auto-Healing: Detecting and fixing worker faults without human intervention.

• Dynamic Work Rebalancing: Optimizing efficiency by redistributing work among workers in real-time.

Finally, we introduce Dataflow Templates, which allow even experienced developers to deploy common pipelines without writing code from scratch. We categorize these into Streaming Templates (e.g., Pub/Sub to BigQuery), Batch Templates (e.g., Bigtable to Cloud Storage), and Utility Templates (for compression/deletion).

In this lesson, we focus on the critical final step of the data pipeline: Visualization. Data that is difficult to interpret is often useless, so we introduce Looker, Google Cloud's enterprise platform for business intelligence and embedded analytics.

We explore Looker's unique architecture, specifically the Semantic Modeling Layer driven by LookML. You will learn how LookML allows developers to define business logic and permissions centrally, abstracting the complexity of the underlying SQL databases (supporting BigQuery and 60+ others).

We then dive into Looker's visualization capabilities, including:

• Dashboards: Creating "Business Pulse" views for high-level metrics like sales trends and user acquisition.

• Visualization Types: Beyond standard bar charts, we cover advanced options like Sankey diagrams, funnels, and liquid fill gauges.

• Geospatial Analysis: Plotting data on maps to see distribution (e.g., NYC Taxi ride density).

• Delivery: Scheduling reports to be sent via Slack, Google Drive, or Dropbox.

In this lesson, we break down the architecture of BigQuery, defining it as two services in one: a fully managed storage facility and a high-speed SQL analytical engine. You will learn how these two components are connected by Google's petabit-scale network, allowing them to scale storage and compute independently based on demand.

We explore the flexibility of Data Ingestion, covering:

1. Internal Storage: Native BigQuery storage with automatic replication and backup.

2. External Sources (Federated Queries): Querying data directly where it lives—in Cloud Storage (CSVs), Spanner, Cloud SQL, or even Google Sheets—without moving it to BigQuery first.

3. Multi-Cloud: Analyzing data stored in AWS or Azure.

Finally, we detail the three methods for loading data—Batch, Streaming (for real-time needs), and Generated (SQL INSERTs)—and the different query modes available (Interactive vs. Batch).

In this lesson, we explore how BigQuery has evolved from a simple data warehouse into a powerful ML engine, eliminating the painful, time-intensive process of exporting data to external notebooks or learning complex frameworks like TensorFlow.

We demonstrate the simplified two-step workflow:

1. Create Model: Use a standard SQL statement to train the model on your data.

2. Predict: Use ML.PREDICT to generate insights immediately.

We then provide a guide to Model Selection, distinguishing between Supervised (task-driven) and Unsupervised (data-driven) learning. You will learn the correct use cases for:

• Logistic Regression: For classification tasks (e.g., "Is this email spam?").

• Linear Regression: For forecasting continuous numbers (e.g., "What will shoe sales be next month?").

• Clustering: For unsupervised pattern recognition (e.g., "How do I group these random images?").

In this lesson, we walk through the five key phases of a machine learning project, demonstrating how BigQuery ML (BQML) streamlines the workflow using standard SQL.

We break down each stage of the lifecycle:

1. Extract & Load: Getting data into BigQuery (using connectors or SQL joins).

2. Feature Selection: Creating the training dataset. We discuss how BQML automatically handles complex tasks like one-hot encoding (converting categorical variables like "Red/Blue" into numeric values "1/0").

3. Create Model: Using the CREATE MODEL statement to define the model type (e.g., Linear vs. Logistic Regression).

4. Evaluate: Using ML.EVALUATE to inspect performance metrics such as RMSE (for forecasting) or Accuracy/AUC (for classification).

5. Predict: Using ML.PREDICT to generate future insights and confidence scores.

We also dive into advanced inspection commands like ML.WEIGHTS, which allows you to see which features were most important to the model's decision-making (on a scale of -1 to 1). Finally, we prepare for a hands-on lab using Google Merchandise Store data to predict customer return probability.

In this strategic overview, we compare the four distinct options for building machine learning models on Google Cloud, helping you select the right tool based on your team's skills and data requirements.

We break down the options from "easiest/least control" to "hardest/most control":

1. Pre-built APIs: Ready-to-use models (Vision, Video, NLP) trained by Google. Ideal for developers with no ML expertise who need immediate results without training data.

2. AutoML (Vertex AI): A no-code, point-and-click interface to train custom models on your own data. Best for teams who want custom results without writing complex code.

3. BigQuery ML: The SQL-based solution. Perfect for data analysts who already have tabular data in BigQuery and want to build models without moving data or learning Python.

4. Custom Training (Vertex AI): The full-code solution (Python/TensorFlow/PyTorch) for ML engineers who need maximum flexibility and full control over the pipeline and hyperparameters.

In this lesson, we explore the fastest route to integrating AI into your applications: Google Cloud's Pre-Built APIs. Building a custom model from scratch requires massive datasets (hundreds of thousands of records) and significant expertise. Pre-built APIs allow you to bypass this complexity by leveraging models already trained on Google's vast internal datasets (e.g., YouTube captions, Google Images).

We cover the core suite of APIs available for immediate use:

• Vision API: Analyzes static images to detect objects, faces, and text.

• Video Intelligence API: Recognizes motion, action, and content in video.

• Speech-to-Text & Text-to-Speech: Converts audio to text (and vice-versa) with high fidelity.

• Natural Language API: Extracts sentiment, entities, and syntax from text.

• Translation API: dynamic language translation using Google's Neural Machine Translation technology.

This lesson provides a comprehensive overview of AutoML (Automated Machine Learning), a powerful no-code solution designed to streamline the complex process of building custom machine learning models. You will explore how AutoML leverages advanced techniques like transfer learning and neural architecture search to automate time-consuming tasks such as hyperparameter tuning and model selection.

The lesson breaks down the practical applications of AutoML across four primary data types—Image, Tabular, Text, and Video—explaining how businesses can use these tools to solve specific "objectives," from predicting real estate prices to tracking objects in live sports footage. Whether you are a data scientist looking to prototype faster or a business leader seeking high-quality custom AI without deep coding expertise, this lesson illustrates how AutoML bridges the gap between raw data and actionable insights.

In this lesson, we examine the final and most flexible option for building machine learning models: Custom Training. Designed for ML engineers who need full control over their code and environment, this approach centers on Vertex AI Workbench—a single, unified development environment for the entire data science workflow, from exploration to deployment.

We focus on the critical step of selecting your training environment, using a "Kitchen Metaphor" to distinguish between the two container types:

1. Pre-built Containers: Like a "fully furnished kitchen" stocked with appliances and cookware. These come ready-to-use with standard frameworks like TensorFlow, PyTorch, Scikit-learn, and XGBoost.

2. Custom Containers: Like an "empty room." You must bring your own cabinets and tools. This option allows you to define exact dependencies and libraries that aren't available in the standard images.

Did you know that 50% of all enterprise machine learning projects never make it past the pilot phase? In this lesson, we tackle the "technical and operational nightmares" that prevent AI from reaching production. We dive deep into Google Vertex AI, a unified platform specifically designed to bridge the gap between a cool lab experiment and a powerful, live application.

Drawing on Google’s 20-year history of AI innovation (stretching back to the foundations of Scikit-learn), this lesson explores how Vertex AI simplifies the entire ML journey. Whether you are a data scientist who wants to avoid becoming an "infrastructure guru" or an engineer looking for a faster way to deploy, you’ll learn why this platform is the future of AI development.

By now, you know how to build models—but where do those models live, and what specialized solutions already exist to save you time? In this lesson, we break down the Google Cloud AI Portfolio into a clear, three-layer framework. We move from the raw infrastructure at the bottom to the sophisticated, industry-specific "Vertical" solutions at the top.

We will explore how Google categorizes its offerings so you can decide whether to build a custom solution from scratch or leverage a pre-trained "Horizontal" tool like Document AI or Contact Center AI (CCAI) to solve universal business challenges.