Back

Kubernetes & Container Platform Engineering Services

Paired bar chart of five percentage measures before and after a Kubernetes platform build: node utilisation rises from 22 to 68 per cent, self-service deploys from 18 to 86 per cent, workloads running on a golden path from 11 to 79 per cent, while change failure rate falls from 24 to 9 per cent and environments drifting from committed code fall from 61 to 12 per cent
Figure 1. Platform and delivery measures before and after a Kubernetes platform build, all expressed as a share of measured activity. Node utilisation rises from 22 to 68 per cent, self-service deploys from 18 to 86 per cent and workloads running on a golden path from 11 to 79 per cent, while change failure rate falls from 24 to 9 per cent and environments drifting from committed code fall from 61 to 12 per cent. The two falling measures are the reason the rising ones can be trusted.
Chart values are an illustrative planning model based on typical UMC engagements and published industry benchmarks. They are not a guarantee of results on any specific project.

Most organisations do not have a Kubernetes problem. They have twelve clusters built by four vendors, no golden path, no cost owner and a platform team that spends its week answering tickets instead of building. Containers arrived; the engineering discipline that makes them cheap did not.

Kubernetes and container platform engineering at Unified Management Consulting is the work of turning a container runtime into a platform that product teams can use without asking anyone for permission. That means a landing zone with accounts and networking designed rather than accumulated, clusters with a documented baseline, golden paths that make the correct deployment the easy deployment, a pipeline that produces signed images, observability wired in before the first workload arrives, and cost controls that are enforced by quota rather than argued about in a monthly meeting.

We build platforms on managed Kubernetes — EKS, AKS, GKE — and on self-managed clusters where a data centre, a regulation or an existing investment makes that the right answer. We are equally willing to tell you that Kubernetes is the wrong tool for the workload in front of us: a single Laravel application with steady traffic is usually cheaper and safer on a managed compute service, and the honest recommendation is the one that saves you a platform you will never have the headcount to run. Where the estate is a mix, we design the mix, and we write down which workloads belong where and why.

🐳 Kubernetes & Container Platform Engineering — Quick Summary

Component What We Deliver
Landing zone and account design Cloud accounts or subscriptions, network topology, identity federation, billing structure and guardrails designed as one artefact, reproducible from code, with the reasoning recorded.
Cluster baseline and node pools A documented cluster standard: version policy, node pools by workload class, autoscaling limits, upgrade cadence, backup of cluster state and a tested restore.
Golden paths and service template One supported way to deploy a service — repository template, pipeline, deployment manifest pattern, health checks, resource requests, logging and tracing — that teams adopt because it is faster than doing it themselves.
CI/CD to image registry Build, test, scan, sign and publish images; progressive delivery with automatic rollback; review environments per pull request; deployment lead time measured rather than estimated.
Policy, network and pod security Admission policy as code, network segmentation, pod security standards, secret management, image provenance and least-privilege identity for every workload.
Observability and alert routing Metrics, logs and traces with retention tiers, service-level objectives, dashboards per critical journey and alerts that page a human only when a human can act.
Workload onboarding and migration waves Assessment of each application for state, dependencies, licensing and change frequency, then sequenced waves with a rollback path per workload.
Multi-tenancy and namespace design Tenant isolation by namespace, node pool or cluster, decided against the real risk profile and the cost of each option, with quotas attached.
Cost controls, quotas and rightsizing Namespace budgets, request-to-usage reconciliation, spot and reserved capacity strategy, and a monthly cost report that names an owner per line.
Reliability engineering and load testing Load and soak tests before a wave lands, failure injection in staging, and a rehearsed incident path for the platform itself.
Runbooks, handover and enablement Operating documentation, named runbooks per failure mode, developer onboarding sessions and a supportability verdict on the platform we leave behind.
Ongoing platform operation Optional retainer covering upgrades, patching, capacity review, cost review and incident support with measured service levels.

What This Service Actually Covers

A container platform is not one deliverable but a set of engineering decisions that stop being cheap to change once workloads depend on them. The table below is the scope we agree at the start of an engagement, with the artefact each item produces. Anything without an artefact is an opinion, and opinions do not survive a change of platform engineer.

