Kubernetes consulting and platform architecture

Kubernetes is adopted more often than it is warranted. The first question we ask is whether you need it — and we ask it knowing that the answer no makes the engagement smaller.

Overview

Kubernetes solves a genuine set of problems: scheduling workloads across machines, declarative deployment, self-healing and a consistent interface across environments. Where those problems are present it is an excellent answer.

It also introduces a substantial operating burden. Cluster upgrades, networking, storage, security policy, resource management and observability are all real work, and they are paid continuously by a team that must understand them.

Our position is that many organisations running Kubernetes would be better served by a managed application platform, and that many others genuinely need it and are running it badly. Both statements are worth the same to us, which is what makes them worth reading.

Enterprise use cases

Where we see this used to good effect, and what makes each case a fit.

Many services with independent lifecycles

Estates where a meaningful number of services need to be deployed, scaled and released independently.

Consistent multi-environment deployment

Where the same declarative definitions produce development, test and production, removing a class of environment difference.

Workloads requiring fine-grained scheduling

Batch, mixed workload or resource-constrained estates where bin-packing genuinely improves utilisation.

Hybrid and multi-provider portability

Where a consistent deployment interface across environments is a stated requirement rather than a hoped-for benefit.

Internal developer platforms

As the substrate beneath a paved path that hides Kubernetes from most engineers rather than exposing it to them.

Estates with an existing platform team

Where the operational capability already exists, which changes the calculation substantially.

Architecture

The first architectural decision is cluster topology: how many clusters, and split by what — environment, tenant, region or blast radius. One large cluster is cheaper to run and concentrates risk; many clusters isolate well and multiply operational work.

The second is what the platform hides. Kubernetes exposed directly to every engineer means everyone learns it; a paved path that abstracts it means fewer people need to, at the cost of building and maintaining that abstraction.

  • Cluster count and split decided by blast radius and isolation, not by convention
  • Multi-tenancy model chosen explicitly: namespace, cluster or somewhere between
  • A paved path that hides Kubernetes from most engineers, where team size warrants it
  • Networking and ingress designed before workloads depend on the arrangement

Best practices

The practices that matter most are unglamorous: resource requests and limits set from measurement, health probes that reflect real readiness, and everything applied from version control rather than by hand.

Resource requests deserve emphasis because they are the most consistently wrong setting we encounter. Set too low, workloads are throttled or evicted; set too high, the cluster is expensive and mostly idle — and both are usually present in the same cluster.

  • Requests and limits set from measurement rather than copied between services
  • Liveness and readiness probes distinguished, since confusing them causes restarts
  • All cluster state applied from version control, with drift detected
  • Pod disruption budgets set, so upgrades do not take a service down

Security

Kubernetes defaults are permissive in ways that surprise teams: pods can typically talk to any other pod, service accounts are mounted automatically, and containers frequently run with more privilege than they need.

The controls that matter are network policy, admission control and image provenance. Each closes a category rather than an instance, which is the only kind of control that holds up in a cluster where workloads change continuously.

  • Network policy applied, since the default is that everything can reach everything
  • Admission control enforcing what may run, rather than reviewing afterwards
  • Image provenance and scanning at the cluster boundary
  • Workload identity for cloud access instead of credentials in secrets

Scalability

Kubernetes scales workloads well, and the constraints are usually elsewhere: the database behind the services, cluster-level limits, or autoscaling configured against a signal that does not predict load.

Cluster autoscaling adds nodes on a timescale of minutes, which is fine for gradual growth and inadequate for a sudden spike. Where load arrives abruptly, headroom must be provisioned rather than scaled into.

  • Autoscaling driven by the signal that predicts load, not by CPU by default
  • Node scaling latency understood, since it is minutes rather than seconds
  • Headroom provisioned where load arrives faster than nodes can be added
  • The database assessed as the real constraint before workload scaling is tuned

Performance

Most Kubernetes performance complaints resolve to resource configuration. CPU limits cause throttling that presents as latency rather than as an error, and memory limits cause termination that presents as instability.

Networking is the second area. Service mesh adds latency and considerable operational complexity, and it is frequently adopted for capabilities the estate could obtain more cheaply another way.

  • CPU throttling checked first, since it presents as latency rather than an error
  • Memory limits set from observed usage, because termination presents as instability
  • Service mesh adopted only where its specific capabilities are genuinely required
  • Pod placement and locality considered where cross-zone traffic matters

