Back to blog

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:

  1. You run more than one permanently running service (API + worker + frontend)
  2. Deployment downtime is unacceptable (rolling updates required)
  3. You want Infrastructure as Code (reproducible environments)
  4. Your application needs to scale horizontally (more replicas under load)
  5. 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 →