DevOps and CI/CD in Practice: Automate the Path from Code to Production
Signature Course No. 337 — A Signature AI Socratic Coaching Course.
Assumes you can read code and use version control at a basic level — your coach starts where you are.
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.
A coach that teaches by asking — not by lecturing
The Lighthouse Coach is an AI Socratic coach built on Cognosco Learning's DevOps and CI/CD in Practice: Automate the Path from Code to Production 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.
Software is not delivered when it is written — it is delivered when a change reaches production safely. Most teams lose their changes in the space between those two moments: the code sits waiting for review, the build runs on one person's machine, the release is a checklist performed from memory on a Thursday afternoon, the database change and the code change arrive in the wrong order, and when something breaks at 9 p.m. nobody can say exactly what changed. This course closes that space: measure delivery honestly, build and check every change the moment it arrives, express the whole path as a pipeline in code, and promote one artifact built once — then run the far end of the path, releasing gradually, watching production with signals that mean something, and recovering on evidence.
It starts with ownership. DevOps is a decision before it is a toolchain: the people who build a change share responsibility for what that change does in production, and the people who run production share responsibility for how buildable and releasable the system is. You will meet the running system in full: Latchmere Systems, a 62-person software company whose platform serves 420 regional moving firms through five deployables and one shared database — 31,200 bookings in a typical month, 46,800 in the June peak, 26 scheduled releases a year performed from a 34-step manual checklist in 210 minutes, 4 of the last 26 releases causing a customer-visible incident, a median 9-day wait from finished code to production, and a median 90 minutes to restore service.
It works in two movements. First, Module 1 — Designing the Delivery System — Concepts 1–9: What DevOps Actually Owns; The Running System; Measuring Delivery; Version Control as the Single Source; Continuous Integration; The Pipeline as Code; Automated Testing in the Pipeline; Environments and Configuration; and Building the Artifact Once — finishing with The Pipeline Build. Then, Module 2 — Releasing, Running, and Improving Production — Concepts 10–18: Continuous Delivery and Deployment; Release Strategies; Database Changes Without Breaking Production; Infrastructure as Code; Observability; Incident Response and Blameless Learning; Rollback, Roll-Forward, and Recovery; Security in the Pipeline; and The Delivery Standard — finishing with The Release and Recovery Plan.
Both capstones produce real artifacts — a complete pipeline build for Latchmere's booking service: the measured baseline with its arithmetic, the commit-to-artifact design, the 1,240 planned checks placed by layer with their gates, the environments, secrets, and artifact discipline, all compressed into a one-page summary leadership actually reads; and a release and recovery plan for a risky May release, four weeks before the June peak: the changes separated and gated by risk, exposure chosen per change, the database change sequenced as expand, migrate, contract, the watching and the undo written in advance, and the plan signed claim by claim.
The honesty standard is part of the course. This book makes no promise about a job, a credential, a salary, or an outcome. It teaches the durable discipline first — tools change faster than disciplines do — and names the current tool surface in its appendix, flagged where you must verify what is current before you rely on it. Every figure is shown with its arithmetic, computed from the running company's standing facts, where a pencil can check it: 4 ÷ 26 is a 15.4% change failure rate, and 6 engineers × 210 minutes is 21 engineer-hours spent performing a checklist, per release.
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.
DevOps and CI/CD in Practice: Automate the Path from Code to Production is part of The Lighthouse Signature Series — the online counterpart to the one-day, in-person learning Cognosco Learning has delivered since 2002.
Course Facts
One full concept, coached end to end — free: verify your email and we’ll send you a link to start.
Already enrolled? Enter the course →
Diagnose → Learn & Practice → Prove → Capstone
Every learner moves through the same discipline a Cognosco instructor would insist on in the room.
Diagnose
The Coach starts where the course starts: with the wall. In a workplace you know, when a release breaks at night, whose phone rings — and did that person have any say in how the release was built? What is the development side measured on, and what is the operations side measured on — and where do those two measures directly oppose each other? And for the last change you saw delivered, who could have answered where it was, what it last passed, and how to undo it — one name, or a chain of handoffs? 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.
Learn & Practice
Work each concept in conversation with the Coach — spoken or written — then practice it against realistic situations until it holds up.
Prove
Every concept ends in proof: answer the check cold and demonstrate the skill. Know it already? Test out and take credit immediately.
Capstone
Finish with two capstones — The Pipeline Build for Module 1 and The Release and Recovery Plan for Module 2 — that pull the whole course together, and earn the certificate.
What You'll Learn
Build the artifact once, give it an identity, and promote that identical artifact through every environment to production. Every skill in this course serves that discipline: a change travels from a developer's machine to production through version control, continuous integration, a pipeline defined as code, checks placed by speed and cost, and environments kept honest — and the green lights along the way are evidence only when the object users run is the exact object that passed every stage.
Module 1 designs the delivery system. What DevOps actually owns, and the running system in full; delivery measured with lead time, deployment frequency, change failure rate, and recovery time; code kept on a trunk with short-lived branches and real review; every change built and checked the moment it arrives; the pipeline expressed as code, with stages, gates, and artifacts; automated checks placed fast first; environments and configuration kept honest, with secrets kept secret; and one artifact built once and promoted, never rebuilt.
Module 2 releases, runs, and improves production. The human gate placed where risk actually lives, and everything around it automated; release turned into a dial — flags, canaries, and two blue-green doors; database changes sequenced as expand, migrate, contract so both running versions survive the mixed-version hour; infrastructure provisioned from reviewed code; production watched through logs, metrics, and traces, with alerts that mean something; incidents run without blame and converted into structural fixes; rollback, roll-forward, and recovery decided on evidence; and security built into the pipeline's own stages — scanning, signing, and least privilege.
And it holds its boundary throughout. Automating repetitive work one script at a time is another course's ground, and so are surveying the software engineering profession and the container tool layer — containers appear here exactly once, in one concept, as one way to package an artifact inside a pipeline. What this course owns is the full delivery discipline, end to end, and it closes where it must: with the delivery standard, and what you are signing when code reaches customers in your name.
What you will learn
- Measure a delivery system with lead time, deployment frequency, change failure rate, and recovery time — and improve it on evidence
- Keep work on a trunk with short branches and real review, and integrate every change with automated builds and checks on arrival
- Design a pipeline as code: stages, gates, environments, configuration, and one artifact built once and promoted
- Place automated tests inside the pipeline by speed, cost, and what each layer can actually catch
- Release safely: continuous delivery, feature flags, canary and blue-green releases, and database changes that survive a mixed-version hour
- Run production as part of delivery: infrastructure as code, observability, incident response, rollback, and pipeline security
Everything in the course
- All 18 concepts of DevOps and CI/CD in Practice: Automate the Path from Code to Production, 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 Build and The Release and Recovery 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
Built for the people who own what happens after the merge
Developers moving into delivery responsibility — who can write the feature and now own what happens to it after the merge; and platform and operations engineers who build the path other teams release on, and must make the right thing the easy thing.
Technical leads — who must choose a release strategy, defend a gate, or explain to a manager why deploying less often makes failure worse, not better.
Quality and security engineers — whose checks belong inside the pipeline, placed by cost and risk, not appended at the end. This course assumes you can read code, use a version control system at a basic level, and follow a worked count of minutes, percentages, and rates. It does not assume you have run a pipeline before, and it does not teach programming, task scripting, or container orchestration.
Prefer to learn live and in person? The same material anchors Cognosco's one-day programs — browse the in-person catalog.
Start with What DevOps Actually Owns
$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.
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.
More Signature Courses are coming
DevOps and CI/CD in Practice: Automate the Path from Code to Production is Signature Course No. 337. Leave your email and we'll send you news of future Signature Courses and Lighthouse updates as they are announced — nothing else.