
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 |

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

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.
- Enterprise IT infrastructure management for Star TV — 24×7 monitoring, support and infrastructure management for a media and broadcasting company: the operating model a platform team inherits.
- Switching, routing and server-room setup for Global Hospitals — a multi-location healthcare network’s infrastructure stack, which is the on-premises estate a hybrid platform has to reconcile with.
- IT infrastructure support for Marriott Hotel and IT infrastructure for Fern Hotels & Resorts — multi-property hospitality estates where capacity follows occupancy rather than a forecast.
- Ez1.in Services: a ground-up e-commerce platform rebuild — a services-plus-products catalogue rebuilt from scratch, with its technical stack and system architecture documented.
- Mobile application development for a news company — a high-performance mobile estate where traffic follows events, which is the hardest capacity profile to plan against.
- Tech stack consolidation: the business case for unified systems — the argument for reducing the number of runtimes before adding a new one.
- AI infrastructure capacity and capital intensity — what accelerator scarcity and capacity economics mean for workloads you planned to schedule on a shared platform.
- AI transformation strategy for modern industries — the operating-model changes that make a platform investment pay back.
- Shadow AI: risks, discovery and governance — why ungoverned workloads appear, and how admission policy and identity reduce the incentive.
- The Technology insight archive — further writing on infrastructure, security and engineering practice.
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:
- Cloud Services & Migration (AWS, Azure, GCP) — the accounts, hosting architecture and migration work the platform is built inside
- DevOps & CI/CD Engineering — pipelines, environments and deployment discipline for estates that are not on Kubernetes
- Cloud Cost Optimisation & FinOps Services — commitment strategy, unit economics and the cost governance forum
- Cybersecurity Services & Solutions — the wider control set, testing and incident response
- Managed IT Infrastructure & AMC and Backup & Disaster Recovery — the operating model and the recovery obligations a platform inherits
- Computing, Server, Storage & Data Centre Engineering and Routing, Switching, Firewall & Network Engineering — the hybrid estate the platform has to reconcile with
- Enterprise Systems Integration — the ERP, CRM and legacy contracts workloads on the platform still depend on
- IT Staff Augmentation Services — named platform engineers where you need capacity rather than a programme
- Cloud Security Posture Management (CSPM) — estate discovery, CIS baseline assessment, identity and exposure review, drift control as policy, compliance evidence and a severity-ranked remediation register with named owners
- Site Reliability Engineering (SRE) & Observability — service inventory, SLOs and error budgets, metrics, logs and traces, dashboards with owners, alert routing, on-call design and blameless incident review
- Cloud-Native Application Modernisation — portfolio assessment and disposition, target architecture, strangler extraction, managed service and data migration, rehearsed cutover with a tested rollback, and hypercare
- Server Virtualisation (VMware / Hyper-V) Services — VMware and Hyper-V clusters, host sizing, cluster policy and the runbook that survives a host failure
- Hyperconverged Infrastructure (HCI) Services — hyperconverged clusters where compute, storage and availability are one licensing and one failure domain