Scope item The decision it settles Artefact you keep
Landing zone How accounts, networks, identity and billing are separated so that one compromised workload cannot reach the whole estate Terraform or Bicep modules, a network diagram, and a written rationale per boundary
Cluster baseline Which cluster flavour, version policy, node pool shape and upgrade cadence the estate runs on A cluster standard document plus the code that builds a conforming cluster in an afternoon
Golden path How a team deploys a service without opening a ticket Repository template, pipeline definition, deployment pattern, and an onboarding guide
Admission policy What is refused automatically, without a review meeting Policy as code in version control, with the exceptions register alongside it
Observability What is measured, retained for how long, and who is paged Signal inventory, SLO definitions, dashboard set and alert routing rules
Cost governance Who owns which spend and what happens when a budget is exceeded Namespace budgets, tagging standard, and a monthly report with named owners
Workload onboarding Which applications move, in what order, with what rollback Assessment sheet per workload and a wave plan with entry and exit criteria
Operation and handover Who runs this in month thirteen and what they need to do it Runbooks, escalation paths, training record and a supportability verdict

We treat the artefacts as the deliverable. A cluster that exists but cannot be rebuilt from code is a liability with a monthly invoice attached, and we have been called in to rescue several.

When Kubernetes Is the Right Answer — and When It Is Not

Kubernetes is a scheduling and lifecycle system for many small, frequently changing, independently deployable units of work. It earns its complexity when you have those units. It does not earn it when you have three applications and a release every quarter. The table below is the assessment we run before recommending anything, and it is the same assessment we would run against our own proposal.

Situation Why Kubernetes fits Why it may not What we recommend
A portfolio of ten or more services with independent release cycles Uniform deployment, scaling and observability across services; one operating model instead of ten If the services are not independently deployable in practice, the platform will not make them so Platform build with golden paths, sequenced onboarding waves, and a service ownership model agreed first
Spiky or seasonal traffic where capacity must follow demand Horizontal autoscaling reacts in seconds and releases capacity again, which fixed VM capacity cannot do If the spike is predictable and daily, scheduled scaling on managed compute may be simpler and cheaper Autoscaling with tested limits, plus load testing that proves behaviour at the real peak
Polyglot engineering with Java, Node, Python and .NET services One runtime contract for every language: image, health check, resources, logs Where one language dominates, a platform-native service for that language may need less machinery Golden paths per language family, with a single pipeline and observability contract
AI and batch workloads needing GPUs on shared infrastructure Scheduling, queueing and node affinity for expensive accelerators, with fair sharing between teams GPU supply and cost are usually the constraint, not the scheduler Container platform with GPU node pools and quotas, assessed alongside the capacity economics of AI infrastructure
One or two monolithic applications with modest change frequency Rarely: the operational overhead exceeds the benefit You acquire a distributed systems problem to solve a deployment problem you did not have Managed compute or containers without orchestration, revisited when the portfolio grows
Heavily stateful workloads: databases, message brokers, ERP Possible, with operators and disciplined storage engineering Managed services usually beat self-operated state on cost, resilience and staffing Stateless tiers on the platform; state on managed services, with backup and restore verified — see Backup & Disaster Recovery
A regulated estate requiring data residency and audit evidence Policy as code produces consistent, inspectable evidence of control Residency and certification obligations sit with the cloud account design, not the cluster Landing zone designed around the obligation first, then the platform inside it
Stacked bar chart of the workload estate by runtime across four quarters: legacy VM monoliths fall from 64 to 21 per cent, containerised but unorchestrated workloads hold between 12 and 19 per cent, workloads running on Kubernetes rise from 11 to 54 per cent, and managed serverless rises from 7 to 13 per cent
Figure 2. A workload estate by runtime across four quarters of platform adoption. Legacy VM monoliths fall from 64 to 21 per cent of the estate while workloads running on Kubernetes rise from 11 to 54 per cent; containerised but unorchestrated workloads hold between 12 and 19 per cent and managed serverless rises from 7 to 13 per cent. The shape matters more than the speed: the middle column staying flat is what a programme with no golden path looks like.
Chart values are an illustrative planning model based on typical UMC engagements and published industry benchmarks. They are not a guarantee of results on any specific project.

Figure 2 is a composite of programmes we have run, not a promise. The realistic question is not how fast you move but whether the middle category shrinks. Estates fail when workloads are containerised and then left on hand-managed hosts, which gives you the packaging benefit and none of the scheduling, scaling or self-healing benefits — and twice the operational surface.

The Platform We Build: From Landing Zone to Golden Path

