The Lighthouse · Signature Series

GitLab CI in Practice

Signature Course No. 573 — A Signature AI Socratic Coaching Course.

Built for teams who ship on GitLab and want pipelines they can believe — your coach starts where you are.

Try a Free Preview

AI-built course structure. Socratic coaching that builds mastery, not just completion.

An agentic, mastery-based AI learning platform.

A New Kind of Learning

Socratic coaching, delivered by an agentic AI coach.

Not a course you watch. An AI coach you work with.

The Lighthouse Coach begins by discovering how you think about the subject, teaches what is missing, and gives you realistic practice before asking you to prove that you can use it. You may test out of concepts you already understand, while capstones turn the learning into a practical plan, decision, conversation, or other real-world result.

The curriculum is deliberately authored; the AI delivers it through coaching. It is not an AI randomly generating lessons.

Meet The Lighthouse Coach

A coach that teaches by asking — not by lecturing

The Lighthouse Coach is an AI Socratic coach built on Cognosco Learning's GitLab CI in Practice course, in the Personal Effectiveness & Well-Being category. It does not play videos at you. It holds a conversation: it asks you a question, listens to your answer, names the misconception it hears, affirms what you got right, and asks the next question — the way a great coach works in the room.

Every team that ships on GitLab has pipelines. Far fewer have pipelines they trust. The difference is rarely effort — mistrusted pipelines are often worked on constantly. It is judgment: whether someone on the team can say, for every job, what question it answers, what its failure should make the team do, and what it costs in the only currency a pipeline really spends — the time between a developer making a change and the team knowing something true about it.

It starts with the promise. Concept 1 teaches you to read any pipeline as an argument: what is checked, what a failure causes, and what green licenses — and to spot where the claim and the checking have come apart. The remaining concepts of Module 1 give you the design discipline: dependencies before habit, one purpose per run, fast truthful feedback, evidence a stranger can audit, runners as real capacity, clean handoffs, shared configuration without copy-paste, and secrets handled as trust decisions.

It works in two movements. First, Module 1 — Design the Pipeline: From Commit to Confidence — work through Concepts 1–9, finishing with The Pipeline Blueprint; then, Module 2 — Run It, Trust It, Improve It — work through Concepts 10–18, finishing with The Ninety-Day Improvement Plan.

Both capstones produce real artifacts — a complete pipeline blueprint for a new service, designed before it is written: promise, dependency graph, purposes, truth rules, runner design, and trust document; and a ninety-day improvement plan for a real, mistrusted estate — baselined, sequenced, budgeted, and measurable enough for leadership to approve, fund, and hold you to.

The honesty standard is part of the course. This course teaches pipeline design and delivery judgment, not interface screens or configuration syntax line by line. Everything perishable — which features sit in which GitLab tier, what runners cost, which details belong to which release — is fenced to the course book's Appendix, to be confirmed at the source before you rely on it. Every number in the course is stipulated for teaching and labelled as such.

The course is self-paced and always on — roughly 30 minutes per concept, about 9 hours in full, taken in as many sittings as you like. You can type your answers, or talk out loud: the Voice Coach speaks its questions and listens to your spoken replies. Learners who already know the material can test out concept by concept.

GitLab CI in Practice is part of The Lighthouse Signature Series — the online counterpart to the one-day, in-person learning Cognosco Learning delivers.

Course Facts

Concepts18 · 2 modules
Capstones2
Time per concept≈ 30 minutes
Full course≈ 9 hours, self-paced
FormatOnline · AI voice coach
CertificateOn completion
VerificationVerifiable online
Introductory price$195

One full concept, coached end to end — free: verify your email and we’ll send you a link to start.

AI-built course structure with Socratic coaching that builds mastery, not just completion.

Already enrolled? Enter the course →

The Method

Diagnose → Learn & Practice → Prove → Capstone

Every learner moves through the same discipline a Cognosco instructor would insist on in the room.

1

Diagnose

The Coach starts where the course starts: with the pipeline your team waits on most. State its promise in three parts — what is checked, what a failure actually causes, and what green licenses; name the job you could not defend with the sentence test; recall the last time the team merged on red or retried before reading, and what that taught everyone watching. Every concept opens with three questions that locate where you actually stand, and your answers shape how deeply the Coach works the concept with you. Everyone begins with Module 1 — no skipping the foundations you only think you have.

2

Learn & Practice

Work each concept in conversation with the Coach — spoken or written — then practice it against realistic situations until it holds up.

3

Prove

Every concept ends in proof: answer the check cold and demonstrate the skill. Know it already? Test out and take credit immediately.

4

Capstone

Finish with two capstones — The Pipeline Blueprint for Module 1 and The Ninety-Day Improvement Plan for Module 2 — that pull the whole course together, and earn the certificate.

The Course Content

What You'll Learn

Signal, evidence, cost — the three threads under every concept. A pipeline exists to produce trustworthy knowledge about a change, fast. Every design choice in this course is judged by what it does to the signal: how soon it arrives, how much it can be believed, and what it obliges the team to do next — and priced in the interval between making a change and knowing something true about it.

Module 1 teaches design. Read a pipeline as an argument and state its promise; let real dependencies decide what waits; give each kind of run one purpose; order for fast, truthful feedback inside a stated budget; make jobs produce evidence a stranger can audit; treat runners as finite machines; hand work between jobs as rebuild, reuse, or preserve; share configuration without copying it; and write secrets and permissions as the trust decisions they are.

