Platform Engineering · Lesson 78

NoOps

NoOps is the idea that a developer can ship code to production without a dedicated operations team doing anything by hand. Here is the plain version first. You fix a bug in the checkout page. You push the fix. A pipeline builds it, tests it, puts it in a container, and hands it to the platform. The platform starts the new version, moves traffic to it, watches it, and scales it when traffic rises. Nobody files a ticket asking ops to deploy it. Nobody logs into a server. Nobody stays up to watch the deploy. That is the whole idea. It exists because the old way was slow and fragile. Every deploy waited on a person, and every person was a bottleneck and a single point of failure. NoOps does not mean nobody does operations. It means the operations work is written down as code, once, by a platform team, and then every developer uses it by pushing code. The work moved. It did not vanish. This lesson follows one push from the developer's laptop to live traffic, hop by hop, and then shows you the three places the promise breaks: the work the platform cannot do, the failure nobody owns, and the bill nobody watched.

Difficulty: Advanced · Know this first: Lesson 55, Lesson 49
Run it as:

When it breaks, I check

One thing to remember

Where the time goes

Every hop charges rent in seconds. The bar below is a worked example for one deploy, not a measurement from a live system, but the shape is honest: on a normal deploy, the build and the tests are 180 seconds of the 430 second trip. The platform does the rest, and the developer does nothing. Step through the lesson or switch the scenario and watch the bar change. The hidden debt scenario more than doubles the trip without the code changing at all. The spike more than doubles it too, and most of that is the platform scaling under load. The time is not the whole story. The debt scenario costs a human doing ops by hand. The spike scenario costs money. The bar shows the time. The steps show the rest.

Extra diagram — Push to main — who does what after you let go

A second picture of the same system. I start with one box and build to the full Master picture. The dot is the push — one bug fix.