Every layer below is built in code, reviewed like application code, and tested by rebuilding it. The ordering is deliberate: identity and network boundaries before clusters, clusters before workloads, observability and policy before the first team onboards. Reversing that order is how platforms end up with ten exceptions in their first quarter.

Layer What we build How it is verified
Identity and access Federation to your directory, role definitions for platform admin, service owner and auditor, break-glass procedure, no long-lived access keys Access review against the role matrix; a test that the auditor role can read and not write
Network and boundaries VPC or VNet design, private subnets, egress control, private endpoints for registry and data services, DNS split for internal names Connectivity tests from inside and outside the boundary, recorded as evidence
Cluster control plane Managed or self-hosted control plane with a version policy, private API endpoint, audit logging enabled from day one A conforming cluster rebuilt from code in a clean account, timed and recorded
Node pools Pools by workload class: general, memory-heavy, GPU, spot-tolerant; taints and tolerations documented; autoscaling min and max justified by cost and resilience Scale-up and scale-down behaviour exercised under load; eviction and drain tested
Workload runtime contract Image format, health and readiness probes, resource requests and limits, graceful shutdown, configuration injection, log format, trace headers A reference service deployed to the golden path passing every contract check
Golden path pipeline Repository template, build and test, image scan and signing, deploy to review environment, progressive rollout with automatic rollback A deliberately broken release is deployed and observed to roll back without human action
Policy and admission control Allowed registries, required labels, forbidden privileged containers, namespace quotas, network policy defaults Each policy proven by attempting the forbidden thing and recording the refusal
Observability stack Metrics collection, log pipeline with retention tiers, distributed tracing, dashboards, alert routing to the owning team An injected fault appears in the dashboard and pages the right team within the SLO window
Cost and quota controls Namespace resource quotas, budget alerts, tagging standard, reservation and spot strategy A quota breach is refused and an owner is notified before the bill arrives
  • Every layer is in version control with a named reviewer — infrastructure changes are pull requests, not console sessions.
  • The platform is rebuilt from code at least once per programme to prove that the code, not the console history, is the source of truth.
  • Exceptions are recorded in a register with an expiry date, because an undocumented exception becomes the standard within two quarters.
  • The golden path is measured on adoption, not on existence: a path nobody uses is a document.

Workload Assessment and Migration Waves

Workloads are assessed individually and then sequenced. The first wave is chosen for learning value and low blast radius, not for importance; the second wave is chosen to prove that the golden path handles a harder case. By the third wave the platform team should be reviewing rather than building.

Assessment dimension What we look for Effect on the wave plan
State and storage Local disk writes, database co-location, file shares, session state in memory Stateful workloads move last or stay on managed services; session state must be externalised first
Dependencies Hard-coded hostnames, on-premises calls, licensed middleware, vendor appliances Dependencies are mapped before the workload is scheduled, and network paths tested
Licensing Per-core or per-socket licensing, licence servers, vendor support for virtualised or containerised deployment A licensing constraint can make a technically easy workload commercially impossible
Change frequency Releases per month, hotfix rate, number of teams touching the code High change frequency earns the most from the platform and justifies an early wave
Criticality and rollback Business impact of an outage, whether the old path can be reinstated quickly Critical workloads need a proven rollback before cutover, not after the first incident
Team readiness Whether the owning team can read a dashboard, interpret a log and deploy a change Readiness gaps are closed with enablement sessions before the wave, not during an incident
Performance profile Latency budget, throughput peaks, batch windows, memory behaviour Drives resource requests, node pool choice and the load test we run before cutover

Each wave has entry and exit criteria written down before it starts. Entry criteria are usually a passing load test and a rehearsed rollback. Exit criteria are a period of stable operation against an agreed error budget, with the runbook written by the people who will use it. Waves that cannot state their exit criteria are waves that will not end.

Cluster Architecture Decisions That Actually Matter

These are the decisions we expect to defend in an architecture review, with the reasoning we bring. Most are reversible for a while and then not reversible at all, which is exactly when they should be argued about.

