Kubernetes gives you the pieces to run containers. It does not give you a finished platform. You still have to add a way to build images, a way to get traffic in, a way to decide which pods may do what, and a way to keep all of that in sync. OpenShift is Kubernetes with those pieces already bolted on and wired together. It is the same engine underneath, with opinions on top. Here is the concrete version. A developer pushes code to Git. OpenShift builds an image from that code, checks it against the security rules, rolls it out, and hands it a URL with TLS. Nobody opens a ticket. Nobody hand-edits the cluster. This lesson follows one push through that whole path, and then shows the two ways it breaks most often in real life: a pod the security rules refuse, and a hand edit the GitOps operator quietly undoes.
Every hop charges rent in seconds. The bar below is a worked example for one push, not a measurement from a live system, but the shape is honest: the build is most of the trip, the rollout is second, and everything else is small. Step through the lesson or switch the scenario and watch the bar change. When the security rules refuse the pod, the rollout hop swells to 120 seconds of waiting and the hops after it disappear, because they never ran. When the operator reverts a hand edit, the operator hop grows to 60 seconds. The build is the cost of making the thing. The rest is the cost of proving it is safe to run.
The budget above is one fixed trip. This box is yours. Change the replica count, the build cache, or the auto-sync setting, and watch the total move. The budget bar above moves with it, so you can see which hop is eating the time.
How many pods the rollout starts. Each pod takes about 10 seconds to become ready, so more replicas means a longer rollout. This is the real cost of scaling up: every replica adds rollout time.
Warm means the dependencies are already downloaded, so the build takes 45 seconds. Cold means every dependency downloads again, so the build takes 240 seconds. A cold cache is the usual reason a build suddenly takes four times longer.
On means the ArgoCD operator reverts a hand edit in about 60 seconds. Off means the drift sits until a human notices it, about 1,800 seconds, which is 30 minutes. The toggle is the difference between a self-healing cluster and a quiet mistake.
Try this: (1) Set the build cache to Cold at the defaults. The total jumps from 101 seconds to 296 seconds and nothing else changed. (2) Now set replicas to 10 as well. The total is 366 seconds. Same code, same cluster. Only the cache and the replica count changed. (3) Turn auto-sync off. The deploy total does not move, but the drift fix time jumps from 60 seconds to 1,800 seconds. That is the cost of a cluster nobody is watching.
Three questions. No score is saved anywhere. This is just you against the material.
Same topic, four times. First the platform idea, then builds, routes, and the security rules that bite, then operators and GitOps on the platform, then the level where I count whether the platform earns what it costs.
Definition: Kubernetes gives you the pieces to run containers. It does not give you a finished platform. You still have to add a way to build images, a way to get traffic in, a way to decide which pods may do what, and a way to keep all of that in sync. OpenShift is Kubernetes with those pieces already bolted on and wired together. It is the same engine underneath, with opinions on top.
Types:
Uses: A developer pushes code to Git. OpenShift builds an image from that code, checks it against the security rules, rolls it out, and hands it a URL with TLS. Nobody opens a ticket. Nobody hand-edits the cluster. I use it when the team would have built all of those pieces anyway, and I want them on day one instead of after a year of wiring.
Dimensions: With a few services on one cluster, the platform is ready on day one and the build is most of the trip. As services grow, the build farm and the rollout dominate the deploy time. What breaks first is usually an image that assumes it runs as root, which the default security rules refuse, or a Route with a typo in the Service name, which fails exactly like a dead app with a 503. I notice the first from a pod that never starts and the second from the Route answering while the app is healthy. What it costs is the license, the support, and the time to learn the opinions. The trade is a working platform on day one against some choice. I like the trade when the team needed the whole platform. I do not like it when the team only needed the engine.
Definition: A BuildConfig is fine for a simple build. A Route is one small file that exposes a Service with TLS. An SCC is stricter and more specific than the broad Pod Security Standards: it controls the user ID range, the groups, the volumes, and the capabilities, per service account. The default is to run as a random non-root user inside an assigned range.
Types:
Uses: I fix a refused pod in the image, not in the rule: set a USER in the Dockerfile, make the directories writable by the group, and stop assuming root. I move from BuildConfigs to Tekton Pipelines when the team needs the same steps on every service and wants them enforced, not suggested. A pipeline that cannot be skipped is a guardrail. A BuildConfig that anyone can bypass is a suggestion. On call, if a Route answers 503, I check the Service name first.
Dimensions: A warm build cache takes 45 seconds. A cold cache takes 240, because every dependency downloads again. Each replica adds about 10 seconds of rollout time. What breaks is a cold cache after a base-image change, a build queue when every team pushes at once, or an SCC loosened to allow root as a fast fix, which trades one broken deploy for a cluster full of pods that run as root. I notice the first two from deploy times that jump without the code changing, and the third only when I audit who runs as root. What it costs is build minutes, registry storage, and the time to write the image correctly. The trade is guardrails against escape hatches. The fast fix is usually the wrong one.
Definition: An operator is a controller plus a custom resource. The custom resource says what should be true, and the controller makes it true. The Operator Lifecycle Manager installs and updates operators from a catalog, so the operator itself arrives as a package instead of a pile of YAML. The ArgoCD operator is the one that matters most here: it watches Git and the cluster and keeps them in sync.
Types:
Uses: I bootstrap a new cluster with one parent Application, and it deploys the whole platform. I use sync waves so the database lands before the app and the Route lands last, so traffic never arrives before the app is ready. In a design review, the question I ask is which operator writes to etcd on every sync, because every operator and every sync writes there, and etcd is the quiet bottleneck at scale.
Dimensions: At ten times the services, one cluster stops being the unit. I add more clusters and manage them with a fleet tool, and GitOps becomes the only sane way to keep them in sync, because nobody can hand-edit ten clusters. What breaks is an operator that misbehaves, a template change that fans out to every cluster, or a hand edit the operator quietly undoes while someone is debugging. I notice the first from the operator's own logs and the last from a fix that keeps disappearing. What it costs is operator upkeep, catalog upgrades, and the learning curve of the platform's opinions. The trade is enforcement against flexibility. The platform decides more, and I decide less, on purpose.
Definition: OpenShift costs money: the license, the support, and the people who learn it. It earns that money when it replaces platform work the team would do anyway. The honest math is hours, not features. I count the platform hours OpenShift saves in a quarter, and I count the hours the team spends learning its opinions. If the first number is bigger, it earns its keep. If it is not, vanilla Kubernetes with a small set of tools is the right call, and I say so.
Types:
Uses: Five engineers who would spend a year building CI, a registry, ingress, security rules, and GitOps by hand: OpenShift buys that year back. Three services on one cluster and one engineer who knows Kubernetes: it is heavy, and I say so in the design review. At 2 AM, the question is not which feature the platform has. It is how long from a Git push to the same change on every cluster, and whether the build farm or the registry is the thing in the way.
Dimensions: At a hundred times the scale, the image registry and the build farm become the bottleneck, not the apps. What breaks is a saturated build farm, a registry that cannot serve pulls fast enough, or etcd under write pressure from every operator. I notice it as deploy times that grow across the whole fleet at once. What it costs is the license, the support contract, and the people who carry the platform knowledge. The trade is buying a year back against owning the opinions. A platform that saves hours is worth paying for. A platform that costs hours to learn and saves none is not, no matter how good the feature list looks.
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 build is counted and the rollout is timed.
Vanilla Kubernetes gives you the engine and lets you choose everything else. You pick your own CI, your own registry, your own ingress, your own security rules, and you wire them together yourself. OpenShift picks defaults for all of that and ships them wired. A BuildConfig instead of an external CI job. An ImageStream instead of a registry tag you manage by hand. A Route instead of an Ingress you configure. SCCs instead of security rules you write from scratch. The trade is simple. You get a working platform on day one, and you give up some choice. I like the trade when the team would have built all of it anyway. I do not like it when the team only needed the engine and now has to learn the opinions too.
The SCC is the part of OpenShift that bites newcomers. Plain Kubernetes has Pod Security Standards, which are broad rules about what a pod may do. An SCC is stricter and more specific: it controls the user ID range, the groups, the volumes, and the capabilities, per service account. The default is to run as a random non-root user inside an assigned range. An image that assumes it runs as root breaks on that default. The fix is in the image, not in the rule: set a USER in the Dockerfile, make the directories writable by the group, and stop assuming root. Loosening the SCC to allow root is the fast fix and the wrong one, because it trades one broken deploy for a cluster full of pods that run as root.
An operator is a controller plus a custom resource, and the plain version is this: the custom resource says what should be true, and the controller makes it true. The Operator Lifecycle Manager is the installer and updater for operators. It handles versions, upgrades, and permissions, so the operator itself can be installed from a catalog instead of a pile of YAML. The ArgoCD operator is the one that matters most for this lesson. It watches Git and the cluster and keeps them in sync. ApplicationSets extend it: one template that creates an ArgoCD Application per service, per environment, so forty services do not need forty hand-written configs. Sync waves order the work: the database first, the app second, the Route last.
A BuildConfig is fine for a simple build: code in, image out. It gets thin when the pipeline has to test, scan, sign, and promote. OpenShift Pipelines runs on Tekton, and a Tekton pipeline is a list of tasks that run as pods. The build task, the test task, the scan task, and the promote task each run in their own pod, and the pipeline passes the image from one to the next. I move from BuildConfigs to Pipelines when the team needs the same steps on every service and wants them enforced, not suggested. A pipeline that cannot be skipped is a guardrail. A BuildConfig that anyone can bypass is a suggestion.
OpenShift costs money: the license, the support, and the people who learn it. It earns that money when it replaces platform work your team would do anyway. If you have five engineers who would spend a year building CI, a registry, ingress, security rules, and GitOps by hand, OpenShift buys that year back. If you have three services on one cluster and one engineer who knows Kubernetes, it is heavy. The honest math is hours, not features. I count the platform hours OpenShift saves in a quarter, and I count the hours the team spends learning its opinions. If the first number is bigger, it earns its keep. If it is not, vanilla Kubernetes with a small set of tools is the right call, and I say so.
At 10x the services, one cluster stops being the unit. I add more clusters and manage them with a fleet tool, and GitOps becomes the only sane way to keep them in sync, because nobody can hand-edit ten clusters. At 100x, the image registry and the build farm become the bottleneck, not the apps. I cache the base images, I limit who can trigger a full rebuild, and I watch etcd, because every operator and every sync writes to it. The budget stops being deploy time and becomes fleet time: how long from a Git push to the same change on every cluster.
One small file exposes a Service with TLS at the edge:
apiVersion: route.openshift.io/v1
kind: Route
metadata:
name: checkout
spec:
host: checkout.apps.example.com
to:
kind: Service
name: checkout
weight: 100
port:
targetPort: web
tls:
termination: edge
insecureEdgeTerminationPolicy: Redirect
Seven facts in one small file. The host is the public name. The to field says which Service gets the traffic, and the weight says all of it, which is how a canary would split it later. The port says which Service port to use. The TLS block says the router ends TLS at the edge and redirects plain HTTP to HTTPS, so no request ever travels unencrypted from the outside. If this Route answers 503, I check the Service name first, because a typo here fails exactly like a dead app.
This one stayed with me because the apps were fine and the deploys were not. Every build was green, every image was pushed, and nothing could ship.
A cluster upgrade ran over the weekend. On Monday morning, every deploy failed. The builds were green. The images were pushed. The new pods sat in Pending and never started. The old pods kept serving traffic, so users saw nothing wrong at first. Then the teams that needed to ship a fix on Monday could not ship anything. The deploy pipeline was red across the board, and every team filed the same ticket within an hour.
Three things. First, the CI pipeline now fails any image that runs as root, so the rule is caught at build time instead of deploy time. Second, every cluster upgrade now runs a canary deploy of a real service before the upgrade is called done. If the canary cannot deploy, the upgrade is not done. Third, the platform team keeps a list of every exception to the security rules, with an owner and an expiry date. The Monday fix was a temporary exception, and temporary exceptions without an expiry date become permanent. The lesson I kept: the upgrade did not break the apps. It exposed that the apps were relying on a rule that was never promised.
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 delivery path. Take a minute with it before you read my approach.
Design the delivery path for 40 services on OpenShift across three environments: dev, staging, and prod. Every service is built from Git, deployed with GitOps through the ArgoCD operator, and exposed with a Route. A bad deploy must never reach prod, and a developer must never be able to push straight to prod. Sketch the path from a Git push to a prod URL, and say who can do what at each step.
I would ask five things before I sized anything.
Start with the numbers from this lesson. One service deploys in about 101 seconds on a warm cache with three replicas. Forty services deploying at once is not forty times that, because the builds share a cache and the cluster builds in parallel. I plan the build farm for ten builds at once, which covers the normal day, and I queue the rest. Promotion moves the image, not the code: dev builds the image once, staging runs the same image, and prod runs the same image again. Rebuilding for each environment is how the same code passes staging and fails prod. For sizing, 40 services at three replicas is 120 pods plus the operators, so I plan the cluster for 150 pods with room to roll. A rollback is a Git revert plus a sync, about 60 seconds with auto-sync on, and anyone on call can press it.
Promoting the same image buys safety and costs speed, because staging has to run before prod can. Auto-sync buys fast fixes and costs control, so prod auto-syncs only after a human approves the sync, while dev syncs on every push. One ArgoCD setup for all environments buys simplicity and costs blast radius, so I split prod into its own instance with its own repo. Pipelines buy enforced steps and cost build time, so I keep the pipeline short: build, test, scan, promote, and nothing else. And the Route per service buys a clean URL and costs hostname management, so I use one wildcard domain and let the Routes hang off it.
Saved in this browser, so the Lessons index can show your progress across the course.