11 stepsMoving: the push — one bug fixBasic to Master
Developer1Git main2Pipeline4 STAGESImage plus config,one version1 VERSIONPlatform: deploy5Traffic shift3 STEPSPlatform: scale70% CPUAlerts8Bill9Owner at 2 AM2 AMBuild-up: goldenpath with its11the push — one bug fix
Extra diagram

    Legend: orange dot = the push — one bug fix  ·  hexagon = a service or model  ·  shaded box = a store, log, or file  ·  dashed line = the wire between boxes. Progression: Starts from scratch with one developer and one push — the only human action in the lesson. Adds the pipeline, then the platform, then the alerts, bill and owner one at a time. Ends at the Master-level picture: a golden path with its gaps named, hidden debt tracked, and cost treated as a contract.  ·  Traffic: orange = request forward, green = response back.

    Change the team and watch the ops work move

    The budget bar above shows three fixed stories. This simulator lets you write your own. Move a slider and watch the manual ops hours, the hidden debt, and the monthly cost move. The numbers are a teaching example, not live measurements. The shape is the lesson: the managed share and the platform team are the levers, and the work that neither of them covers is the debt.

    How many times the team ships a week. One is a quiet internal tool. Fifty is a busy product team. Every deploy carries ops work: build, test, deploy, watch, scale, patch. More deploys means more ops work, unless the platform absorbs it.

    What share of the system runs on managed services and serverless instead of servers the team runs itself. Zero means the team runs everything. One hundred means the cloud runs everything and the team only writes code. Managed services are the enablers of NoOps, because they remove the servers from the team’s job. They also move the cost from fixed to per-use, and per-use cost scales with traffic.

    How many developers ship code. The manual ops hours get split across them, so the same total hours feel very different on a team of five and a team of fifty. A small team feels every hour. A big team can hide the debt for a while, until it grows past hiding.

    Whether a platform team exists to build and run the self-service platform from Lesson 55. Yes means the golden path is maintained, the gaps get closed, and the debt gets an owner. No means the platform is a pile of scripts nobody maintains, and the automation covers half as much. The platform team is the NoOps enabler. Without it, NoOps is just developers doing ops by hand in the dark.

    Manual ops hours per week9.2 h10 deploys a week, 55.2 minutes of manual ops each, 60% managed, platform team on
    Hidden ops debt hours per week0.75 hthe work the platform does not cover, done ad hoc by developers
    Monthly total cost$10,539$2,539 managed services plus $8,000 platform team share. Budget: $15,000 a month
    Manual ops hours per developer per week0.46 h9.2 hours split across 20 developers

    Try this: (1) Turn the platform team off at the defaults. The manual ops hours jump from 9.2 to 14.6 a week and the hidden debt jumps from 0.75 to 3.0 hours, while the bill falls by $8,000. The platform team is not a cost. It is the thing that keeps the work automated. (2) Now turn the platform team back on and push the managed share to 100%. The manual ops hours fall to 2.0 a week, but the hidden debt rises to 1.25 hours, because more of the system is managed and more of the gaps are the platform’s to close. (3) Now set deploys per week to 50. The manual ops hours jump to 46.0 a week, a full-time job, even with the platform team on. NoOps scales the deploys. It does not make the remaining manual work disappear.

    Check yourself

    Three questions. No score is saved anywhere — this is just you against the material.

    Basic to master

    The lesson above walks one push through nine hops, from the commit to the 2 AM page. This section covers the same deploy four times, from the first push I make to the level where the platform is the company.

    Basic — Push and the platform does the rest

    Definition: NoOps automates operations until no dedicated ops team is needed. The work did not vanish. It moved. The pipeline builds and tests. The platform deploys, scales, and heals. The developer pushes code and watches a dashboard. The push is the deploy request. There is no ticket and no handoff.

    Types:

    • The pipeline — build, test, package. A red pipeline stops the deploy before broken code reaches a server.
    • The golden path — the one blessed way to ship, built by the platform team.
    • The managed service — the cloud runs the undifferentiated work, like the database, so the team does not patch it.
    • The serverless function — code with no server to provision, charged by the invocation.

    Uses: I use this level every time I ship. I push to main, I watch the pipeline go green, and I check the health check before I check anything else. If the new version passes, the platform moves the traffic.

    Dimensions:

    • Load: At one deploy a week the platform is idle most of the time. At fifty deploys a week the pipeline queue grows, and the build cache starts to matter.
    • Breaks: It breaks when the pipeline skips tests to go faster. A pipeline that ships bugs faster is not a faster pipeline. I notice it when a bug reaches production that a test would have caught.
    • Cost: The cost is the platform and the managed services, running all the time. A quiet internal tool pays the same platform cost as a busy product.
    • Trade-off: I give up choosing the server to get a deploy I never touch. The platform decides where the code runs. I have to learn to read its dashboard, not to log in.

    Intermediate — The golden path and its gaps

    Definition: The golden path is the pipeline, the deploy, the scaling rules, the dashboards, and the alerts, maintained as one product. The manifest is the config a developer writes once: the service, its image, its scaling rule, its alerts with a named owner, and its cost limit. The honest part is the last block. It says out loud what the platform does not cover.

    Types:

    • The service manifest — one file, one version, image plus config, with a named owner.
    • The scaling rule — two to twenty replicas at 70 percent CPU, with a daily cost limit beside it.
    • The health check — the signal that says the new version is ready before traffic moves.
    • The unsupported jobs list — migrations, secret rotation, and the runbook for each, written down instead of hidden.

    Uses: I use this level when a deploy stops. I check what the platform refused to do. A deploy that stops with a clear error is a platform telling the truth. Then I read the manifest to find the runbook for the job the platform does not cover.

    Dimensions:

    • Load: At 10x the deploys the platform becomes the bottleneck. The pipeline queue grows and the golden path needs a team that treats it like a product.
    • Breaks: It breaks when the golden path does not cover the job and nobody wrote it down. The deploy stops, a developer runs a migration by hand, and the five minutes is a human doing ops in the dark.
    • Cost: The cost is the platform team. Two engineers who do not ship features, measured by the manual hours they save, not by the features they ship.
    • Trade-off: I give up the freedom to deploy any way I like to get one path that works every time. A deploy outside the path is a deploy nobody can debug at 2 AM.

    Advanced — Hidden debt and the lonely debug

    Definition: Hidden ops debt is the work the platform does not cover, that nobody wrote down, and that falls on whoever is awake when it breaks. A database migration. A secret rotation. A manual approval from a vendor. Each one is small. Together they are a second job that nobody owns and nobody measures. I find it by asking the team what they did by hand last week.

    Types:

    • The unowned job — work with no owner, no runbook, and no measurement, waiting for the worst night to appear.
    • The platform team — the enabler. Turn it off and the manual work jumps from 9.2 to 14.6 hours a week while the hidden debt jumps from 0.75 to 3.0 hours.
    • The on-call rotation — the developer who shipped the change, backed by the platform team when the platform itself breaks.
    • The stateful job — a migration or a backfill the platform cannot decide, so a human must.

    Uses: I use this level when the alert has no owner. I check the rotation before I check the alert. An alert routed to a team inbox is an alert nobody owns. Then I write the job down, give it an owner, and measure it, because debt I do not measure grows in the dark.

    Dimensions:

    • Load: At 10x the deploys the debt grows with them. The same gap that cost one hour a week now costs ten, and the team of five feels it first.
    • Breaks: It breaks when the platform itself breaks and the developer debugging it did not build it. The 2 AM debug is lonelier, and the fix is slower, because the dashboards are not theirs.
    • Cost: The cost is the manual hours. Ten deploys a week at 60 percent managed is 9.2 hours a week with a platform team, and 14.6 without one. The bill falls by $8,000 and the work comes back.
    • Trade-off: I give up the ops team to get a smaller team that ships faster. The price is the lonely debug. The deploy is faster and the team is smaller, and the 2 AM fix is on the developer who shipped it.

    Hidden ops debt is a list before it is a project. I find it by asking the team one question at the end of the week: what did you do by hand this week that a machine could have done. The answers go on a list with an owner and an estimate, and the list is reviewed every month. A database migration done by hand, a secret rotated by hand, a manual approval from a vendor: each one is small, and together they are a second job nobody owns. The list is the fix, because debt I do not measure grows in the dark, and debt on a list gets a date.

    Some work must stay human, and I name it on purpose. A deploy that changes how money moves gets a human approval, because the cost of a wrong deploy is higher than the cost of waiting ten minutes. A secret rotation that touches production gets a human watching, because the rollback is a person, not a script. The rule I use is simple: if the action can break a real user and cannot be undone in a minute, a human approves it. Everything else is a candidate for automation, and I automate the most frequent one first.

    Master — Cost as a contract and the platform as a product

    Definition: At this level the platform is the company. Every developer depends on it, every deploy goes through it, and a platform outage is a company outage. The platform team gets error budgets of its own. The managed-services bill is a budget with an owner, a forecast, and a weekly review. Automation without a limit is a blank check, and the platform will cash it.

    Types:

    • The cost limit — a daily cap that pages the owner, and a hard cap high enough never to fire on a real sale day.
    • The retry limit — three tries with backoff, then a dead letter queue, so a failing function stops instead of running forever.
    • The cost alarm — a page when the daily spend passes its limit, because a bill that triples overnight should page someone that night.
    • The platform error budget — the platform measured like any service, with its own on-call and its own roadmap.

    Uses: I use this level when finance emails about a bill. I check the cost per request before the total. A cost per request that jumped tells me what grew. A function that retries a failing call in a loop is the most expensive bug in serverless, because every retry is a new charge.

    Dimensions:

    • Load: At 100x the platform is the bottleneck for the whole company. A bad platform deploy stops every team at once, not just one service.
    • Breaks: It breaks when a scaling rule has no cost limit and a traffic spike spends money faster than any human would. I notice it in the bill, the morning after, which is too late.
    • Cost: The cost is the whole bill: managed services, serverless, and the platform team. At 100x, a 10 percent cost surprise is a real number, and the budget stops being a target and becomes a contract.
    • Trade-off: I give up a hard cap that stops deploys to get a soft limit that pages. A hard cap that stops deploys on the biggest day of the year is worse than an expensive day. The page keeps a human in the loop, and the loop keeps the bill honest.

    Automation without a spending limit is a blank check. A function that retries a failing call in a loop charges for every retry, and a loop that never stops is the most expensive bug in serverless. I put a budget on every automated workflow with an owner and a weekly review, and I alert on cost per request, not on the total, because the total fools me every time growth is good. The platform team gets error budgets of its own, and a platform outage is a company outage, so the platform dashboard sits next to the product dashboards, and the platform on-call is a real rotation.

    Self-healing fails in a loop when the fix recreates the problem. A service that restarts because it runs out of memory will run out of memory again after the restart, and the loop pages nobody because each restart looks like a recovery. I break the loop with a counter: three restarts in an hour stops the healing and pages a human, because the third restart is evidence the fix is wrong. I also log every automated action with the reason, so the review can see the loop instead of seeing three separate recoveries. A healing action that fires more than twice for the same cause is not healing. It is a symptom.

    Go deeper

    The lesson above is one push through nine hops. Production is the rest of it. Here is what I actually spend my time on once the deploy is counted and the budget is written down.

    NoOps vs DevOps vs SRE

    NoOps, DevOps, and SRE are three answers to the same question: who does the operations work. DevOps says the developers and the operators work together, and the wall between them comes down. SRE says engineers run the system, with error budgets and toil limits, and the toil is the work you automate away. NoOps says the operations work is automated so completely that no dedicated ops team is needed at all. They are not three different jobs. They are three points on one line. DevOps shares the work. SRE engineers the work. NoOps automates the work until the team is small enough to disappear. The mistake is treating NoOps as the end of operations. It is not. It is operations done by a platform team and by developers, instead of by an ops team. The work is still there. The job titles changed.

    Hidden ops debt

    Hidden ops debt is the work the platform does not cover, that nobody wrote down, and that falls on whoever is awake when it breaks. A database migration. A secret rotation. A manual approval from a vendor. A compliance form. Each one is small. Together they are a second job that nobody owns and nobody measures. I find hidden debt the same way I find any debt: I ask the team what they did by hand last week. If the answer is nothing, either the platform is excellent or nobody is telling the truth. The fix is boring. Write the job down. Give it an owner. Automate it or schedule it. Then measure it, because debt you do not measure grows in the dark. The simulator in this lesson counts it in hours a week, and that number is the one I would put on a dashboard next to the uptime.

    The platform team as the enabler

    The platform team is the reason NoOps works at all. They build the golden path from Lesson 55: the pipeline, the deploy, the scaling rules, the dashboards, the alerts. They are the ops team, renamed and moved one level up. Instead of operating one service, they operate the machine that operates all the services. That is why the simulator in this lesson treats the platform team as a toggle, not a detail. Turn it off and the automation covers half as much, the debt doubles, and the manual work nearly doubles. A platform with no team behind it is a pile of scripts that rots. The first time a script breaks and nobody fixes it, the developers go back to doing ops by hand, and they do it in the dark, without a runbook. If you want NoOps, fund the platform team. It is the cheapest ops team you will ever hire, because one team serves every developer.

    Serverless and managed services as enablers

    Serverless and managed services are the second enabler. A managed database means nobody patches the database. A serverless function means nobody provisions the server. The cloud runs the undifferentiated work, and the team runs the code that makes the business money. That is the deal, and it is a good deal, until the bill arrives. Managed services charge by use, and use scales with traffic, so the cost scales too. The failure mode is a scaling rule with no cost limit. I have seen a function retry itself ten thousand times a minute because the downstream service was down, and every retry was a charge. The fix is a concurrency cap, a retry limit, and a cost alarm that pages a person. Serverless removes the server. It does not remove the need to watch the bill.

    When NoOps fails

    NoOps fails in four places, and I have seen all four. First, stateful systems. A database migration, a data backfill, a schema change that needs a human to decide the order. The platform cannot decide, so a human must, and if nobody owns it, the deploy stops. Second, compliance. A system that needs a human to sign off on a change, or a human to approve access, cannot be fully automated, and pretending it can is how audits fail. Third, debugging depth. When the platform itself breaks, the developer debugging it is debugging a system they did not build, with dashboards they did not write. The 2 AM debug is lonelier, and the fix is slower. Fourth, cost. Automation scales without asking, and a runaway function or a traffic spike can spend money faster than any human would. NoOps works when the system is stateless, the platform is maintained, the owner is named, and the cost has a limit. When one of those four is missing, NoOps is a promise the system cannot keep.

    What changes at 10x / 100x

    At 10x the deploys, the platform becomes the bottleneck. The pipeline queue grows, the build cache matters, and the golden path needs a team that treats it like a product, with its own roadmap and its own on-call. At 100x, the platform is the company. Every developer depends on it, every deploy goes through it, and a platform outage is a company outage. The platform team gets error budgets of its own, the same as any SRE team from the SRE lessons. The cost story changes too. At 10x, the managed-services bill is a line item. At 100x, it is a budget with an owner, a forecast, and a weekly review, because a 10 percent cost surprise at that scale is a real number. The budget stops being a target and becomes a contract, and every service owns its share of it, in hours and in dollars.

    A golden-path service manifest

    This is the config a developer writes once and the platform runs forever. It declares the service, its image, its scaling rule, its alerts with a named owner, and its cost limit. Plain names, no vendor details.

    service:
      name: checkout-api
      image: registry.example.com/checkout-api:1.42
      owner: priya@example.com
      on_call: checkout-team
    deploy:
      strategy: rolling
      max_unavailable: 1
      health_check: /health
      rollback_on_errors: true
    scaling:
      min_replicas: 2
      max_replicas: 20
      target_cpu_percent: 70
      max_cost_per_day_usd: 120
    alerts:
      - name: error-rate-high
        threshold: 1% errors for 5 minutes
        page: checkout-team
      - name: cost-over-budget
        threshold: $120 in one day
        page: checkout-team
    platform:
      golden_path_version: v7
      unsupported_jobs:
        - database-migrations
        - secret-rotation
      migration_runbook: runbooks/checkout-migration.md

    Read it top to bottom and it is the whole lesson in config form. The service has a name, an image, and a named owner, so the 2 AM page has a home. The deploy is rolling with a health check and an automatic rollback, so a bad version cannot take the service down. The scaling rule says two to twenty replicas at 70 percent CPU, and the cost limit says $120 a day, so the platform knows how far it is allowed to scale. The alerts page the checkout team, not a shared inbox. And the last block is the honest part: the platform says out loud what it does not cover, database migrations and secret rotation, and points at the runbook for the migration. That honesty is what keeps hidden ops debt from being hidden. The config is the operations. The rest is just code.

    The automation coverage check is a count I run every month. I list every step in the runbook, I mark each one manual or automated, and I divide. The number is not the goal. The list is the goal, because the list shows which manual steps are left, and the most frequent manual step is the next automation. I also check the manual steps for the ones that should stay manual, and I mark them as intentional, so nobody automates a money-moving approval by accident. A coverage number without the list is a vanity metric. A list with owners and dates is a plan.

    cat > /tmp/k5-runbook.txt <<'EOF'
    restart stuck job: manual
    rotate secret: automated
    scale up pool: automated
    page owner: manual
    drain node: automated
    EOF
    total=$(wc -l < /tmp/k5-runbook.txt)
    auto=$(grep -c automated /tmp/k5-runbook.txt)
    echo "$auto of $total steps automated"

    Three commands, three flags, and the redirect is the one that matters most.

    cat > /tmp/k5-runbook.txt <<'EOF' writes the lines into a file. > overwrites. <<'EOF' is a heredoc, and the quotes around 'EOF' keep the shell from expanding $ inside the lines. Without the quotes, a $ in the text would be replaced before it reaches the file.

    wc -l < /tmp/k5-runbook.txt counts the lines. -l is lines. < feeds the file on stdin, so wc prints the bare number, 5. That bare number is what total=$(...) needs. With a filename instead, wc prints "5 /tmp/k5-runbook.txt", and the arithmetic breaks.

    grep -c automated counts matching lines instead of printing them. -c is count. It prints 3. Without -c, grep prints the three lines, and echo would have nothing to count. echo "$auto of $total steps automated" prints the two variables. The quotes keep each one as a single argument. I ran the whole box: it prints "3 of 5 steps automated".

    Expected output: 3 of 5 steps automated. The two manual steps are the ones to look at: restarting a stuck job by hand and paging the owner by hand. If the stuck job restarts three times a week, it is the next automation. If the page goes to a team inbox, it has no owner, and the automation starts with the routing, not the page.

    One time it broke

    This one stayed with me because everything worked. The platform scaled, the traffic was served, and the deploy was a success. The bill was the incident.

    What broke

    A team had moved a reporting service to serverless, three functions behind an API. One of the functions called a downstream service that went down for an hour. The function retried the call, and the retry had no limit and no backoff. Every failed call triggered another call, and every call was charged. The function invoked itself thousands of times a minute for an hour. Traffic was flat. The users saw slow reports and moved on. Nobody was paged, because the errors were inside the function and the function kept running. The first sign of trouble was a finance email the next morning: the monthly serverless bill had tripled overnight. The platform did exactly what NoOps promises. It scaled without a human. It also spent without a human, because nobody had told it how far it was allowed to go.

    Timeline

    • Day 1, 14:00The downstream service goes down for maintenance that ran long. The reporting function starts failing its calls.
    • Day 1, 14:05The function’s retry logic kicks in. No limit, no backoff. Every failed call retries immediately, and every retry is a new invocation and a new charge.
    • Day 1, 14:30Invocations hit thousands a minute. The platform scales to meet them, because that is what it is built to do. No alert fires, because the function is running, not failing.
    • Day 1, 15:00The downstream service comes back. The retry storm stops on its own. The function goes quiet. Nothing looks broken.
    • Day 2, 09:00Finance emails the team lead. The serverless bill tripled overnight. Nobody on the team knows why yet.
    • Day 2, 10:15I open the invocation counts per function. One function has ten times the invocations of the other two, and almost all of them failed. The retry loop is obvious once you look at the count.
    • Day 2, 11:00I confirm the downstream outage window matches the invocation spike exactly. The function retried itself for an hour, and the platform charged for every retry.
    • Day 2, 13:00The retry limit is set to three with backoff, a dead letter queue takes the failures, and a cost alarm is added to the function.

    What changed after

    Three things. First, every function got a retry limit of three with backoff, and a dead letter queue for the failures, so a failing call stops after three tries instead of running forever. Second, every function got a cost alarm that pages the owner when the daily spend passes its limit, because a bill that triples overnight should page someone the same night, not wait for finance the next morning. Third, the team added a cost review to the weekly standup, five minutes, one number per service, so the bill is watched the same way the error rate is watched. The lesson I took home is simple: automation without a limit is a blank check. NoOps removes the human from the deploy. It must not remove the human from the bill.

    If you remember nothing else

    Design exercise

    This is the kind of question I would ask in an interview, and the kind I ask myself before I sign off on a real NoOps setup. Take a minute with it before you read my approach.

    The prompt

    Design the NoOps setup for a team of 20 developers shipping a checkout service 10 times a week. The team must deploy without an ops team, handle 10 times the traffic on the biggest sale day of the year, keep the monthly platform and cloud cost under $15,000, and answer one question in writing: who gets paged at 2 AM. You have the platform from Lesson 55, the IaC from Lesson 49, managed services and serverless, and a platform team of two engineers. Sketch the setup: the golden path, the gaps, the scaling rules, the cost limits, and the on-call.

    Clarifying questions to ask first

    I would ask five things before I sized anything. What does the deploy need that the platform cannot do: migrations, secret rotation, vendor approvals? How spiky is the traffic: is 10 times the peak a few hours or a whole day, and what happens at twice that? What is the cost limit: is $15,000 a hard cap that stops deploys, or a budget that pages someone? What happens when the platform itself breaks: who fixes it, and how long can the team wait? And who owns the service at 2 AM: the developer who shipped the change, the team lead, or a rotation?

    Rough sizing, worked

    Start with the simulator math from this lesson. Ten deploys a week at 60 percent managed with a platform team on is 9.2 hours of manual ops a week, 0.75 hours of hidden debt, and $10,539 a month, inside the $15,000 budget with about $4,400 of headroom. The sale day is the test. Ten times the traffic means the scaling rule must allow 20 replicas, and the cost limit must allow a spike day without stopping the deploy. I set the daily cost limit at $120, which is about $3,600 a month at normal traffic, and I allow the sale day to run to $600, because a hard cap that stops deploys on the biggest day of the year is worse than an expensive day. The on-call is the developer who shipped the change, backed by the platform team of two for platform failures. The platform team’s own rotation covers the platform, and the checkout team’s rotation covers the service. The gaps are written down in the manifest: migrations and secret rotation, with a runbook for each and a named owner. The deploy pipeline is the golden path from Lesson 55, and the migration runs as a job the platform does support, with the developer watching. Little’s Law for the sizing: 10 deploys a week at 55.2 minutes of manual ops each is 9.2 hours a week, and split across 20 developers that is 0.46 hours each, less than half an hour a week. The team can afford NoOps. A team of five could not, because the same 9.2 hours is nearly two hours each, and the debt would eat the week.

    Trade-offs to name

    A higher managed share buys less manual work and costs more per use, so I set it at 60 percent and keep the database managed but the checkout logic on containers the team controls. A strict cost limit buys budget safety and costs availability on the spike day, so I set a soft limit that pages and a hard limit that is high enough never to fire on a real sale day. A small platform team buys a maintained golden path and costs two engineers who do not ship features, so I measure the platform by the manual hours it saves, not by the features it ships. Automatic rollback buys safety and costs a deploy that rolls back on a false alarm, so I set the rollback threshold at 1 percent errors for five minutes, not a single error. And the on-call is the developer who shipped the change, which buys ownership and costs the developer’s sleep, so the rotation is real, the runbook is written, and the platform team backs it up when the platform breaks.

    Saved in this browser, so the Lessons index can show your progress across the course.

    Next in this series
    Lesson 79 — LLMOps

    This lesson was about automating operations until no dedicated ops team is needed. The next lesson opens up the newest member of the *Ops family: how you operate a language model in production, day after day, when the model itself keeps changing under you. That is LLMOps, and it is the next hop in this module.