Decision Options How we choose
Managed versus self-managed control plane EKS, AKS, GKE; self-managed kubeadm or a distribution on your own infrastructure Managed unless residency, licensing, existing hardware or an air-gapped requirement says otherwise. The control plane is undifferentiated heavy lifting for almost everyone
One large cluster versus many small ones Single multi-tenant cluster; cluster per environment; cluster per business unit; cluster per criticality tier Fewer clusters than instinct suggests. Isolation by namespace and policy is sufficient for most tenancy; separate clusters are for separate upgrade risk, regulatory boundaries or blast-radius limits
Node pool strategy One general pool; pools by workload class; GPU pools; spot pools Pools by cost and interruption tolerance, with spot for stateless and batch work only, and a documented fallback when spot capacity is unavailable
Networking model Cloud-native CNI with pod IPs; overlay network; service mesh sidecars; mesh-free service discovery Start without a mesh. Add one only when mTLS, traffic splitting or cross-cluster routing is a requirement you can name, because a mesh is a permanent operational cost
Ingress and traffic management Cloud load balancer per service; shared ingress controller; gateway API; CDN in front Shared ingress with host-based routing for internal services, dedicated load balancers only where a client contract or a latency budget requires it
Storage classes Block storage, file shares, object storage, ephemeral local disk Object storage for artefacts and backups, block for databases that must run in-cluster, and a hard rule against persistent local disk for stateful services
Secrets management Kubernetes secrets with encryption at rest; external vault; cloud secret manager with a CSI driver External manager wherever possible. Kubernetes secrets are a distribution mechanism, not a secrets store, and the distinction matters in an audit
Upgrade cadence Follow the provider within one minor version; stay two versions behind; upgrade on a fixed quarterly cycle One minor version behind at most, on a fixed cycle with a rehearsed upgrade in staging first. Version lag is how clusters end up un-upgradeable
Multi-region and disaster recovery Active-passive, active-active, backup-and-restore only Decided by the recovery objective you can pay for, not by ambition. Most estates need a tested restore and a documented rebuild, not active-active

Where the estate already includes on-premises servers and network infrastructure, the platform design has to reconcile with it rather than ignore it: Computing, Server, Storage & Data Centre Engineering and Routing, Switching, Firewall & Network Engineering are the practices we plan hybrid connectivity, latency budgets and firewall rules with.

CI/CD: From Commit to Production Without a Human in the Path

The pipeline is the platform’s front door. If deployment requires a ticket, the platform will be bypassed within a quarter and you will end up with containers deployed by hand onto nodes nobody documents. Every stage below has a gate, and every gate either passes automatically or fails loudly.

Pipeline stage Gate applied What failure looks like
Commit and branch protection Review required, signed commits, no direct pushes to protected branches A change reaches production that no second person has read
Build and unit test Tests pass, coverage floor enforced, build reproducible from a clean cache A green build that cannot be rebuilt, which is a build you cannot trust in an incident
Image build and scan Base image pinned and current, critical and high vulnerabilities blocked, licence scan clean An image with a known critical flaw deployed because the scan was advisory rather than enforced
Sign and publish Image signed, published to an allowed registry only, digest recorded against the commit An unsigned image running in production with no way to prove what it contains
Deploy to review environment Ephemeral environment per pull request, seeded with masked data, reachable by the reviewer Review by description rather than by behaviour, which is how interface breaks ship
Progressive delivery Canary or blue-green step with automatic health comparison and automatic rollback A full-fleet deployment of a change that was never observed at partial traffic
Post-deploy verification Synthetic checks against the critical journeys, SLO burn check, error budget gate A deployment declared successful because the pods started, not because the service works
Audit trail Every promotion recorded with actor, artefact digest and approval evidence An audit finding you cannot answer, which costs more than the pipeline that prevents it

Deployment lead time and change failure rate are reported every month from pipeline data. They are the two numbers that tell you whether a platform is real, and they are the two numbers most platform programmes never measure.

Security, Policy and Multi-Tenancy

Container security is mostly ordinary security enforced in a new place: identity, least privilege, patching, network segmentation and evidence. What changes is that enforcement can be automatic, which means the platform can be more consistent than a team of administrators ever could be — provided the policies are written down and the exceptions are registered.

