Kubernetes vs. Shared Hosting: When Is It Time to Switch?
Shared hosting, often just called web hosting, is where most web projects start. For €5 to €15/month you get a runtime, a database and a web interface, with no terminal and no DevOps.
At some point a project outgrows shared hosting. The only question is when, and whether Kubernetes is the right answer then.
When a Project Outgrows Shared Hosting
Shared hosting works well for WordPress sites, classic PHP applications and static websites, and, depending on the host, small Node or Python apps. A move becomes worth considering when any of these scenarios apply:
1. Your Runtime Isn’t on Offer
Shared hosting usually means PHP, with some hosts adding Node.js or Python. ITSH web hosting runs PHP 8.3 to 8.6 and purely static sites. It gets tight as soon as you need something else: Go, Rust, Java, a runtime your host doesn’t offer, a PHP extension missing from the package (on ITSH web hosting, for example soap, ldap, imap or gmp), or your own system packages and binaries. At that point you need a container image, and with it Kubernetes or at least a VPS.
2. You Need Multiple Permanently Running Processes
A modern SaaS product rarely consists of a single application. A typical stack looks like:
- API backend
- Frontend (SPA or SSR)
- Background worker
- Database
- Redis/cache
On shared hosting, you typically cover the web application, cron jobs, and the database. There’s no room for a permanently running queue worker, your own cache, or a message broker. Those need their own servers, and with them their own management overhead.
3. Deployments Aren’t Reproducible
If your deployment is an FTP upload or a few clicks in a web panel, you’re missing reproducibility. What happens when a deployment fails? How do you roll back? Who deployed what, and when? Many hosts now offer git deployments, which solves the upload but not the declarative state: there’s no deployment history, no rollback in a single command, and no environment you can rebuild from scratch out of a repository.
4. Scaling Hits the Plan Ceiling
Shared hosting shares a server’s resources with other customers. Your site scales within the limits of your plan, but you don’t decide how many instances of a given service run, and you can’t direct load at individual components. A horizontal pod autoscaler that replicates exactly the one overloaded service isn’t something shared hosting provides.
5. Vendor Lock-in Through Proprietary Tools
Many hosts offer custom deployment tools, database panels, and configuration interfaces. Migrating to a different provider often means rebuilding parts of your infrastructure from scratch.
Kubernetes vs. Shared Hosting Compared
Kubernetes solves these problems, but at the cost of complexity:
| Criterion | Shared Hosting | Kubernetes |
|---|---|---|
| Runtimes | PHP, depending on the host also Node.js or Python | Anything that runs in a container |
| Multiple services | Limited (web app + cron jobs) | Yes, unlimited |
| Deployments | FTP / git / web panel | kubectl apply / GitOps |
| Rollbacks | Manual | One command, revision history is kept |
| Scaling | Vertical, within your plan | Horizontal Pod Autoscaler |
| Reproducibility | Low | Complete (Infrastructure as Code) |
| Barrier to entry | Very low | High (without a managed service) |
| Price | €5 to €15/month | From €3/month base fee plus usage (ITSH PAYG) |
Try it: Create a free namespace →
Kubernetes isn’t automatically more expensive than shared hosting. The cost depends on how you run it. Kubernetes gets expensive mainly where you pay for a whole cluster. How that compares with managed Kubernetes from the hyperscalers is worked out in What Does Kubernetes Cost for Small Businesses?
If you’d rather pay a fixed amount, pick a fixed tier. The pricing calculator shows both.
Is a VPS with Docker Enough?
Between shared hosting and Kubernetes, there’s a logical middle step: a VPS with Docker, at ITSH for example a VServer. For many scenarios, that’s enough, and it’s a good way to learn container fundamentals.
# On a VPS: Docker Compose for a simple setup
docker compose up -d
A VServer runs on a single machine, though. If that machine fails, your server is gone until it’s back, and there is no automatic failover. In a paid Kubernetes namespace you run two replicas instead, so your application keeps answering while a node is replaced.
When to Stay on Shared Hosting
Stay on shared hosting if your website is a PHP application or static files, scheduled tasks work fine as cron jobs, and you don’t want to manage servers or containers. A WordPress site, a Laravel project or a company website gains nothing from Kubernetes except work. That’s what ITSH web hosting is for.
When Is Kubernetes Worth It?
Kubernetes is worth it when at least two of these apply:
- You run more than one permanently running service (API + worker + frontend)
- Deployment downtime is unacceptable (rolling updates required)
- You want Infrastructure as Code (reproducible environments)
- Your application needs to scale horizontally (more replicas under load)
- You maintain multiple environments (staging + production)
If only point 1 applies, Docker Compose on a VPS is probably fine.
If you’re unsure, try it: in the free namespace you can run through the whole workflow with a small service before you decide. What fits is in the free tier documentation.
Making the Switch in Practice
What this looks like without a DevOps team of your own is covered in Container Deployment Without a DevOps Team.
Step 1: Containerize Your Application
Each component gets a Dockerfile. A typical Node.js example:
FROM node:24-alpine AS build
WORKDIR /app
COPY package.json yarn.lock ./
RUN yarn install --frozen-lockfile
COPY . .
RUN yarn build
FROM node:24-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY --from=build /app/node_modules ./node_modules
USER 1000
EXPOSE 3000
CMD ["node", "dist/server.js"]
Step 2: Write Kubernetes Manifests
A simple Deployment with a Service. The resource numbers fit a free namespace too. On a paid plan, size them for your application and run two replicas.
apiVersion: apps/v1
kind: Deployment
metadata:
name: api
spec:
replicas: 1
selector:
matchLabels:
app: api
template:
metadata:
labels:
app: api
spec:
containers:
- name: api
image: registry.example.com/api:1.0.0
ports:
- containerPort: 3000
securityContext:
allowPrivilegeEscalation: false
runAsNonRoot: true
seccompProfile:
type: RuntimeDefault
capabilities:
drop: ["ALL"]
resources:
requests:
cpu: 50m
memory: 128Mi
limits:
cpu: 100m
memory: 256Mi
---
apiVersion: v1
kind: Service
metadata:
name: api
spec:
selector:
app: api
ports:
- port: 80
targetPort: 3000
Step 3: Set Up GitOps
On ITSH you switch GitOps on per namespace in the portal, on the Config tab. You enter a Git repository, and every new commit on the tracked branch is rolled out automatically. The repository has to be readable without credentials, so in practice public. Setup is covered under Deploying from Git.
# Check deployment status
kubectl get pods -n my-namespace
kubectl rollout status deployment/api -n my-namespace
Step 4: DNS and TLS
The TLS certificate is issued automatically as soon as your HTTPRoute carries the cert-manager.io/cluster-issuer annotation. A hostname under your namespace’s address works right away. You only need a DNS record for a domain of your own. The complete example with an HTTPRoute is under Your first deployment.
What You Don’t Need
The most common mistake when starting with Kubernetes: trying to do everything at once. You do not need the following on day one:
- Helm Charts: Plain YAML manifests are fine for getting started.
- Service Mesh (Istio/Linkerd): Only relevant with dozens of services.
- Custom Operators: Standard resources cover most use cases.
- Multi-cluster setup: A single namespace is enough for most SMB workloads.
With a managed Kubernetes namespace on ITSH, you also skip all cluster administration: no etcd, no nodes, no ingress controller configuration.
Cost Comparison: Shared Hosting vs. ITSH Namespace
For a typical web application (API + frontend + database):
| Shared Hosting | ITSH Namespace S (€15.00 gross/month) | |
|---|---|---|
| Price | €10/month | €15.00/month |
| Runtimes | PHP, depending on the host also Node.js or Python | Anything that runs in a container |
| Services | Web app + cron jobs | Unlimited |
| Deployments | FTP / git | kubectl apply or GitOps (ArgoCD, switched on in the portal) |
| TLS | Yes | Yes (automatic) |
| Scaling | Vertical, within your plan | Horizontal (HPA) |
| Backups | Daily (DB) | Daily, weekly and monthly for volumes and Kubernetes objects (restore via support); databases need their own backup |
For €5 more per month you get infrastructure that is reproducible, scales horizontally and doesn’t depend on which runtimes a host offers. Storage isn’t part of the fixed tier. PVCs are billed separately. The servers are in Germany, backups are stored in Finland (EU).
The database runs in your namespace through an operator, see Kubernetes databases. How to set up the database, HTTPS and autoscaling for production is covered in the post on Kubernetes in production.
Conclusion
For WordPress, PHP applications and static sites, shared hosting is exactly right. When your project outgrows it, Kubernetes is the next step, and with a managed namespace that step doesn’t have to be expensive or complicated.
You don’t need a DevOps team or a cloud certification. You need a Dockerfile and a few YAML manifests. You’ll have to learn Docker and the Kubernetes basics. Not the cluster.
Try it: Create a free namespace →
Do the math: Cost for your setup in the pricing calculator →
Rather have PHP without the operations? See ITSH web hosting →