# The DeepLearning.AI and Google Cloud LLMOps course: what to learn in 1 hour 31 minutes, and what to drop when the client isn't on GCP

> The course runs on BigQuery and Google Cloud. The part worth taking to a client is a fine-tuning pipeline that can be rerun, with a version for every piece.

Original: https://fdetimes.net/en/books-courses/deeplearning-ai-llmops-course-review/

A new fine-tune starts giving customers worse answers than last week's version. If you don't know which dataset it was trained on, all you can do is guess. DeepLearning.AI's **LLMOps** course was built to teach you how to avoid exactly this situation, and it takes less than two hours.

The course was announced on 17 January 2024 and made with Google Cloud. It is taught by Erwin Huizenga, who at launch was Machine Learning Technical Lead at Google. Analytics India Magazine reported that the course was free on release, and the course page at deeplearning.ai/short-courses/llmops was last updated on 8 October 2025.

For an FDE, the value of the course is not the Google toolset. Your client may run AWS, Azure or a self-built Kubernetes cluster. So for every lesson, keep asking: which part is a working habit that carries over to another client?

## The three 21-minute lessons are the core

The course page lists 1 hour 31 minutes, split into Introduction (4 minutes), Fundamentals (11), Data Preparation (21), Automation and Orchestration with Pipelines (21), Prediction, Prompts, Safety (21), Conclusion (1) and a 10-minute quiz.

The course page states the main goal plainly: adapt an open-source pipeline that uses supervised fine-tuning so an LLM answers user questions better. You work with BigQuery, Kubeflow Pipelines and Google Cloud.

## Idea one: a pipeline is worth more than a notebook

The Automation and Orchestration with Pipelines lesson teaches you to turn separate steps into a flow that runs automatically. At a client, this difference decides the handover: only the person who wrote a notebook can rerun it, whereas the client's team can rerun a pipeline after you have left the project.

According to its official documentation, Kubeflow Pipelines is a platform for building and deploying ML workflows that are portable across environments and scale easily. It is container-based and runs on Kubernetes. A compiled pipeline can run on any KFP-compatible backend, and Google's Vertex AI Pipelines is only one of them.

## Idea two: version both data and models

The course treats versioning data and models as best practice, and press coverage of the launch also stressed this point. An unofficial notes repository on GitHub (ksm26/LLMOps) shows that this lab is done in Kubeflow, tracking each tuning run, rather than with any proprietary GCP service.

Go back to the situation at the top of this article, and suppose model v3 is worse than v2. If every run is tied to a dataset version, you can compare the two datasets straight away and might find, for instance, that the latest export picked up tickets that were never resolved. Without versions, the meeting with the client becomes a guessing session.

**Key point:** Learn one cloud vendor's tools, but come away with habits that work at every client.

## Idea three: safety is a recorded number

The Prediction, Prompts, Safety lesson teaches you to output a safety score for each category of harmful content. Each category gets its own score rather than being folded into a single "safe/unsafe" label. That detail is what turns safety into something you can negotiate with a client.

Picture a bank, with categories and figures that are purely illustrative. It blocks a response when the hate speech score is 0.3 or above, harassment at 0.5, while dangerous content, such as instructions for getting around identity verification, is blocked from as low as 0.2, because that is the risk it fears most.

Now a response scores 0.1 for hate speech, 0.2 for harassment and 0.35 for dangerous content. The average across the three is about 0.22, which looks harmless. Judged category by category, though, it exceeds the 0.2 threshold for dangerous content and is blocked: exactly what a single combined label would miss.

So put a per-category threshold table into the acceptance criteria from the start of the project, so the client signs off each number, instead of a vague promise that the model is "safe".

## What to drop and what to keep when the client isn't on GCP

BigQuery and the Google Cloud platform are the vendor-specific parts. When the client uses a different data store, replace the data-loading step in the Data Preparation lesson with theirs. Keep the cleaning and formatting logic as it is.

Keep Kubeflow Pipelines, because it is open source and runs on any KFP-compatible backend. The first thing to do at the client is ask the infrastructure team whether they already have a Kubernetes cluster, and only then decide whether to use KFP or move the steps into the orchestration tool they already use.

Versioning and safety scoring are ways of working, independent of any tool, so take them to every project.

## Who should take it, and in what order?

The course suits engineers who have called LLM APIs but never put a fine-tune into production. Watch Fundamentals first, then do Data Preparation and Pipelines in one sitting because they follow on from each other, and only then Safety. If you already know classic MLOps, you can skim the fundamentals.

On the career side, when reading FDE or applied AI job descriptions, look for keywords such as pipeline orchestration, Kubeflow and model versioning. On a CV, a line like "built a reproducible fine-tuning pipeline with versioned data and models and per-category safety thresholds" carries far more weight than a course certificate.

## An exercise for when you finish

Take the pipeline from the course and assume your client isn't on GCP. Rewrite it on a single page: which step moves to the client's data store, which steps stay unchanged on KFP, which version IDs each run records, and the per-category safety threshold table you would ask the client to sign.

If that page is clear enough for an engineer on the client side to rerun everything without asking you, you have learned what the course really sets out to teach. And every client will, sooner or later, ask: "what data was this version trained on?"

**Try this week:**

- Watch the Data Preparation and Automation and Orchestration with Pipelines lessons, 21 minutes each, then redraw the pipeline by hand and mark the steps tied to BigQuery.
- Take a fine-tuning or prompt project you are working on, give every run a data version ID and a model version ID, and record them in one place.
- Read the Kubeflow Pipelines overview page and find out which KFP backend your current (or hypothetical) client's Kubernetes cluster can run.

## Sources

- [LLMOps – DeepLearning.AI](https://deeplearning.ai/short-courses/llmops)

- [New LLMOps short course – DeepLearning.AI Community](https://community.deeplearning.ai/t/new-llmops-short-course/547525)

- [ksm26/LLMOps (GitHub course notes repo, unofficial)](https://www.github.com/ksm26/LLMOps)

- [Overview | Kubeflow Pipelines](https://www.kubeflow.org/docs/components/pipelines/overview/)

- [Andrew Ng partners with Google Cloud for new course on LLMOps – Analytics India Magazine](https://analyticsindiamag.com/andrew-ng-partners-with-google-cloud-for-new-course-on-llmops/)