Control area What we implement Evidence produced
Workload identity Federated identity per workload, no embedded credentials, short-lived tokens, service account separation per namespace An identity inventory mapping each workload to its permissions
Pod security Restricted pod security standard, read-only root filesystem, no privilege escalation, seccomp profiles, capability drops Admission policy in version control plus a refusal log per attempted violation
Image provenance Allowed registries only, signature verification at admission, base image inventory with patch status A bill of materials per running image, retrievable at audit time
Network segmentation Default-deny network policy per namespace, explicit allow rules, private endpoints for data services, egress restrictions Connectivity test results showing what is reachable and what is not
Secrets External secret manager, rotation policy, no secrets in environment variables where avoidable, audit of secret reads Rotation record and a list of every consumer of each secret
Tenant isolation Isolation level chosen per tenant risk: namespace with quota, dedicated node pool, or dedicated cluster A tenancy decision record naming the risk that drove each choice
Audit and detection Cluster audit logging to a tamper-evident store, alerting on privileged pod creation and policy overrides Alert history with response times, reviewed monthly
Vulnerability management Continuous scanning of images, nodes and configuration, with remediation service levels by severity A patching report that shows age of the oldest unpatched critical finding

Posture across the whole cloud estate — not only the cluster — is the subject of our cloud security practice, and the two are designed together: Cybersecurity Services & Solutions covers the wider control set, incident response and testing, while IT Audit & Compliance (ISO, SOC 2) covers the certification the platform will eventually have to satisfy.

Observability on the Platform

A platform without observability is a black box with a scheduler inside it. We instrument before the first production workload, because retrofitting tracing into forty services is a project and instrumenting one golden path is an afternoon.

Signal What is collected Retention and cost discipline
Metrics Node, cluster, workload and business metrics; request rate, error rate and latency histograms per service High resolution for fourteen days, downsampled aggregates for a year, business metrics kept longest because they are the cheapest per insight
Logs Structured logs from every workload with trace and request identifiers, cluster audit logs, ingress access logs Hot for thirty days, cold archive for the compliance period, and a rule against logging request bodies by default
Traces Distributed traces across services and queues, sampled adaptively with full capture on errors Tail-based sampling so that error traces are never dropped to save storage
Service-level objectives One availability and one latency objective per user-facing service, with an error budget and a burn-rate alert Reviewed monthly; an objective nobody looks at is deleted rather than kept for appearance
Dashboards One per critical journey, one per service, one for the platform itself; no dashboard without an owner Quarterly review to retire dashboards nobody opens
Alerts Symptom-based paging for user-facing impact, cause-based ticketing for everything else Every page is reviewed: if it did not need a human, it becomes a ticket or is deleted

Alert design is the part teams get wrong most often, and it is cheap to fix early: paging on CPU utilisation produces fatigue, paging on error budget burn produces action. The full practice — SLOs, on-call, incident command and post-incident review — is what our site reliability work covers, and platform observability is built to feed it.

Cost Controls, Quotas and Rightsizing

Kubernetes makes it easy to consume capacity and easy to lose track of who is consuming it. Cost governance is therefore a platform feature, not a finance exercise. The controls below are implemented in the platform itself so that overspend is prevented rather than reported.

Cost lever Typical effect What it requires
Right-sized requests and limits The largest single saving on most estates: clusters commonly run at 15 to 25 per cent utilisation before this work, and 55 to 70 per cent after Usage telemetry per workload, a review cadence, and a rule that requests are set from measured usage rather than guessed
Namespace budgets and quotas Prevents one team from consuming the headroom another team is relying on An agreed allocation model and a process for requesting an increase
Spot and reserved capacity mix Spot for stateless and batch workloads typically cuts compute cost by 50 to 70 per cent on that portion; reservations cover the steady baseline Interruption handling in the workload, and a fallback pool when spot capacity is unavailable
Node pool autoscaling limits Stops a runaway workload from scaling the cluster without limit Maximum node counts justified by budget rather than by fear
Storage and snapshot policy Orphaned volumes and unbounded snapshots are the most common invisible spend Lifecycle rules and a monthly orphan report with a named owner per item
Data transfer discipline Cross-zone and cross-region traffic is frequently the second largest line after compute Topology-aware routing and a review of anything that leaves the region
Cost allocation and reporting Turns a single invoice into per-service and per-team cost, which is what makes the other levers stick A tagging standard enforced at admission, and a report that names an owner per line

Cost optimisation across the whole cloud estate, including commitment strategy, unit economics and the governance forum that keeps it honest, is delivered as a separate practice: Cloud Cost Optimisation & FinOps Services. Platform quotas and FinOps reporting are designed together so the numbers agree.

The Fourteen-Week Programme

