Many services with independent lifecycles
Estates where a meaningful number of services need to be deployed, scaled and released independently.
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.
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.
Where we see this used to good effect, and what makes each case a fit.
Estates where a meaningful number of services need to be deployed, scaled and released independently.
Where the same declarative definitions produce development, test and production, removing a class of environment difference.
Batch, mixed workload or resource-constrained estates where bin-packing genuinely improves utilisation.
Where a consistent deployment interface across environments is a stated requirement rather than a hoped-for benefit.
As the substrate beneath a paved path that hides Kubernetes from most engineers rather than exposing it to them.
Where the operational capability already exists, which changes the calculation substantially.
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.
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.
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.
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.
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.
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 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.
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.
Sectors where this comes up most often, and the constraint that puts it there.
OSS/BSS complexity, network-scale data volumes and availability expectations measured in minutes per year.
IndustryTraffic that is seasonal rather than steady, omnichannel inventory accuracy, and catalogue scale.
IndustryCore system modernisation, real-time payment flows, and architecture that can evidence regulatory controls.
IndustryReal-time tracking, partner system integration, and routing systems where latency has a direct cost.
IndustryGrid and asset telemetry, regulatory reporting, and operational systems that cannot tolerate an outage window.
IndustryInteroperability between clinical systems, patient data privacy, and legacy platforms that cannot be taken offline.
The engagements this work is usually delivered within.
Delivery pipelines, infrastructure as code, Kubernetes and the observability practices that make releases routine.
Migration strategy, landing-zone design, cost modelling and the architecture decisions that determine whether cloud spend buys capability.
Target-state design, modernisation roadmaps, integration and cloud architecture, and the governance that keeps decisions consistent after the consultants leave.
Security architecture, assessment and compliance advisory, designed in rather than reviewed afterwards.
Application support, infrastructure management and incident response under defined service levels.
Custom application, web, mobile and API development, and modernisation of systems that are constraining the business.
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.
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.