Module 2 teaches operations and improvement. Carry a change through environments with deployment separated from release and rollback designed in advance; triage failure without superstition; place each test where it earns its minutes; admit security scanning as a citizen of the pipeline; run pipelines across projects and inside large ones; hold speed to a budget with arithmetic attached; govern the estate without gridlock; and run the pipeline itself as a product, with users, measures, and an improvement backlog.

And it holds its fences throughout. Version control craft is a different discipline with its own course on this shelf, and the GitHub estate is a different estate with its own course; neither is taught here. This book owns the ground between a change being ready to test and that change being safely in production: the pipeline, and only the pipeline, on GitLab.

What you will learn

  • Read any GitLab pipeline as an argument: state what each stage and job claims, what its failure should cause, and what the whole pipeline promises
  • Design stage and job structure from real dependencies, so work runs as early as it honestly can and nothing waits out of mere habit
  • Scope pipelines to purposes — merge-request, branch, default-branch, scheduled, and release pipelines each doing one job well
  • Put fast, truthful feedback first: order work by signal value per minute and hold the whole pipeline to a stated time budget
  • Make jobs tell the truth — results, artifacts, and reports a stranger can audit — and judge deliberately when a failure may be allowed not to block
  • Choose and govern runners as real capacity: the right machine for the job, queues made visible, and contention treated as a design problem
  • Hand work between jobs cleanly, distinguishing what must be rebuilt, what may be cached, and what must be preserved as evidence — with lifetimes set on purpose
  • Reuse pipeline configuration without copying it, and judge the risks that shared and inherited configuration carry
  • Handle secrets and pipeline permissions as trust decisions: least privilege, protected values, and honest treatment of untrusted changes
  • Carry a change through environments to production with deployment separated from release, and rollback designed before it is needed
  • Triage pipeline failure without superstition: product failure, pipeline failure, and flake told apart by evidence, with retries governed by rule
  • Place each kind of test where it earns its minutes, govern the pipeline estate across projects and inside large ones, hold speed to a budget, and run the pipeline itself as a product that improves on evidence
What's Included

Everything in the course

  • All 18 concepts of GitLab CI in Practice, in 2 modules
  • A starting-point check first — the Coach finds where you actually stand before teaching
  • Learn, Practice, Prove for every concept — no passive video watching
  • A test-out on every concept: prove you know it and move on
  • The Voice Coach: talk with the Coach out loud — it speaks, listens, and replies
  • A personal Learner Record of your work across the course
  • Two capstone exercises: The Pipeline Blueprint and The Ninety-Day Improvement Plan
  • A printable session summary whenever you pause
  • The Lighthouse Coach completion certificate (Signature Series)
  • Your progress is saved as you go — stop anytime, resume where you left off
Who It's For

Built for the people pipelines answer to

Developers and tech leads on GitLab estates whose pipelines have grown by accretion — slow, flaky, or quietly ignored — and who need a design discipline for rebuilding them, not another collection of tips; and platform and DevOps engineers who own shared runners, shared configuration, and delivery standards for several teams, and must make estate-level calls individual teams cannot make for themselves.

Release and delivery managers accountable for how changes reach production, who need to judge deployment and rollback readiness from pipeline evidence rather than optimism; and engineering managers who approve pipeline investment and need the arithmetic and the vocabulary to judge whether a proposal will pay.

What it assumes, honestly stated — working familiarity with software delivery in a team: you know what a build, a test suite, and a deployment are, and you have waited for a pipeline and cursed one. It does not assume deep GitLab experience, and it does not teach version control.

Prefer to learn live and in person? The same material anchors Cognosco's one-day programs — browse the in-person catalog.

Enroll

Start with The Pipeline Is a Promise

$195 — introductory price. One payment. No subscription, no password to manage.

Here is exactly what happens when you enroll:

  • Pay securely with Stripe — you are taken straight into the course
  • Create your learner profile and begin the Module 1 starting-point check
  • Save the access key you are given — it restores your enrollment on any device
  • Learn at your pace; your progress is stored in your browser on your device

For the full voice experience, use Chrome and allow the microphone when asked. Typing your answers works everywhere, all the time. Questions before you enroll? Email hello@cognoscolearning.com.

The Lighthouse Coach — GitLab CI in Practice$195.00
Total · introductory price, one-time$195.00

Secure checkout by Stripe. The moment your payment completes, you are taken straight into the course to create your learner profile and begin — no account password to manage. You will receive an access key to save; it restores your enrollment on any device.

Good Questions

Before you enroll

What is a Socratic coaching session?

A conversation, not a video. Your coach asks a question; you answer — out loud by voice, or by typing — and the coach responds to what you said: naming the misconception it hears, affirming what you got right, and asking the next question. You advance only when you have mastered each concept, so a finished course means the learning held.

How long does it take — and how long do I have?

About 30 minutes per concept. Learn in sittings of any length; your progress is saved as you go. You have a full year from purchase to finish, and you can revisit and retake within that year.

What does the certificate verify?

That you completed every concept and both capstones of this course. Anyone can confirm a Cognosco certificate online — enter its certificate ID on our verification page.

What if it isn't for me — what are the refunds?

If you have not started, cancel for a full refund within seven days of purchase. Once you have started, there is no cash refund — stop before finishing and we credit the full amount you paid toward any other course in the library (credit valid one year from your original purchase). Once you complete the course, no refund or credit applies.

Independently verified before publication — structure, claims, and sources checked; tested end to end as a learner takes it.

The Signature Series Continues

More Signature Courses are coming

GitLab CI in Practice is Signature Course No. 573. Leave your email and we'll send you news of future Signature Courses and Lighthouse updates as they are announced — nothing else.