Gantt chart of a fourteen-week Kubernetes and container platform programme: landing zone and account design in weeks one and two, cluster baseline and node pools in weeks three and four, golden paths and service template from week four to six, CI/CD to image registry from week six to eight, observability and alert routing from week eight to ten, policy network and pod security from week nine to eleven, the first workload wave and load tests in weeks eleven and twelve, cost controls and quotas in weeks twelve and thirteen, and runbooks with platform handover in weeks thirteen and fourteen
Figure 3. The fourteen-week Kubernetes and container platform programme we run when building a platform from a landing zone. Weeks overlap deliberately: observability starts before the first workload lands, and cost controls arrive before the second wave rather than after the first invoice surprises anyone.
Chart values are an illustrative planning model based on typical UMC engagements and published industry benchmarks. They are not a guarantee of results on any specific project.
Weeks Workstream Decision gate at the end
1–2 Landing zone and account design: identity federation, network topology, billing structure, guardrail policies The landing zone is rebuilt from code in a clean account and the rebuild time is recorded
3–4 Cluster baseline and node pools: version policy, pool shapes, autoscaling limits, upgrade procedure A conforming cluster is built, drained and rebuilt with no manual console steps
4–6 Golden paths and service template: repository template, runtime contract, reference service The reference service deploys through the golden path and passes every contract check
6–8 CI/CD to image registry: build, test, scan, sign, publish, progressive delivery A deliberately broken release rolls back automatically, observed and recorded
8–10 Observability and alert routing: metrics, logs, traces, SLOs, dashboards, paging policy An injected fault appears on the journey dashboard and pages the owning team inside the SLO window
9–11 Policy, network and pod security: admission policy, default-deny networking, secrets integration Each policy is proven by an attempted violation and the refusal is logged
11–12 First workload wave and load tests: two to four services onboarded, load and soak testing, rollback rehearsal The wave runs for an agreed soak period with the error budget intact
12–13 Cost controls and quotas: namespace budgets, tagging, reservation and spot strategy, first cost report A quota breach is refused and the owning team is notified before any overspend
13–14 Runbooks and platform handover: operating documentation, enablement sessions, supportability verdict Your engineers execute a runbook unaided and the verdict is signed off

Programmes that run longer than fourteen weeks for a first platform are usually waiting on something other than engineering: an unfrozen account structure, an undecided service ownership model, or a procurement cycle for a managed service. We surface those dependencies in week one so they are managed as decisions rather than discovered as delays.

What We Measure and Report

Every monthly report contains the same twelve measures. They are chosen because each one can be extracted from the platform rather than assembled from opinion, and because each one moves when the work is real.

Measure How it is captured What good looks like after two quarters
Deployment frequency Pipeline events per service Multiple deployments per week for active services, with no scheduled release window
Deployment lead time Commit timestamp to production timestamp Under a day for the median change, with the tail explained rather than hidden
Change failure rate Deployments requiring rollback or hotfix, over all deployments Under 10 per cent, and falling as progressive delivery matures
Mean time to restore Incident start to service restored, from the incident record Under two hours for platform incidents, with the trend visible month on month
Node utilisation Requested versus used CPU and memory across pools 55 to 70 per cent, high enough to be efficient and low enough to absorb a node failure
Golden path adoption Services deployed through the template, over all services Above 80 per cent, with named exceptions and expiry dates for the rest
Policy violations refused Admission controller refusals per month A falling count, with each refusal traced to a team conversation rather than a workaround
Open critical findings Image, node and configuration scanning Zero older than the agreed remediation window
Error budget burn SLO attainment per user-facing service Budget remaining at month end for every service, and a release freeze when it is not
Cost per workload Allocation report from the tagging standard A named owner per line and a month-on-month movement that can be explained
Spot interruption impact Interruptions per week against failed requests Interruptions occurring with no user-visible impact
Platform tickets Requests raised to the platform team by type A falling count of ‘how do I’ tickets, which is the adoption signal that matters

The report is written for a chief technology officer and a finance lead at the same time. If it cannot be read by both, it is an engineering diary rather than a management instrument, and we treat that as a defect.

Team, Skills and Handover

A platform is a product with customers, and it needs an owner. We build the platform alongside your engineers rather than in front of them, because the version of this that fails is a delivered cluster with nobody who understands why it is shaped the way it is.

