Building and Deploying Apps on Google Cloud: From Code to Live Service
Signature Course No. 341 — A Signature AI Socratic Coaching Course.
Assumes you can already write code — 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 Building and Deploying Apps on Google Cloud: From Code to Live Service 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.
Code is not a service until strangers can use it and you can see it serving them. An application that runs on a laptop is a promise; a live service is that promise kept — in front of strangers, at inconvenient hours, under traffic nobody scheduled. This course teaches the whole distance between those two things, on one platform, with one application: Tidelight Outfitters, a fictional outdoor retailer with two stores and a rental counter, and its customer application Tideboard — a storefront where customers browse the gear catalog, check rental availability by date, reserve equipment, and book guided trips — carried from first deploy to peak season without ever being reset.
It starts with choosing the right home. You will learn the five Google Cloud compute homes by what they ask of you — Cloud Run, Cloud Functions, App Engine, Google Kubernetes Engine, and Compute Engine — and place each piece of Tideboard by three questions asked in order: the shape of the work, the control you truly need, and the operating burden your team can carry. Then you will ship a container to Cloud Run and steer traffic between immutable revisions, with a rollback that is a steering decision measured in seconds, not a rebuild measured in panic.
It works in two movements. First, Module 1 — From Code to a Live Service — Concepts 1–9: Choose the Right Home; Projects, Regions, and the Shape of a Service; Ship a Container to Cloud Run; Environments and Configuration; Identity, Permissions, and Service Accounts; Data for an Application; Event-Driven Pieces with Cloud Functions; Connect Services Safely; Observe a Live Service — finishing with Launch Tideboard. Then, Module 2 — Run It Like a Product — Concepts 10–18: Design Microservices That Earn Their Keep; Coordinate Work with Pub/Sub and Tasks; Store State Across Services; Secure the Public Surface; Release Without Fear; Scale and Cost Under Real Traffic; Handle Failure on Purpose; Ship Data-Safe Changes; Operate and Improve the Live Service — finishing with Peak Season, Without the Panic.
Both capstones produce real artifacts — a launch record for Tideboard version one: the placement record for homes, projects, and region; the release as performed, with its configuration inventory; the identity table and connection map; the data design with a restore test actually run; and the evidence pack with the launch verdict; and a production readiness dossier for Tideboard's peak-season release: the split and coordination design, the defended public surface, the pipeline and crest plan with their arithmetic shown, failure rehearsed on a game day, and the season's one change sequenced safely.
The honesty standard is part of the course. This is a builder's course, and it stays on the build side of the line: it teaches no examination technique, maps itself to no examination outline, and promises no credential, score, job, or business outcome. Google Cloud changes — service names, console layouts, limits, and prices move — so the course teaches the durable decision underneath each choice first, and flags every fact of the kind that goes stale as a point to verify against current Google Cloud documentation before you rely on it.
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.
Building and Deploying Apps on Google Cloud: From Code to Live Service 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 right home. List the pieces of an application you know and sort each one by shape — a request to answer, an event to react to, a job to finish, or a machine to keep; say where you have seen a team pay operating burden — patching, cluster care, capacity fuss — for control it never actually used; and state one workload's traffic pattern in a single sentence and name the home that sentence points to, before any other consideration. 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 — Launch Tideboard for Module 1 and Peak Season, Without the Panic for Module 2 — that pull the whole course together, and earn the certificate.
What You'll Learn
Shape, control, and burden — in that order, every time. Every placement in this course is those three questions asked honestly: what is the shape of this workload, how much control do I truly need, and how much operating burden can my team carry? Answered in plain words, they decide the compute home, the data store, the service boundary — and they stay revisable, because each decision records the signal that would reopen it.
Module 1 takes Tideboard from code to a live service. The five compute homes and the placement record; projects split by environment and a region chosen on evidence; a container shipped to Cloud Run through immutable revisions with steered traffic; configuration outside the code and secrets outside everything; least-privilege identities for machines; data stores chosen by the questions the application asks; event-driven functions; private connections with proven callers; and a service observed through logs, metrics, and traces — evidence, not hunches.
Module 2 runs it like a product. Services split only where change, ownership, or load pays for the boundary; work coordinated with Pub/Sub and Cloud Tasks so no customer is charged twice and no order is lost; state held honestly across services; the public surface defended in four layers; releases carried by a pipeline with a one-action rollback; scale and cost planned with arithmetic before the crest; failure designed for and rehearsed; data and interfaces changed without stranding a consumer; and the whole service operated on a rhythm that survives tired people and bad Saturdays.
And it holds the build side of the line throughout. Neighboring courses explain cloud ideas for readers who will never be asked to ship anything, teach data pipelines on Google Cloud, or prepare candidates for a certification examination. This course does none of those jobs. It teaches you to build and deploy applications: choose where code runs, ship it, give it data and identity, connect its parts, watch it while it serves real people, and improve it without breaking it.
What you will learn
- Choose a Google Cloud compute home for a workload and defend the choice by workload shape, control, and operating burden
- Deploy a containerized application to Cloud Run and steer traffic safely between revisions
- Manage configuration and secrets across environments, and promote a build without rebuilding it
- Apply least-privilege identity with service accounts, and choose application data stores — Cloud SQL, Firestore, and Cloud Storage — by access pattern
- Add event-driven functions and connect services without exposing more surface than the job requires
- Observe a live service with logging, metrics, and traces, and diagnose from evidence rather than from hunches
- Divide an application into services where the division pays, and coordinate work with Pub/Sub and Cloud Tasks with retries and idempotency handled
- Secure the public surface, automate releases with rollback, scale for real traffic with cost under control, and operate through failure and change
Everything in the course
- All 18 concepts of Building and Deploying Apps on Google Cloud: From Code to Live Service, 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: Launch Tideboard and Peak Season, Without the Panic
- 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 builders who ship — and then answer for what they shipped
Developers — who can write working application code and now need to ship it to Google Cloud and keep it alive there; and technical leads and small-team builders who must make compute, data, and release choices for a product and defend those choices in plain language.
Developers moving from another cloud or from on-premises hosting — who know what a service is and need the Google Cloud map, in working depth rather than in slogans.
Founders and product engineers at small companies — who are, for now, the whole platform team, and need a disciplined default path from first deploy to peak season. This course assumes you can read and write application code in at least one common language, use Git, and work comfortably in a terminal. It assumes no prior Google Cloud experience. It is not a concepts course for non-builders, it is not a data engineering course, and it is not examination preparation.
Prefer to learn live and in person? The same material anchors Cognosco's one-day programs — browse the in-person catalog.
Start with Choose the Right Home
$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
Building and Deploying Apps on Google Cloud: From Code to Live Service is Signature Course No. 341. Leave your email and we'll send you news of future Signature Courses and Lighthouse updates as they are announced — nothing else.