Integration

The integration that matters most is with the delivery pipeline. Kubernetes is declarative, which makes it a natural fit for definitions held in version control and applied automatically — and a poor fit for manual changes that immediately diverge from the declared state.

The second is with cloud provider services. Workload identity, load balancing, storage and secrets all have provider-specific integrations that are worth using deliberately, at a stated cost in portability.

  • Cluster state applied from version control, with manual changes treated as drift
  • Provider integrations used deliberately, with the portability cost acknowledged
  • Secrets from an external store rather than held as base64 in the cluster
  • Ingress and certificate lifecycle automated rather than managed by hand

Operations

Cluster upgrades are the defining operational task. Versions are supported for a limited period, upgrades cannot be skipped indefinitely, and an estate that falls behind faces a considerably harder catch-up than a routine upgrade would have been.

Observability is the second. A cluster generates a large volume of telemetry and unconsidered retention is expensive, so what is kept and for how long is worth deciding rather than defaulting.

  • Upgrade cadence owned and scheduled, because falling behind compounds
  • Telemetry retention decided against investigation need and cost
  • Alerting on workload health rather than on cluster resource metrics
  • Disaster recovery rehearsed, including what a cluster rebuild actually requires

Governance

Governance works best as admission control: policy that prevents a non-compliant workload from running is worth far more than a report identifying it afterwards, and it costs nobody time per deployment.

Cost governance needs equal attention. Namespace-level cost attribution and resource quotas make consumption visible and bounded, and without them a cluster's cost is a single number nobody owns.

  • Admission control preventing non-compliant workloads rather than reporting them
  • Resource quotas per namespace, so one workload cannot consume the cluster
  • Cost attributed per namespace or team rather than reported as one figure
  • An exception path faster to follow than to work around

Frequently asked questions

By checking whether its problems are your problems: a meaningful number of services with independent release cycles, workloads that genuinely benefit from fine-grained scheduling, or a stated requirement for consistent deployment across environments. If none of those describe you, a managed application platform will serve better at a fraction of the operating burden.

We ask this first, knowing that the answer no makes the engagement smaller.

Decided by blast radius and isolation rather than by convention. One large cluster is cheaper to operate and concentrates risk; many clusters isolate well and multiply operational work. Environment separation is usually the minimum justified split.

Preferably not, above a certain team size. A paved path that abstracts it means fewer people need to understand it, at the cost of building and maintaining that abstraction. Below that size the abstraction costs more than it saves.

Usually memory limits set too low, or liveness and readiness probes confused — a liveness probe that fails during slow startup restarts the pod repeatedly. Both are configuration rather than platform problems, and both are extremely common.

Resource requests set too high, typically copied between services rather than measured. Requests reserve capacity whether or not it is used, so an over-requested cluster is both expensive and underutilised — frequently alongside other workloads that are throttled because theirs are too low.

Usually not. A mesh provides real capabilities — mutual TLS, traffic shaping, detailed telemetry — at substantial operational complexity and some latency. Most estates adopting one could obtain the specific capability they wanted more cheaply, and it is worth naming that capability before deciding.

On a scheduled cadence with an owner. Versions are supported for a limited period and upgrades cannot be skipped indefinitely, so falling behind compounds until catch-up is a project. Pod disruption budgets and readiness probes are what make an upgrade routine rather than an outage.

No, and its defaults surprise teams. Pods can typically reach any other pod, service accounts mount automatically, and containers frequently run with more privilege than needed. Network policy, admission control and image provenance are the controls that close categories rather than instances.

Technically yes, and the portability is smaller than it appears. Identity, networking, storage and load balancing all differ, so the workload definitions port and the platform beneath them largely does not. Multi-provider is a legitimate choice for a stated reason, not a free benefit of adopting Kubernetes.

Almost always, if you have concluded you need Kubernetes at all. Operating the control plane yourself is work with very little differentiating value, and the managed offerings remove a meaningful share of the upgrade burden that causes estates to fall behind.

A team that owns it, with the capability to do so. Kubernetes without an owner degrades quietly — upgrades slip, policy drifts, cost grows — and the organisations that struggle most are the ones that adopted it without deciding who would run it.

Next step

Discuss a Kubernetes platform

A free first consultation covering your workloads, whether Kubernetes is warranted for them, and — if it is — what the operating model around it needs to look like.

No cost, no obligation. Pricing is transparent and includes GST.