Role Responsibility in the programme Who usually holds it
Platform lead Owns the platform roadmap, the golden path and the exception register Your engineering manager, supported by us until the handover
Platform engineers Build and operate the layers: cluster, networking, pipeline, observability, policy A joint team; typically two of your engineers paired with ours
Service owners Own one or more workloads on the platform, including their SLOs and on-call Your application teams, named before their workload is onboarded
Security reviewer Approves policy changes, reviews exceptions, owns the audit evidence Your security lead or our cybersecurity practice where there is no internal function
Cost owner Owns the allocation model, the budget and the monthly cost review A finance or technology leader; the role must be named, not shared
SRE or on-call engineer Owns incident response for the platform and the escalation path Rotated across your engineers with our support through the first two incidents
  • Pairing over shadowing: your engineers write the Terraform and the pipeline with us, in your repositories, from week two.
  • Enablement sessions at each gate rather than a training day at the end, so learning lands while it is useful.
  • Runbooks written by the person who will use them, reviewed by us, and exercised in a game day before handover.
  • Where you need capacity rather than a programme, named engineers are supplied through IT Staff Augmentation Services working to your prioritisation.
  • A supportability verdict at handover stating plainly what your team can run alone and what still needs external cover — see also Managed IT Infrastructure & AMC for the operating model.

Failure Modes We Are Usually Called In To Fix

These are the patterns we find in inherited platforms. They are almost never caused by a lack of Kubernetes knowledge; they are caused by a platform built to demonstrate Kubernetes rather than to serve the teams using it.

Failure mode How it presents What we do about it
Cluster sprawl Eight or more clusters from different vendors, no shared standard, nobody able to say which workloads run where An estate inventory, a target cluster count with a written rationale, and consolidation in waves
No golden path Every team deploys differently; the platform team is a ticket queue; onboarding takes weeks A reference service and a repository template, then migration of teams onto it with support
Requests guessed, not measured Utilisation in the teens, nodes added to fix latency, cost rising with no visible cause Rightsizing from telemetry, quota enforcement, and a cost report with owners
Everything is privileged Containers running as root with host mounts because a vendor image demanded it, and the exception was never registered Policy as code, a documented exception register with expiry dates, and vendor pressure applied where an image cannot be hardened
Alert fatigue Hundreds of pages a month, most ignored; the real incident is missed inside the noise Symptom-based paging, error budget alerts, and a review of every page for a month
No rollback Deployments are forward-only; a bad release is fixed by a hotfix under pressure Progressive delivery with automatic rollback, rehearsed before it is needed
Un-upgradeable cluster Three or four minor versions behind, deprecated APIs in use, upgrade blocked by a workload An API deprecation audit, workload remediation, then a staged upgrade path with a rehearsal
Platform as a person One engineer holds the whole design; leave becomes an operational risk Documentation as code, pairing, and a handover test where another engineer performs a change unaided

Where the platform is sound and the problem is the application running on it, we say so and refer the work: Website Migration & Replatforming for content platforms, PHP / Laravel Development and Headless & Composable Commerce for application estates, and Web Application Maintenance & Support for the retainer that keeps them current.

Evidence From Our Work

The engagements below are published case studies and insight from this practice, each described by the subject its own page documents. They are listed because a platform decision is usually made by analogy with an estate somebody has already run.

Engagement Models and Commercials

Three shapes cover almost every platform engagement. We recommend one after the assessment, and we will recommend the smallest one that solves the problem you actually have.

Model Best when Duration and structure What you receive
Platform assessment You have clusters already and need an independent verdict before spending more Two to four weeks, fixed fee Estate inventory, architecture review, cost and utilisation analysis, security and policy review, a prioritised remediation plan with effort estimates
Platform build You need a platform designed and built, with your engineers trained into it Twelve to sixteen weeks, staged with decision gates Landing zone, cluster baseline, golden path, pipeline, observability, policy, cost controls, runbooks and a signed supportability verdict
Platform operation retainer The platform exists and needs upgrades, capacity management, cost review and incident cover Monthly, three-month minimum, with measured service levels Upgrade and patch management, capacity and cost review, on-call support, quarterly architecture review and a monthly measure report
Workload onboarding wave The platform exists but applications have not moved onto it Four to eight weeks per wave of two to five workloads Assessment per workload, remediation plan, load testing, cutover with rollback, and post-wave stability report

