Anyone can ship it. You’ll keep it alive.
AI made writing software fast. It made operating software more important — more systems, shipped faster, by fewer people who understand what they deployed. Ten weeks on the unglamorous, career-defining craft of production: pipelines, observability, incidents, and the bill.
Why this course exists
Every AI-accelerated team eventually meets the same wall: software is being produced faster than anyone can responsibly run it. Deploys multiply, dashboards stay dark, and the first real incident finds a team that has never practiced one.
Production engineering — the discipline of shipping reproducibly, observing honestly, responding calmly, and paying attention to cost — has always separated senior engineers from feature factories. In the AI era it’s scarcer and more valuable, because generated systems fail in ways their authors never read.
This course trains it the only way it can be trained: by running real systems. You deploy through pipelines you build, get paged in a staged incident, and finish by auditing and hardening a system as the Summit. The exit skill is calm.
Fit matters
Small cohorts mean we’d rather turn you away than waste your next 10 weeks. Read both lists honestly.
Expected outcomes
Outcomes are written as capabilities, because that’s what reviews test and what employers probe.
Ship any service reproducibly: environments, containers, CI/CD, and infrastructure as code
Instrument systems so questions become queries: metrics, logs, traces, SLOs
Run incidents with method: detection, mitigation, communication, and blameless review
Make load, capacity, and performance decisions from evidence
Audit an AI-assisted system’s operational readiness — and harden it until it passes
Own the bill: understand, predict, and reduce what your architecture costs
The learning journey
Every phase has an entry state, an exit state, and a Waypoint Review gating the way forward — so progress is never a feeling, it’s a fact.
Weeks 1–3
From “works on my machine” to reproducible delivery: environments, containers, pipelines, and infrastructure that exists as code.
Waypoint 1 · The Reproducible Deploy
Deploy your service through your own pipeline, then destroy and recreate the whole environment from code in front of a mentor. No hand-editing allowed.
Weeks 4–7
The operating heart: observability, SLOs, incident craft, and performance under real load — ending in a staged incident game-day.
Waypoint 2 · The Game-Day
Mentors break your system in ways you haven’t seen. You detect, mitigate, communicate, and write the blameless review. Assessed on method and calm, not luck.
Weeks 8–10
The senior layer: cost, scaling judgment, and operational review of modern AI-heavy stacks. Summit: a full production audit and hardening of a real system.
Waypoint 3 · Summit — The Production Audit
Take a real system (yours or an adopted one), audit its operational readiness end to end, harden the worst gaps, and defend the audit like a consultant who has to be right.
The curriculum, week by week
Lesson-level detail is refined with each cohort; the weekly structure below is the commitment.
Wk 01
Environments and containers: making “it runs” a property, not a hope
Ships: Your service containerized with dev/prod parity
Wk 02
Pipelines: build, test, deploy — with rollback as a first-class citizen
Ships: CI/CD pipeline shipping to a live environment
Wk 03
Infrastructure as code: the environment you can delete
Ships: The Reproducible Deploy, ready for Waypoint 1
Wk 04
Observability: metrics, logs, and traces that answer questions
Ships: Instrumentation and dashboards on your live service
Wk 05
SLOs and alerting: promises you can keep, alerts that respect sleep
Ships: SLOs defined with alerting wired to them
Wk 06
Incident craft: detection, mitigation, communication, review
Ships: Runbooks written; practice drill completed
Wk 07
Performance and load: finding the edge before users do
Ships: Load test results and fixes; the Game-Day — Waypoint 2
Wk 08
The bill: cloud cost literacy and the architecture decisions behind it
Ships: Cost analysis of your stack with a reduction shipped
Wk 09
Scaling judgment: when to scale, what to scale, what to refuse to build
Ships: Capacity plan defended in pod review
Wk 10
Operating AI-era systems: reviewing what nobody fully read
Ships: Summit audit and hardening complete — Waypoint 3
Projects
Every phase produces something reviewable; the Summit produces something you defend.
Phase 1
A service with a full delivery pipeline and infrastructure you can delete and recreate from code.
Phase 2
Instrumentation, SLOs, and runbooks that turn your service from a black box into an honest one — tested by the Game-Day.
Summit project
A full operational-readiness audit and hardening of a real system, defended end to end.
Mentorship
Small pods, senior mentors, and promises with numbers attached — mentorship here is a system, not a Slack channel.
You’re placed in a pod of six in week one and climb with them to the end. Small enough that your absence is noticed; strong enough to survive a hard week.
A live session with your pod mentor every week: demos, unblocking, and group review of real work.
Thirty minutes with your mentor, agenda owned by you — career, code, or the thing you’re stuck on.
Every weekly deliverable gets a real review — line comments and questions — within one day. That’s a promise, not an aspiration.
Twice a week, drop in with anything. No booking, no agenda.
Mentors carry pagers in real jobs — SRE and platform engineers who have run the incidents they’ll stage for you.
The Game-Day is run live with your pod as your incident team; the debrief is a masterclass in itself.
The Ship Week Rhythm
Courses fail when weeks drift. Ours can’t: every week ends with something shipped, and going quiet triggers a human, not a reminder email.
You post the week’s targets to your cohort space. Everyone sees them.
Three times a week, two sentences: what moved, what’s stuck.
The week’s increment goes up for review and gets demoed in your pod. Shipped beats perfect.
Silent for two days? A mentor reaches out personally. Not a bot — a person who knows your project.
Your public record of the whole journey — and the proof of work employers actually read.
Waypoint Reviews
No exams. Each phase ends with a Waypoint Review — you present working software against a rubric published on day one, the way real engineering teams review real work.
Forty-five minutes: you demo the milestone, walk the code, and answer questions about why it’s built the way it’s built.
Functionality, code quality, AI-collaboration quality, and reasoning under questions. No surprises, no trick questions.
Prompt hygiene, verification discipline, knowing when not to use the tool — assessed explicitly, because that’s the craft now.
Miss a waypoint and you get a week to close the gap, like a returned pull request. Rigorous, not punitive.
From the trail
“The Game-Day broke my service in ways I still think about. But the calm is what stuck: two months later we had a real incident at work and I ran it exactly like the drill. My manager asked where I learned that.”
Backend engineer · Production Engineering
Pricing
No fake discounts, no upsells inside the course, no “premium tier” of attention. Everyone gets the whole thing.
Production Engineering
₹75,000
Or 3 monthly installments of ₹26,000
One-time, all-inclusive.
Every cohort reserves need-based scholarship seats. If the price is the only thing stopping you, apply anyway and say so.
Questions, answered straight
No certificate-cramming here. You leave with something better: a pipeline you built, an incident you survived, an audit you defended — and the judgment that transfers across every tool a job posting could name.
Cohorts run on one mainstream cloud and current, widely-adopted tooling — but every concept is taught as judgment first, tool second. The skills survive your next employer’s stack because they were never welded to this one.
Projects are scoped to free tiers and small instances; expect spend comparable to a couple of coffees a month, and cost discipline is itself part of the curriculum — running lean is graded, not just tolerated.
It’s designed to be survivable and unforgettable, in that order. You’ll have runbooks you wrote, drills behind you, and your pod as your incident team. The assessment rewards method and communication — nobody is graded on heroics.
The intended path is AI-Native Software Engineering first, but experienced backend developers who already build complete systems can enter directly. If you can build it but couldn’t run it, you’re exactly who this is for.
Every session is recorded and available the same day. Live attendance is strongly encouraged — the studio format is interactive — but the program is built to survive real life and real time zones.
Cohorts are scheduled around Indian evenings and weekend mornings (IST), which also works for the Gulf and Southeast Asia. Everything is recorded, and async reviews mean your work never waits for a meeting.
Full refund within the first two weeks of the cohort, no questions and no forms-designed-to-exhaust-you. After that, fees are non-refundable but you can defer to a later cohort once, free.
Yes — installment options are listed with each course’s pricing, and every cohort reserves need-based scholarship seats. If price is the only thing stopping you, apply and say so plainly.
Graduates receive a completion credential — but the artifacts that actually open doors are the ones you build: a public build log, defended projects, and a published case study. We optimize for those.
Working developer → AI-Native Software Engineering. New to code → Software Foundations. Already AI-native and choosing a depth → the specializations. Bringing a whole team → For Teams. Still unsure? Write to us with two lines about where you are; a human replies.
Cohorts are capped at 24
Applications take ten minutes and are read by an engineer. If a different course fits you better, we’ll tell you straight.