Putting several customers on one Kubernetes cluster saves money. It also changes the security question from "can someone get into the cluster" to "can one customer's workload reach another customer's data". ReadyOn, which runs a workforce analytics platform called Harmony that handles payroll and organisation data for enterprise customers, has described how it answers that second question on a single shared Amazon EKS environment.
The design, published on the AWS Architecture Blog and covered by InfoQ on 26 October, uses four layers that are meant to overlap. ReadyOn does not expect any single layer to hold on its own.
What are the four layers?
Namespace. Every tenant gets its own namespace with RBAC, resource quotas, admission controls and network policies that deny traffic by default. Argo CD ApplicationSets generate all of this from Git, so every tenant gets the same baseline and manual changes are reverted automatically.
Compute. Karpenter gives each tenant its own node pool. Pods need two tolerations to be scheduled, one for the tenant and one for the workload type, and an admission controller checks that the tolerations a pod asks for match the tenant that owns its namespace. That stops a workload from simply claiming another tenant's nodes.
Network. Per-tenant VPC security groups only allow database connections from that tenant's node pool, on top of the Kubernetes network policies. The EKS API endpoint is private and reached through VPN, OpenID Connect and multi-factor authentication.
Data. Each tenant has its own Amazon Aurora cluster instead of sharing a database with row-level filtering. Secrets live under tenant-scoped paths in AWS Secrets Manager, workloads get short-lived credentials through IAM Roles for Service Accounts, and each tenant has its own observability backend.
ReadyOn says it built a ten-stage threat model focused on lateral movement from a compromised tenant workload, and that its adversarial testing has not found a working path between tenants so far.
Why are namespaces not enough on their own?
Namespaces, RBAC, quotas and network policies give you logical separation. They do not stop two tenants' pods from running on the same node and sharing a kernel. AWS's own guidance recommends node selectors, affinity rules or taints and tolerations when you need stronger separation, which is what ReadyOn's compute layer does.
The data layer is the expensive choice. A cluster per tenant costs more than a shared database, but it means a bug in a query filter cannot leak one customer's payroll data to another. For regulated data, that trade is usually easy to defend to an auditor.
One of the engineers quoted in the InfoQ piece made a point that is easy to skip: "Isolation depth without observability depth is indistinguishable from false confidence." If your traces cannot show which tenant identity made which database call, you cannot prove your isolation works.
What should a SaaS platform team copy?
Generate tenant setup from Git. Hand-built namespaces drift. A template that creates the namespace, quotas, policies and roles together, and puts them back when someone changes them, is the cheapest control on this list.
Check tolerations at admission. Taints only help if workloads cannot add whatever tolerations they like. Enforce the match between namespace and node pool with a policy engine.
Back up Kubernetes rules with cloud rules. A network policy is enforced inside the cluster. A security group is enforced by the cloud provider. Use both, so a mistake in one layer is not the end of the story.
Decide where data is shared, on purpose. Not every tenant needs its own database. Sort tenants by data sensitivity and contract terms, and give dedicated data stores to the ones that need them.
Test it like an attacker. Pick one tenant's workload, assume it is compromised, and try to reach another tenant. Repeat after every major platform change.
Quick answers
How does ReadyOn isolate tenants on Amazon EKS?
ReadyOn uses four overlapping layers on one shared EKS environment: a namespace per tenant with RBAC and default-deny network policies, a dedicated Karpenter node pool per tenant, per-tenant VPC security groups, and a dedicated Amazon Aurora cluster per tenant with tenant-scoped secrets.
Are Kubernetes namespaces enough for multi-tenant isolation?
No. Namespaces give logical separation, but pods from different namespaces can still share a node and its kernel. Stronger isolation needs dedicated nodes through taints, tolerations or affinity, plus network and data controls outside Kubernetes.
Should every tenant get its own database?
Not always. Dedicated databases cost more but remove the risk of one tenant reading another's data through a query bug. Teams usually reserve them for tenants with sensitive or regulated data.