Assessments are fixed fee and are the entry point we recommend, because a platform build quoted against an unexamined estate is a guess with a contingency attached. Where the assessment concludes that Kubernetes is not the right answer for your workloads, you receive that conclusion in writing with the alternative costed — and we have written it more than once.

Frequently Asked Questions About Kubernetes & Container Platform Engineering

Do we need Kubernetes at all?

Only if you have enough independently deployable workloads to justify a scheduling system, or a scaling profile that fixed capacity cannot serve economically. For two or three applications with quarterly releases, managed compute is cheaper and safer, and we will say so in writing. The test is the number of services, their release frequency and their scaling behaviour — not whether the technology is current.

How many clusters should we run?

Fewer than instinct suggests. One production cluster plus one non-production cluster covers most estates, with tenancy handled by namespace, policy and quota. Separate clusters are justified by a regulatory boundary, a different upgrade risk profile, or a blast-radius limit you can name. Every additional cluster is a permanent upgrade, patching and monitoring obligation.

Managed Kubernetes or self-managed?

Managed — EKS, AKS or GKE — unless data residency, licensing, existing hardware or an air-gapped environment requires otherwise. Operating a control plane is undifferentiated work for almost every organisation, and the upgrades are the part that consumes a team.

What does a platform build cost?

A two to four week assessment is a fixed fee. A platform build runs twelve to sixteen weeks with a joint team and is quoted after the assessment, because the scope depends on how many golden paths, how much policy and how many workload waves you need. We do not quote a build against an unexamined estate; that quote would be padded for unknowns and would cost you more overall.

How long until the first workload is in production?

Weeks eleven or twelve in the fourteen-week programme, after the pipeline, observability and policy are in place. Deploying a workload in week three is possible and is usually how the platform acquires its first unregistered exception.

Can you work with the platform our vendor built?

Yes, and the assessment is designed for exactly that. We inventory what exists, test whether it can be rebuilt from code, review the policies and exceptions, and produce a remediation plan. Where the platform is sound we work within it; where it is a set of hand-built clusters we recommend consolidation with a costed path.

Who operates the platform afterwards?

Your team, with our support through the first two incidents and an optional retainer after that. The handover includes a test: one of your engineers performs a cluster upgrade and executes a runbook unaided. If they cannot, the handover has not happened, whatever the documentation says.

How do you handle GPU and AI workloads?

With dedicated node pools, scheduling constraints, quotas per team and an honest conversation about capacity supply. Accelerator scarcity and cost usually dominate the design; the scheduler is rarely the constraint. We assess this alongside AI Readiness Assessment & Roadmap and Data Engineering for AI, RAG & Knowledge Systems so the platform matches the workload plan.

What about our on-premises servers?

They stay until there is a reason to move them, and some never move. Hybrid connectivity, latency budgets, firewall rules and backup are designed with our network engineering practice and our data centre engineering practice, and the platform is built to talk to them rather than around them.

How is security enforced rather than documented?

Through admission policy as code, default-deny network policy, image signature verification, external secrets management and workload identity federation. Each control is proven by attempting the forbidden action and recording the refusal, which is the evidence an auditor actually asks for. The wider control set sits with Cybersecurity Services.

Will this reduce our cloud bill?

Usually, but not immediately and not automatically. Rightsizing, spot capacity, autoscaling limits and orphan cleanup commonly lift utilisation from the teens to 55 or 70 per cent, while the platform itself adds a monitoring and registry cost. The saving arrives when quotas are enforced and cost has a named owner, which is why we treat FinOps and cloud cost optimisation as part of the build rather than a follow-on project.

Do you support multi-cloud?

We design for portability where it is cheap — standard images, declarative manifests, no unnecessary proprietary services — and we are direct about where it is not. Databases, identity, networking and managed queues differ materially between providers, and a claim of effortless multi-cloud usually means the design has not been tested against a real migration.

Commission a Container Platform Assessment

Send us the cluster inventory you have, the list of workloads you want to run, and the constraint you are most worried about — cost, headcount, resilience or audit. Within four weeks you will have an estate inventory, an architecture and policy review, a utilisation and cost analysis, a target platform design with a written rationale, and a costed plan covering consolidation, golden paths and workload waves, including the option of not building a platform at all and what that would cost.

Contact Unified Management Consulting to arrange a confidential first conversation.

Related Services

Kubernetes and container platform engineering is delivered with the practices around it:

Leave a Reply

Your email address will not be published. Required fields are marked *