# The free 12-hour course that maps a client's CI/CD pipeline

> The Linux Foundation labels LFS162 Beginner, but its most useful material sits in the last three chapters, and you need working Linux knowledge before you start.

Original: https://fdetimes.net/en/books-courses/lfs162-devops-sre-course-fde/

Harness's job ad for a Forward Deployed Engineer contains a sentence many applicants skim past: the hire must be comfortable working directly in a customer's codebase, infrastructure workflows and CI/CD frameworks. The same ad asks for "a strong foundation in CI/CD and infrastructure-as-code". According to the description, the FDE will sit inside the customer's engineering team for the length of a build.

Engineers who come from product work have often never touched a pipeline someone else built. On a client site you need a map of the stations code passes through between commit and production, and there is no time to draw one from scratch.

The Linux Foundation's Introduction to DevOps and Site Reliability Engineering (LFS162) is the cheapest way to get that map: free, online, self-paced, and about 10-12 hours long.

## Labeled Beginner, but harder than that

LFS162 launched in September 2020 and was last updated in May 2026. It has eight chapters. The material runs from DevOps's effect on how software is delivered, through cloud, containers with Kubernetes and Infrastructure as Code, to CI/CD (chapter 6), observability (chapter 7) and SRE (chapter 8).

The intended audience includes managers and anyone who wants a career in DevOps or SRE. The course presents itself as a starting point. One thing to know in advance: although it is rated Beginner, the prerequisites call for an intermediate understanding of Linux systems.

If you are not yet comfortable reading logs, file permissions or processes on Linux, review that first. Go straight into the course and the chapters on containers and CI/CD become a stream of terms you nod along to without really understanding.

## A pipeline is the road from commit to production

Chapter 6 is the main reason for an FDE to take this course. To judge whether a client's pipeline is healthy, you need a number, and DORA offers an easy one: change lead time. It is the time a change takes from being committed to version control to being deployed to production.

Take a hypothetical case. A fix is committed at 9am on Monday and reaches production at 3pm on Thursday, a lead time of 78 hours. Trace those 78 hours and you might find that writing the code and running CI took only 4 hours, waiting for review took 30, waiting for a staging environment 20, and the last 24 were spent waiting for someone to click approve.

Here 74 of the 78 hours are waiting time, so speeding up the build would achieve almost nothing. In your first week with a client, pick a recent change and trace it through each step in the same way. You will learn which gates your integration has to pass, who holds the keys, and where to propose improvements.

## Knowing what to observe, and why

Chapter 7 covers the role of observability systems: what to observe, and why to observe it. The "why" matters more than the list of tools. Every client has dashboards, but not every dashboard can tell you whether your integration is working correctly.

Before deploying anything into a client's system, ask their team what they measure and who receives the alerts. If nobody can answer, treat adding monitoring signals for your own work as an item in the plan, rather than something to deal with after an incident.

**Key point:** What you cannot observe in a client's system, you cannot prove is working.

## SRE is how software engineers do operations

Chapter 8 closes the course with SRE. The neatest definition comes from Google's SRE Book: SRE is what happens when you ask a software engineer to design an operations team.

That definition describes an FDE's job closely. Once you sit inside the client's engineering team and work directly on their infrastructure and CI/CD, as the Harness ad describes, whatever you hand over has to run within their operational processes, including after you have left.

SRE thinking points to a clear choice: automate operational steps instead of leaving behind instructions for running them by hand. Say your integration needs a data sync job rerun whenever it fails. Do not hand over a page listing the commands to type.

Turn those steps into a job inside the client's pipeline that checks its own result and alerts the right person when it fails. The client's team then only needs to read the alert, not remember your procedure.

## Common mistakes when you first enter a client's pipeline

The most common mistake is optimizing what you can see. A slow build is easy to spot, so many people rush into caching and parallelization, when, as in the 78-hour example above, most of the time sits in the queues for review and approval. Measure lead time first, fix second.

The second mistake is deploying first and asking about monitoring afterward. The first incident will then be discovered by the client, not by you. The third is treating a runbook as the deliverable, when any step that repeats should be automated.

## In what order to study

Review Linux first. Then skim the early chapters on DevOps, cloud, containers and IaC to pick up the vocabulary, and spend most of your time on chapters 6 to 8. Afterward, read the opening chapter of Google's SRE Book and DORA's guide to its metrics, so you have yardsticks you can apply at once.

For your applications, look for phrases such as "CI/CD", "infrastructure-as-code" or "infrastructure workflows" when reading FDE job ads. They show how close to the client's infrastructure the real work will sit.

On a CV, a course completion certificate says less than a line such as "cut change lead time from X hours to Y hours", with figures you measured on a real or personal project.

A 12-hour course will not make you an SRE. It will let you read a client's pipeline on day one, and for an FDE that is when the client starts judging you.

**Try this week:**

- Enroll in LFS162 and go straight to chapter 6, noting each stage of a pipeline you currently use.
- Pick a recent change in your repo and calculate its change lead time, from commit to running in production.
- Read chapter 1 of Google's SRE Book, then write three sentences on what you would monitor after deploying an integration.

## Sources

- [Introduction to DevOps and Site Reliability Engineering (LFS162) - Linux Foundation Training](https://training.linuxfoundation.org/training/introduction-to-devops-and-site-reliability-engineering-lfs162/)

- [Forward Deployed Engineer (Implementation Engineering) @ Harness | Menlo Ventures Job Board](https://jobs.menlovc.com/companies/harness/jobs/94842776-forward-deployed-engineer-implementation-engineering)

- [Google SRE Book - Chapter 1: Introduction](https://sre.google/sre-book/introduction/)

- [DORA's software delivery performance metrics](https://dora.dev/guides/dora-metrics-four-keys/)
