Authority you reclaim is authority you run

One production workload, one DGX Spark, one owner. A cloud-free serve path proven end to end by executing probes. This is an authority measurement, not a cost claim and not an on-prem-at-scale claim, scoped to the system that actually ran.

Self-funded. No vendor paid for this answer, and the model that drafted the page is one of the dependencies the migration reclaimed; the findings were owner-validated against the recorded artifacts.

The pitch every cloud-exit deck makes: leave the managed platform and take control back. I tested it on one production application, mine. The Virtual CTO Advisor was all-in on a single cloud: document and vector store, embeddings, generation, session state, identity, all managed, all decided by someone else. This lab migrated a clone of it to the DGX Spark, retained compute kept below the platform's abstraction, and kept going until the serve path ran with no cloud credentials in the environment. Production was never touched. The question isn't whether the workload can run local. It can, and that's the least interesting fact in the lab. The question is how much decision authority actually comes home when it does, and what that authority costs to hold.

Five moves, one probe each

I executed the migration as authority accounting, not as a lift-and-shift, and every step was validated by a probe that executed rather than a claim that sounded right. The document and vector store left Firestore for CloudNativePG and pgvector, tucked behind the application's existing retrieval provider seam, so the ranking logic validated on the cloud is the same code path on pgvector. Embeddings left a hosted API for a local model on the box, and the corpus re-embedded cloud-free: all 3,489 chunks, no credentials, Hugging Face offline. Generation left Vertex for vLLM. Session state left Firestore for Postgres, and that swap surfaced the real cost of retention. The thread and session store had no seam and had to be given one, because an eager cloud client in the import path blocked a cloud-free boot until the coupling was made lazy behind a store interface. Identity came home last: the verify path swapped from Firebase to OpenID Connect against a Keycloak realm. Underneath all of it sits k3s and the operators you run.

The probes are the record. The vector store survived a force-kill wipe-and-restore drill with all 3,489 chunks intact and a two-second recovery, and the wipe was replayed on purpose. Identity issued a real signed token, the application accepted it, and it refused the request without one. Then the load-bearing proof, the kill-the-cloud test. With no cloud credentials in the environment and the model cache offline, the application retrieved from pgvector, embedded locally, generated on vLLM, and answered in my voice: a grounded, cited answer with an evidence score of 0.916, over an HTTPS ingress. The retention is measured, not asserted.

Read through the Decision Authority Placement Model (DAPM), the ledger is short. Five capabilities moved from Ceded to Retained: store, embeddings, generation, session state, identity. The metal was never a cession. The GB10 is commodity NVIDIA hardware, and even its one gap is honest about itself. GPU access works through a runtime-class injection; GPU accounting doesn't, because the driver can't report unified memory. That gap is closeable in the open-source device plugin, which makes it Retained authority left unbuilt by choice, not a vendor lock. And the reasoning authority never moved, because it never left. It was always me and the model, zero delegated to any platform, by design. That's the same zero every vendor carries.

Kubernetes finally got a grade

A method finding fell out of the migration, and it's the one I didn't see coming. I had left Kubernetes out of the assessment canon because grading it honestly was impossible. Kubernetes isn't a product. It's an assembly, and an assembly can't be scored in the abstract, only assembled and then tested. One production application solved that. The workload drew the product boundary: inside it, every function was fair game and testable by execution; outside it, nothing was. That single move put a Kubernetes row in the canon as a peer to the bundled platforms, scored on twenty-six functions, every one earned by executing the migration rather than reading a datasheet. Bound the platform question with a real workload before you score it. It's the only honest way I've found.

The bill comes with the pager

The objection writes itself: this is a homelab, it doesn't scale, and the public cloud is cheaper anyway. Partly fair, so let me concede what's real. Whether the cloud is cheaper at a given utilization is a legitimate question, and this lab doesn't answer it. It measures a different axis: authority placement. That finding holds independent of scale, and scale doesn't soften it, it sharpens it. At estate scale the operational bill of each Retained layer grows, which is exactly why the placement decision has to be made deliberately rather than by default. So the lab priced the bill per layer, and the pattern repeats. The store came with an operator to run and a restore to drill. The embeddings came with a model to own and a re-index to carry. The serving layer came with a memory budget and the uptime. Identity came with a realm to administer and keys to rotate. Retained authority is Retained responsibility. The pager comes with it.

Which is why the sharpest advice in this lab is negative: don't reclaim a layer you're not ready to operate. Read a cloud exit as a DAPM decision made layer by layer, not an all-or-nothing platform swap, and accept that the layers you leave Ceded may be the ones worth paying someone else to hold. The honest bounds matter just as much. One workload, one box, one owner. Cooling, power, facilities, multi-tenancy, and estate breadth never re-entered the picture, and each of them changes the trade, so nothing here is an on-prem-at-scale claim. Total cost of ownership against the public cloud wasn't measured. Identity federation was proven on one tenant, not as an estate-wide identity plane. The GPU-accounting gap was shown to be closeable, not closed.

Two questions stay open, and they're better than the one I started with. First, where is the line between Retained and Delegated when you run someone else's open-source operator? CloudNativePG carried real day-2 for the data tenant: provisioning, failover, backup, replica creation, all drilled. I count that as Retained because the code is mine to fork, but the operational reality is closer to a delegation I can revoke. Second, how much of the operational bill can shift to managed tooling while the decision stays with the owner? The priced gaps are the map of where that trade is available.

I set out thinking the deliverable was a runbook, proof that a model could transcribe a migration once a human had run it. That happened, and it turned out to be the least interesting thing in the room. The reframe arrived late: I wasn't measuring Kubernetes, I was measuring DAPM. Firestore to CloudNativePG, Vertex to vLLM, Firebase to Keycloak. None of those were technology swaps. Each was decision authority moving from Ceded to Retained, and each one bought me authority at the price of a system to keep alive. Kubernetes was the mechanism. Authority was the thing that moved. So the verdict, in one line you can test against your own estate: every layer you move from Ceded to Retained is a decision you now own and a system you now operate. Authority you reclaim is authority you run.

The numbers

Where each layer belongs

Assessments at the time of the lab

Method and disclosure

Self-funded, no sponsor. The application was migrated as a clone and production was never touched. The serve path was proven with no cloud credentials in the environment.

What ships: the substrate, the authority movements, the operational bill per layer, and the raw lab detail. What stays proprietary: the corpus contents, the retrieval tuning, and the owner-authored assessment thresholds.

The quantitative record is the Fourth Cloud assessment bounded-kubernetes-fourthcloud, live in the canon at cloud.layer2c.com. This lab is the story of how a workload became the boundary that made that assessment possible.

Placement correction, September 28, 2026. The Layer 0 row moved from Ceded on both sides to Retained on both sides, because the instrument places Layer 0 by the hardware and the runtime adopted, not by who owns or rents the capacity: commodity x86 and NVIDIA hardware is Retained, and elsewhere an open, standard runtime is Retained while a proprietary runtime that ties the workload to one vendor’s hardware is Ceded. The earlier reading made the metal the lab’s one cession; under the rule there is none at Layer 0. The five moves at the layers above are unchanged.

Placement table re-scored, September 28, 2026. Every row is now read for portability, and the table says so at the top. Earlier tables across the labs mixed that reading with the other one, and some rows rested on location, ownership or cost. No placement changed here; the notes now give each row’s reason under that reading.

The essay on this page was rendered from the lab’s frozen structured record by a model writing under this practice’s voice specification, with a deterministic gate checking every figure against the record before publication. The record is the canonical surface: where prose and record disagree, the record rules.